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,339 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 1 | static __always_inline int __do_follow_link(struct path *path, struct nameidata *nd)
{
int error;
void *cookie;
struct dentry *dentry = path->dentry;
touch_atime(path->mnt, dentry);
nd_set_link(nd, NULL);
if (path->mnt != nd->path.mnt) {
path_to_nameidata(path, nd);
dget(dentry);
}
mntget(path->mnt);
... | 256,736,984,301,789,380,000,000,000,000,000,000,000 | namei.c | 213,658,505,254,054,250,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
1,341 | linux | 4291086b1f081b869c6d79e5b7441633dc3ace00 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4291086b1f081b869c6d79e5b7441633dc3ace00 | n_tty: Fix n_tty_write crash when echoing in raw mode
The tty atomic_write_lock does not provide an exclusion guarantee for
the tty driver if the termios settings are LECHO & !OPOST. And since
it is unexpected and not allowed to call TTY buffer helpers like
tty_insert_flip_string concurrently, this may lead to crashe... | 1 | static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
const unsigned char *buf, size_t nr)
{
const unsigned char *b = buf;
DECLARE_WAITQUEUE(wait, current);
int c;
ssize_t retval = 0;
/* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
if (L_TOSTOP(tty) && file->f_op->write ... | 177,764,399,866,911,630,000,000,000,000,000,000,000 | n_tty.c | 13,693,576,808,205,118,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-0196 | The n_tty_write function in drivers/tty/n_tty.c in the Linux kernel through 3.14.3 does not properly manage tty driver access in the "LECHO & !OPOST" case, which allows local users to cause a denial of service (memory corruption and system crash) or gain privileges by triggering a race condition involving read and writ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0196 |
1,342 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 1 | static void handle_rx(struct vhost_net *net)
{
struct vhost_net_virtqueue *nvq = &net->vqs[VHOST_NET_VQ_RX];
struct vhost_virtqueue *vq = &nvq->vq;
unsigned uninitialized_var(in), log;
struct vhost_log *vq_log;
struct msghdr msg = {
.msg_name = NULL,
.msg_namelen = 0,
.msg_control = NULL, /* FIXME: get and h... | 327,050,017,452,533,930,000,000,000,000,000,000,000 | net.c | 84,928,519,751,752,360,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
1,343 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 1 | cifs_iovec_write(struct file *file, const struct iovec *iov,
unsigned long nr_segs, loff_t *poffset)
{
unsigned long nr_pages, i;
size_t copied, len, cur_len;
ssize_t total_written = 0;
loff_t offset;
struct iov_iter it;
struct cifsFileInfo *open_file;
struct cifs_tcon *tcon;
struct cifs_sb_info *cifs_... | 82,332,909,522,185,400,000,000,000,000,000,000,000 | file.c | 284,112,246,344,305,900,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
1,344 | linux | a08d3b3b99efd509133946056531cdf8f3a0c09b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a08d3b3b99efd509133946056531cdf8f3a0c09b | kvm: x86: fix emulator buffer overflow (CVE-2014-0049)
The problem occurs when the guest performs a pusha with the stack
address pointing to an mmio address (or an invalid guest physical
address) to start with, but then extending into an ordinary guest
physical address. When doing repeated emulated pushes
emulator_re... | 1 | static int complete_emulated_mmio(struct kvm_vcpu *vcpu)
{
struct kvm_run *run = vcpu->run;
struct kvm_mmio_fragment *frag;
unsigned len;
BUG_ON(!vcpu->mmio_needed);
/* Complete previous fragment */
frag = &vcpu->mmio_fragments[vcpu->mmio_cur_fragment];
len = min(8u, frag->len);
if (!vcpu->mmio_is_write)
me... | 64,111,150,231,177,240,000,000,000,000,000,000,000 | x86.c | 98,159,114,997,778,440,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0049 | Buffer overflow in the complete_emulated_mmio function in arch/x86/kvm/x86.c in the Linux kernel before 3.13.6 allows guest OS users to execute arbitrary code on the host OS by leveraging a loop that triggers an invalid memory copy affecting certain cancel_work_item data. | https://nvd.nist.gov/vuln/detail/CVE-2014-0049 |
1,345 | linux | 2def2ef2ae5f3990aabdbe8a755911902707d268 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/2def2ef2ae5f3990aabdbe8a755911902707d268 | x86, x32: Correct invalid use of user timespec in the kernel
The x32 case for the recvmsg() timout handling is broken:
asmlinkage long compat_sys_recvmmsg(int fd, struct compat_mmsghdr __user *mmsg,
unsigned int vlen, unsigned int flags,
st... | 1 | asmlinkage long compat_sys_recvmmsg(int fd, struct compat_mmsghdr __user *mmsg,
unsigned int vlen, unsigned int flags,
struct compat_timespec __user *timeout)
{
int datagrams;
struct timespec ktspec;
if (flags & MSG_CMSG_COMPAT)
return -EINVAL;
if (COMPAT_USE_64BIT_TIME)
return __sys_recvmm... | 89,530,709,225,040,190,000,000,000,000,000,000,000 | compat.c | 107,634,465,611,674,530,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0038 | The compat_sys_recvmmsg function in net/compat.c in the Linux kernel before 3.13.2, when CONFIG_X86_X32 is enabled, allows local users to gain privileges via a recvmmsg system call with a crafted timeout pointer parameter. | https://nvd.nist.gov/vuln/detail/CVE-2014-0038 |
1,346 | linux | d558023207e008a4476a3b7bb8706b2a2bf5d84f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d558023207e008a4476a3b7bb8706b2a2bf5d84f | aio: prevent double free in ioctx_alloc
ioctx_alloc() calls aio_setup_ring() to allocate a ring. If aio_setup_ring()
fails to do so it would call aio_free_ring() before returning, but
ioctx_alloc() would call aio_free_ring() again causing a double free of
the ring.
This is easily reproducible from userspace.
Signed-... | 1 | static struct kioctx *ioctx_alloc(unsigned nr_events)
{
struct mm_struct *mm = current->mm;
struct kioctx *ctx;
int err = -ENOMEM;
/*
* We keep track of the number of available ringbuffer slots, to prevent
* overflow (reqs_available), and we also use percpu counters for this.
*
* So since up to half the sl... | 338,752,304,203,713,800,000,000,000,000,000,000,000 | aio.c | 50,064,682,128,123,810,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-7348 | Double free vulnerability in the ioctx_alloc function in fs/aio.c in the Linux kernel before 3.12.4 allows local users to cause a denial of service (system crash) or possibly have unspecified other impact via vectors involving an error condition in the aio_setup_ring function. | https://nvd.nist.gov/vuln/detail/CVE-2013-7348 |
1,347 | linux | c2349758acf1874e4c2b93fe41d072336f1a31d0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2349758acf1874e4c2b93fe41d072336f1a31d0 | rds: prevent dereference of a NULL device
Binding might result in a NULL device, which is dereferenced
causing this BUG:
[ 1317.260548] BUG: unable to handle kernel NULL pointer dereference at 000000000000097
4
[ 1317.261847] IP: [<ffffffff84225f52>] rds_ib_laddr_check+0x82/0x110
[ 1317.263315] PGD 418bcb067 PUD 3ceb... | 1 | static int rds_ib_laddr_check(__be32 addr)
{
int ret;
struct rdma_cm_id *cm_id;
struct sockaddr_in sin;
/* Create a CMA ID and try to bind it. This catches both
* IB and iWARP capable NICs.
*/
cm_id = rdma_create_id(NULL, NULL, RDMA_PS_TCP, IB_QPT_RC);
if (IS_ERR(cm_id))
return PTR_ERR(cm_id);
memset(&si... | 264,896,393,456,312,270,000,000,000,000,000,000,000 | ib.c | 188,272,071,066,765,100,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-7339 | The rds_ib_laddr_check function in net/rds/ib.c in the Linux kernel before 3.12.8 allows local users to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact via a bind system call for an RDS socket on a system that lacks RDS transports. | https://nvd.nist.gov/vuln/detail/CVE-2013-7339 |
1,348 | linux | bceaa90240b6019ed73b49965eac7d167610be69 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bceaa90240b6019ed73b49965eac7d167610be69 | inet: prevent leakage of uninitialized memory to user in recv syscalls
Only update *addr_len when we actually fill in sockaddr, otherwise we
can return uninitialized memory from the stack to the caller in the
recvfrom, recvmmsg and recvmsg syscalls. Drop the the (addr_len == NULL)
checks because we only get called wit... | 1 | static int dgram_recvmsg(struct kiocb *iocb, struct sock *sk,
struct msghdr *msg, size_t len, int noblock, int flags,
int *addr_len)
{
size_t copied = 0;
int err = -EOPNOTSUPP;
struct sk_buff *skb;
struct sockaddr_ieee802154 *saddr;
saddr = (struct sockaddr_ieee802154 *)msg->msg_name;
skb = skb_recv_datagra... | 189,468,429,727,011,170,000,000,000,000,000,000,000 | dgram.c | 336,326,295,596,065,970,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-7265 | The pn_recvmsg function in net/phonet/datagram.c in the Linux kernel before 3.12.4 updates a certain length value before ensuring that an associated data structure has been initialized, which allows local users to obtain sensitive information from kernel stack memory via a (1) recvfrom, (2) recvmmsg, or (3) recvmsg sys... | https://nvd.nist.gov/vuln/detail/CVE-2013-7265 |
1,349 | linux | bceaa90240b6019ed73b49965eac7d167610be69 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bceaa90240b6019ed73b49965eac7d167610be69 | inet: prevent leakage of uninitialized memory to user in recv syscalls
Only update *addr_len when we actually fill in sockaddr, otherwise we
can return uninitialized memory from the stack to the caller in the
recvfrom, recvmmsg and recvmsg syscalls. Drop the the (addr_len == NULL)
checks because we only get called wit... | 1 | int ping_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
size_t len, int noblock, int flags, int *addr_len)
{
struct inet_sock *isk = inet_sk(sk);
int family = sk->sk_family;
struct sockaddr_in *sin;
struct sockaddr_in6 *sin6;
struct sk_buff *skb;
int copied, err;
pr_debug("ping_recvms... | 121,858,951,950,899,140,000,000,000,000,000,000,000 | ping.c | 314,193,521,440,058,100,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-7265 | The pn_recvmsg function in net/phonet/datagram.c in the Linux kernel before 3.12.4 updates a certain length value before ensuring that an associated data structure has been initialized, which allows local users to obtain sensitive information from kernel stack memory via a (1) recvfrom, (2) recvmmsg, or (3) recvmsg sys... | https://nvd.nist.gov/vuln/detail/CVE-2013-7265 |
1,354 | linux | bceaa90240b6019ed73b49965eac7d167610be69 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bceaa90240b6019ed73b49965eac7d167610be69 | inet: prevent leakage of uninitialized memory to user in recv syscalls
Only update *addr_len when we actually fill in sockaddr, otherwise we
can return uninitialized memory from the stack to the caller in the
recvfrom, recvmmsg and recvmsg syscalls. Drop the the (addr_len == NULL)
checks because we only get called wit... | 1 | static int l2tp_ip_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
size_t len, int noblock, int flags, int *addr_len)
{
struct inet_sock *inet = inet_sk(sk);
size_t copied = 0;
int err = -EOPNOTSUPP;
struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
struct sk_buff *skb;
if (f... | 263,984,241,115,726,000,000,000,000,000,000,000,000 | l2tp_ip.c | 55,758,294,290,170,330,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-7265 | The pn_recvmsg function in net/phonet/datagram.c in the Linux kernel before 3.12.4 updates a certain length value before ensuring that an associated data structure has been initialized, which allows local users to obtain sensitive information from kernel stack memory via a (1) recvfrom, (2) recvmmsg, or (3) recvmsg sys... | https://nvd.nist.gov/vuln/detail/CVE-2013-7265 |
1,355 | linux | bceaa90240b6019ed73b49965eac7d167610be69 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/bceaa90240b6019ed73b49965eac7d167610be69 | inet: prevent leakage of uninitialized memory to user in recv syscalls
Only update *addr_len when we actually fill in sockaddr, otherwise we
can return uninitialized memory from the stack to the caller in the
recvfrom, recvmmsg and recvmsg syscalls. Drop the the (addr_len == NULL)
checks because we only get called wit... | 1 | static int pn_recvmsg(struct kiocb *iocb, struct sock *sk,
struct msghdr *msg, size_t len, int noblock,
int flags, int *addr_len)
{
struct sk_buff *skb = NULL;
struct sockaddr_pn sa;
int rval = -EOPNOTSUPP;
int copylen;
if (flags & ~(MSG_PEEK|MSG_TRUNC|MSG_DONTWAIT|MSG_NOSIGNAL|
MSG_CMSG_COMPAT))
got... | 225,152,650,498,232,850,000,000,000,000,000,000,000 | datagram.c | 134,059,696,568,289,560,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-7265 | The pn_recvmsg function in net/phonet/datagram.c in the Linux kernel before 3.12.4 updates a certain length value before ensuring that an associated data structure has been initialized, which allows local users to obtain sensitive information from kernel stack memory via a (1) recvfrom, (2) recvmmsg, or (3) recvmsg sys... | https://nvd.nist.gov/vuln/detail/CVE-2013-7265 |
1,357 | linux | f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | net: rework recvmsg handler msg_name and msg_namelen logic
This patch now always passes msg->msg_namelen as 0. recvmsg handlers must
set msg_namelen to the proper size <= sizeof(struct sockaddr_storage)
to return msg_name to the user.
This prevents numerous uninitialized memory leaks we had in the
recvmsg handlers an... | 1 | mISDN_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
struct sk_buff *skb;
struct sock *sk = sock->sk;
struct sockaddr_mISDN *maddr;
int copied, err;
if (*debug & DEBUG_SOCKET)
printk(KERN_DEBUG "%s: len %d, flags %x ch.nr %d, proto %x\n",
... | 25,902,652,839,543,214,000,000,000,000,000,000,000 | socket.c | 259,087,261,855,917,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-7270 | The packet_recvmsg function in net/packet/af_packet.c in the Linux kernel before 3.12.4 updates a certain length value before ensuring that an associated data structure has been initialized, which allows local users to obtain sensitive information from kernel memory via a (1) recvfrom, (2) recvmmsg, or (3) recvmsg syst... | https://nvd.nist.gov/vuln/detail/CVE-2013-7270 |
1,359 | linux | f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | net: rework recvmsg handler msg_name and msg_namelen logic
This patch now always passes msg->msg_namelen as 0. recvmsg handlers must
set msg_namelen to the proper size <= sizeof(struct sockaddr_storage)
to return msg_name to the user.
This prevents numerous uninitialized memory leaks we had in the
recvmsg handlers an... | 1 | static int atalk_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
size_t size, int flags)
{
struct sock *sk = sock->sk;
struct sockaddr_at *sat = (struct sockaddr_at *)msg->msg_name;
struct ddpehdr *ddp;
int copied = 0;
int offset = 0;
int err = 0;
struct sk_buff *skb;
skb = skb_r... | 30,146,679,912,109,750,000,000,000,000,000,000,000 | ddp.c | 206,398,089,062,534,550,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-7270 | The packet_recvmsg function in net/packet/af_packet.c in the Linux kernel before 3.12.4 updates a certain length value before ensuring that an associated data structure has been initialized, which allows local users to obtain sensitive information from kernel memory via a (1) recvfrom, (2) recvmmsg, or (3) recvmsg syst... | https://nvd.nist.gov/vuln/detail/CVE-2013-7270 |
1,370 | linux | f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | net: rework recvmsg handler msg_name and msg_namelen logic
This patch now always passes msg->msg_namelen as 0. recvmsg handlers must
set msg_namelen to the proper size <= sizeof(struct sockaddr_storage)
to return msg_name to the user.
This prevents numerous uninitialized memory leaks we had in the
recvmsg handlers an... | 1 | static int ipx_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t size, int flags)
{
struct sock *sk = sock->sk;
struct ipx_sock *ipxs = ipx_sk(sk);
struct sockaddr_ipx *sipx = (struct sockaddr_ipx *)msg->msg_name;
struct ipxhdr *ipx = NULL;
struct sk_buff *skb;
int copied, rc;
lock_s... | 112,645,242,093,379,780,000,000,000,000,000,000,000 | af_ipx.c | 127,064,475,985,704,280,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-7270 | The packet_recvmsg function in net/packet/af_packet.c in the Linux kernel before 3.12.4 updates a certain length value before ensuring that an associated data structure has been initialized, which allows local users to obtain sensitive information from kernel memory via a (1) recvfrom, (2) recvmmsg, or (3) recvmsg syst... | https://nvd.nist.gov/vuln/detail/CVE-2013-7270 |
1,378 | linux | f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | net: rework recvmsg handler msg_name and msg_namelen logic
This patch now always passes msg->msg_namelen as 0. recvmsg handlers must
set msg_namelen to the proper size <= sizeof(struct sockaddr_storage)
to return msg_name to the user.
This prevents numerous uninitialized memory leaks we had in the
recvmsg handlers an... | 1 | static int nr_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t size, int flags)
{
struct sock *sk = sock->sk;
struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
size_t copied;
struct sk_buff *skb;
int er;
/*
* This works for seqpacket too. The receiver has ord... | 122,095,893,171,554,320,000,000,000,000,000,000,000 | af_netrom.c | 227,993,719,544,841,100,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-7270 | The packet_recvmsg function in net/packet/af_packet.c in the Linux kernel before 3.12.4 updates a certain length value before ensuring that an associated data structure has been initialized, which allows local users to obtain sensitive information from kernel memory via a (1) recvfrom, (2) recvmmsg, or (3) recvmsg syst... | https://nvd.nist.gov/vuln/detail/CVE-2013-7270 |
1,381 | linux | f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | net: rework recvmsg handler msg_name and msg_namelen logic
This patch now always passes msg->msg_namelen as 0. recvmsg handlers must
set msg_namelen to the proper size <= sizeof(struct sockaddr_storage)
to return msg_name to the user.
This prevents numerous uninitialized memory leaks we had in the
recvmsg handlers an... | 1 | static int packet_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
struct sock *sk = sock->sk;
struct sk_buff *skb;
int copied, err;
struct sockaddr_ll *sll;
int vnet_hdr_len = 0;
err = -EINVAL;
if (flags & ~(MSG_PEEK|MSG_DONTWAIT|MSG_TRUNC|MSG_CMSG_COMPAT... | 264,606,051,361,135,500,000,000,000,000,000,000,000 | af_packet.c | 336,820,861,216,337,700,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-7270 | The packet_recvmsg function in net/packet/af_packet.c in the Linux kernel before 3.12.4 updates a certain length value before ensuring that an associated data structure has been initialized, which allows local users to obtain sensitive information from kernel memory via a (1) recvfrom, (2) recvmmsg, or (3) recvmsg syst... | https://nvd.nist.gov/vuln/detail/CVE-2013-7270 |
1,394 | linux | f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | net: rework recvmsg handler msg_name and msg_namelen logic
This patch now always passes msg->msg_namelen as 0. recvmsg handlers must
set msg_namelen to the proper size <= sizeof(struct sockaddr_storage)
to return msg_name to the user.
This prevents numerous uninitialized memory leaks we had in the
recvmsg handlers an... | 1 | static int x25_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t size,
int flags)
{
struct sock *sk = sock->sk;
struct x25_sock *x25 = x25_sk(sk);
struct sockaddr_x25 *sx25 = (struct sockaddr_x25 *)msg->msg_name;
size_t copied;
int qbit, header_len;
struct sk_buff *skb;... | 87,996,953,335,419,640,000,000,000,000,000,000,000 | af_x25.c | 108,395,192,628,085,570,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-7270 | The packet_recvmsg function in net/packet/af_packet.c in the Linux kernel before 3.12.4 updates a certain length value before ensuring that an associated data structure has been initialized, which allows local users to obtain sensitive information from kernel memory via a (1) recvfrom, (2) recvmmsg, or (3) recvmsg syst... | https://nvd.nist.gov/vuln/detail/CVE-2013-7270 |
1,395 | mapserver | 3a10f6b829297dae63492a8c63385044bc6953ed | https://github.com/mapserver/mapserver | https://github.com/mapserver/mapserver/commit/3a10f6b829297dae63492a8c63385044bc6953ed | Fix potential SQL Injection with postgis TIME filters (#4834) | 1 | int msPostGISLayerSetTimeFilter(layerObj *lp, const char *timestring, const char *timefield)
{
char **atimes, **aranges = NULL;
int numtimes=0,i=0,numranges=0;
size_t buffer_size = 512;
char buffer[512], bufferTmp[512];
buffer[0] = '\0';
bufferTmp[0] = '\0';
if (!lp || !timestring || !timefield)
r... | 92,160,701,703,090,280,000,000,000,000,000,000,000 | mappostgis.c | 273,968,548,871,858,860,000,000,000,000,000,000,000 | [
"CWE-89"
] | CVE-2013-7262 | SQL injection vulnerability in the msPostGISLayerSetTimeFilter function in mappostgis.c in MapServer before 6.4.1, when a WMS-Time service is used, allows remote attackers to execute arbitrary SQL commands via a crafted string in a PostGIS TIME filter. | https://nvd.nist.gov/vuln/detail/CVE-2013-7262 |
1,412 | Little-CMS | 91c2db7f2559be504211b283bc3a2c631d6f06d9 | https://github.com/mm2/Little-CMS | https://github.com/mm2/Little-CMS/commit/91c2db7f2559be504211b283bc3a2c631d6f06d9 | Non happy-path fixes | 1 | Curves16Data* CurvesAlloc(cmsContext ContextID, int nCurves, int nElements, cmsToneCurve** G)
{
int i, j;
Curves16Data* c16;
c16 = _cmsMallocZero(ContextID, sizeof(Curves16Data));
if (c16 == NULL) return NULL;
c16 ->nCurves = nCurves;
c16 ->nElements = nElements;
c16 ->Curves = _cmsCalloc... | 147,209,237,771,980,330,000,000,000,000,000,000,000 | cmsopt.c | 290,419,189,479,580,550,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2013-4160 | Little CMS (lcms2) before 2.5, as used in OpenJDK 7 and possibly other products, allows remote attackers to cause a denial of service (NULL pointer dereference and crash) via vectors related to (1) cmsStageAllocLabV2ToV4curves, (2) cmsPipelineDup, (3) cmsAllocProfileSequenceDescription, (4) CurvesAlloc, and (5) cmsname... | https://nvd.nist.gov/vuln/detail/CVE-2013-4160 |
1,413 | monkey | 15f72c1ee5e0afad20232bdf0fcecab8d62a5d89 | https://github.com/monkey/monkey | https://github.com/monkey/monkey/commit/15f72c1ee5e0afad20232bdf0fcecab8d62a5d89 | Mandril: check decoded URI (fix #92)
Signed-off-by: Eduardo Silva <eduardo@monkey.io> | 1 | int _mkp_stage_30(struct plugin *p,
struct client_session *cs,
struct session_request *sr)
{
mk_ptr_t referer;
(void) p;
(void) cs;
PLUGIN_TRACE("[FD %i] Mandril validating URL", cs->socket);
if (mk_security_check_url(sr->uri) < 0) {
PLUGIN_TRACE("[FD %i] Close connectio... | 131,927,884,398,444,160,000,000,000,000,000,000,000 | mandril.c | 309,060,299,715,844,330,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2013-2182 | The Mandril security plugin in Monkey HTTP Daemon (monkeyd) before 1.5.0 allows remote attackers to bypass access restrictions via a crafted URI, as demonstrated by an encoded forward slash. | https://nvd.nist.gov/vuln/detail/CVE-2013-2182 |
1,414 | corosync | b3f456a8ceefac6e9f2e9acc2ea0c159d412b595 | https://github.com/corosync/corosync | https://github.com/corosync/corosync/commit/b3f456a8ceefac6e9f2e9acc2ea0c159d412b595 | totemcrypto: fix hmac key initialization
Signed-off-by: Fabio M. Di Nitto <fdinitto@redhat.com>
Reviewed-by: Jan Friesse <jfriesse@redhat.com> | 1 | static int init_nss_hash(struct crypto_instance *instance)
{
PK11SlotInfo* hash_slot = NULL;
SECItem hash_param;
if (!hash_to_nss[instance->crypto_hash_type]) {
return 0;
}
hash_param.type = siBuffer;
hash_param.data = 0;
hash_param.len = 0;
hash_slot = PK11_GetBestSlot(hash_to_nss[instance->crypto_h... | 114,430,622,650,469,530,000,000,000,000,000,000,000 | totemcrypto.c | 276,803,209,648,777,200,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2013-0250 | The init_nss_hash function in exec/totemcrypto.c in Corosync 2.0 before 2.3 does not properly initialize the HMAC key, which allows remote attackers to cause a denial of service (crash) via a crafted packet. | https://nvd.nist.gov/vuln/detail/CVE-2013-0250 |
1,415 | linux | 3e10986d1d698140747fcfc2761ec9cb64c1d582 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/3e10986d1d698140747fcfc2761ec9cb64c1d582 | net: guard tcp_set_keepalive() to tcp sockets
Its possible to use RAW sockets to get a crash in
tcp_set_keepalive() / sk_reset_timer()
Fix is to make sure socket is a SOCK_STREAM one.
Reported-by: Dave Jones <davej@redhat.com>
Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@da... | 1 | int sock_setsockopt(struct socket *sock, int level, int optname,
char __user *optval, unsigned int optlen)
{
struct sock *sk = sock->sk;
int val;
int valbool;
struct linger ling;
int ret = 0;
/*
* Options without arguments
*/
if (optname == SO_BINDTODEVICE)
return sock_bindtodevice(sk, optval, optl... | 34,524,812,571,381,987,000,000,000,000,000,000,000 | sock.c | 200,974,059,219,055,230,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2012-6657 | The sock_setsockopt function in net/core/sock.c in the Linux kernel before 3.5.7 does not ensure that a keepalive action is associated with a stream socket, which allows local users to cause a denial of service (system crash) by leveraging the ability to create a raw socket. | https://nvd.nist.gov/vuln/detail/CVE-2012-6657 |
1,416 | linux | 6f7b0a2a5c0fb03be7c25bd1745baa50582348ef | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6f7b0a2a5c0fb03be7c25bd1745baa50582348ef | futex: Forbid uaddr == uaddr2 in futex_wait_requeue_pi()
If uaddr == uaddr2, then we have broken the rule of only requeueing
from a non-pi futex to a pi futex with this call. If we attempt this,
as the trinity test suite manages to do, we miss early wakeups as
q.key is equal to key2 (because they are the same uaddr). ... | 1 | static int futex_wait_requeue_pi(u32 __user *uaddr, unsigned int flags,
u32 val, ktime_t *abs_time, u32 bitset,
u32 __user *uaddr2)
{
struct hrtimer_sleeper timeout, *to = NULL;
struct rt_mutex_waiter rt_waiter;
struct rt_mutex *pi_mutex = NULL;
struct futex_hash_bucket *hb;
union futex_key key2 = FUTEX_... | 97,517,838,480,806,140,000,000,000,000,000,000,000 | futex.c | 161,971,375,377,535,860,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-6647 | The futex_wait_requeue_pi function in kernel/futex.c in the Linux kernel before 3.5.1 does not ensure that calls have two different futex addresses, which allows local users to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact via a crafted FUTEX_WAIT_REQUEU... | https://nvd.nist.gov/vuln/detail/CVE-2012-6647 |
1,417 | linux | fdf5af0daf8019cec2396cdef8fb042d80fe71fa | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/fdf5af0daf8019cec2396cdef8fb042d80fe71fa | tcp: drop SYN+FIN messages
Denys Fedoryshchenko reported that SYN+FIN attacks were bringing his
linux machines to their limits.
Dont call conn_request() if the TCP flags includes SYN flag
Reported-by: Denys Fedoryshchenko <denys@visp.net.lb>
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S... | 1 | int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
const struct tcphdr *th, unsigned int len)
{
struct tcp_sock *tp = tcp_sk(sk);
struct inet_connection_sock *icsk = inet_csk(sk);
int queued = 0;
int res;
tp->rx_opt.saw_tstamp = 0;
switch (sk->sk_state) {
case TCP_CLOSE:
goto discard;
cas... | 47,732,656,845,780,370,000,000,000,000,000,000,000 | tcp_input.c | 112,625,197,681,995,050,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2012-6638 | The tcp_rcv_state_process function in net/ipv4/tcp_input.c in the Linux kernel before 3.2.24 allows remote attackers to cause a denial of service (kernel resource consumption) via a flood of SYN+FIN TCP packets, a different vulnerability than CVE-2012-2663. | https://nvd.nist.gov/vuln/detail/CVE-2012-6638 |
1,418 | radvd | 92e22ca23e52066da2258df8c76a2dca8a428bcc | https://github.com/reubenhwk/radvd | https://github.com/reubenhwk/radvd/commit/92e22ca23e52066da2258df8c76a2dca8a428bcc | set_interface_var() doesn't check interface name and blindly does
fopen(path "/" ifname, "w") on it. As "ifname" is an untrusted input, it
should be checked for ".." and/or "/" in it. Otherwise, an infected
unprivileged daemon may overwrite contents of file named "mtu",
"hoplimit", etc. in arbitrary location with arb... | 1 | set_interface_var(const char *iface,
const char *var, const char *name,
uint32_t val)
{
FILE *fp;
char spath[64+IFNAMSIZ]; /* XXX: magic constant */
if (snprintf(spath, sizeof(spath), var, iface) >= sizeof(spath))
return -1;
if (access(spath, F_OK) != 0)
return -1;
fp = fopen(spath, "w");
if (... | 281,398,530,467,193,600,000,000,000,000,000,000,000 | device-linux.c | 290,895,116,251,977,450,000,000,000,000,000,000,000 | [
"CWE-22"
] | CVE-2011-3602 | Directory traversal vulnerability in device-linux.c in the router advertisement daemon (radvd) before 1.8.2 allows local users to overwrite arbitrary files, and remote attackers to overwrite certain files, via a .. (dot dot) in an interface name. NOTE: this can be leveraged with a symlink to overwrite arbitrary files. | https://nvd.nist.gov/vuln/detail/CVE-2011-3602 |
1,419 | linux | 819cbb120eaec7e014e5abd029260db1ca8c5735 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/819cbb120eaec7e014e5abd029260db1ca8c5735 | staging: comedi: fix infoleak to userspace
driver_name and board_name are pointers to strings, not buffers of size
COMEDI_NAMELEN. Copying COMEDI_NAMELEN bytes of a string containing
less than COMEDI_NAMELEN-1 bytes would leak some unrelated bytes.
Signed-off-by: Vasiliy Kulikov <segoon@openwall.com>
Cc: stable <sta... | 1 | static int do_devinfo_ioctl(struct comedi_device *dev,
struct comedi_devinfo __user *arg,
struct file *file)
{
struct comedi_devinfo devinfo;
const unsigned minor = iminor(file->f_dentry->d_inode);
struct comedi_device_file_info *dev_file_info =
comedi_get_device_file_info(minor);
struct comedi_s... | 274,220,629,135,533,150,000,000,000,000,000,000,000 | comedi_fops.c | 50,834,563,733,571,210,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2011-2909 | The do_devinfo_ioctl function in drivers/staging/comedi/comedi_fops.c in the Linux kernel before 3.1 allows local users to obtain sensitive information from kernel memory via a copy of a short string. | https://nvd.nist.gov/vuln/detail/CVE-2011-2909 |
1,420 | linux | fc3a9157d3148ab91039c75423da8ef97be3e105 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/fc3a9157d3148ab91039c75423da8ef97be3e105 | KVM: X86: Don't report L2 emulation failures to user-space
This patch prevents that emulation failures which result
from emulating an instruction for an L2-Guest results in
being reported to userspace.
Without this patch a malicious L2-Guest would be able to
kill the L1 by triggering a race-condition between an vmexit... | 1 | static int handle_emulation_failure(struct kvm_vcpu *vcpu)
{
++vcpu->stat.insn_emulation_fail;
trace_kvm_emulate_insn_failed(vcpu);
vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;
vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION;
vcpu->run->internal.ndata = 0;
kvm_queue_exception(vcpu, UD_VECTOR... | 279,029,284,746,417,500,000,000,000,000,000,000,000 | x86.c | 157,489,028,681,611,200,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2010-5313 | Race condition in arch/x86/kvm/x86.c in the Linux kernel before 2.6.38 allows L2 guest OS users to cause a denial of service (L1 guest OS crash) via a crafted instruction that triggers an L2 emulation failure report, a similar issue to CVE-2014-7842. | https://nvd.nist.gov/vuln/detail/CVE-2010-5313 |
1,421 | linux | acff81ec2c79492b180fade3c2894425cd35a545 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/acff81ec2c79492b180fade3c2894425cd35a545 | ovl: fix permission checking for setattr
[Al Viro] The bug is in being too enthusiastic about optimizing ->setattr()
away - instead of "copy verbatim with metadata" + "chmod/chown/utimes"
(with the former being always safe and the latter failing in case of
insufficient permissions) it tries to combine these two. Note... | 1 | int ovl_setattr(struct dentry *dentry, struct iattr *attr)
{
int err;
struct dentry *upperdentry;
err = ovl_want_write(dentry);
if (err)
goto out;
upperdentry = ovl_dentry_upper(dentry);
if (upperdentry) {
mutex_lock(&upperdentry->d_inode->i_mutex);
err = notify_change(upperdentry, attr, NULL);
mu... | 126,591,340,298,897,650,000,000,000,000,000,000,000 | inode.c | 334,612,864,203,734,400,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2015-8660 | The ovl_setattr function in fs/overlayfs/inode.c in the Linux kernel through 4.3.3 attempts to merge distinct setattr operations, which allows local users to bypass intended access restrictions and modify the attributes of arbitrary overlay files via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2015-8660 |
1,422 | linux | 09ccfd238e5a0e670d8178cf50180ea81ae09ae1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/09ccfd238e5a0e670d8178cf50180ea81ae09ae1 | pptp: verify sockaddr_len in pptp_bind() and pptp_connect()
Reported-by: Dmitry Vyukov <dvyukov@gmail.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net> | 1 | static int pptp_bind(struct socket *sock, struct sockaddr *uservaddr,
int sockaddr_len)
{
struct sock *sk = sock->sk;
struct sockaddr_pppox *sp = (struct sockaddr_pppox *) uservaddr;
struct pppox_sock *po = pppox_sk(sk);
struct pptp_opt *opt = &po->proto.pptp;
int error = 0;
lock_sock(sk);
opt->src_addr... | 83,894,244,210,840,040,000,000,000,000,000,000,000 | pptp.c | 269,998,178,809,154,600,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2015-8569 | The (1) pptp_bind and (2) pptp_connect functions in drivers/net/ppp/pptp.c in the Linux kernel through 4.3.3 do not verify an address length, which allows local users to obtain sensitive information from kernel memory and bypass the KASLR protection mechanism via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2015-8569 |
1,423 | linux | 09ccfd238e5a0e670d8178cf50180ea81ae09ae1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/09ccfd238e5a0e670d8178cf50180ea81ae09ae1 | pptp: verify sockaddr_len in pptp_bind() and pptp_connect()
Reported-by: Dmitry Vyukov <dvyukov@gmail.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net> | 1 | static int pptp_connect(struct socket *sock, struct sockaddr *uservaddr,
int sockaddr_len, int flags)
{
struct sock *sk = sock->sk;
struct sockaddr_pppox *sp = (struct sockaddr_pppox *) uservaddr;
struct pppox_sock *po = pppox_sk(sk);
struct pptp_opt *opt = &po->proto.pptp;
struct rtable *rt;
struct flowi4 fl4;... | 246,845,620,878,079,550,000,000,000,000,000,000,000 | pptp.c | 269,998,178,809,154,600,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2015-8569 | The (1) pptp_bind and (2) pptp_connect functions in drivers/net/ppp/pptp.c in the Linux kernel through 4.3.3 do not verify an address length, which allows local users to obtain sensitive information from kernel memory and bypass the KASLR protection mechanism via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2015-8569 |
1,433 | linux | 8c7188b23474cca017b3ef354c4a58456f68303a | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8c7188b23474cca017b3ef354c4a58456f68303a | RDS: fix race condition when sending a message on unbound socket
Sasha's found a NULL pointer dereference in the RDS connection code when
sending a message to an apparently unbound socket. The problem is caused
by the code checking if the socket is bound in rds_sendmsg(), which checks
the rs_bound_addr field without ... | 1 | int rds_sendmsg(struct socket *sock, struct msghdr *msg, size_t payload_len)
{
struct sock *sk = sock->sk;
struct rds_sock *rs = rds_sk_to_rs(sk);
DECLARE_SOCKADDR(struct sockaddr_in *, usin, msg->msg_name);
__be32 daddr;
__be16 dport;
struct rds_message *rm = NULL;
struct rds_connection *conn;
int ret = 0;
in... | 63,125,872,970,388,840,000,000,000,000,000,000,000 | send.c | 261,842,697,984,098,440,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2015-7990 | Race condition in the rds_sendmsg function in net/rds/sendmsg.c in the Linux kernel before 4.3.3 allows local users to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by using a socket that was not properly bound. NOTE: this vulnerability exists because o... | https://nvd.nist.gov/vuln/detail/CVE-2015-7990 |
1,434 | linux | 4b6184336ebb5c8dc1eae7f7ab46ee608a748b05 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4b6184336ebb5c8dc1eae7f7ab46ee608a748b05 | staging/dgnc: fix info leak in ioctl
The dgnc_mgmt_ioctl() code fails to initialize the 16 _reserved bytes of
struct digi_dinfo after the ->dinfo_nboards member. Add an explicit
memset(0) before filling the structure to avoid the info leak.
Signed-off-by: Salva Peiró <speirofr@gmail.com>
Signed-off-by: Greg Kroah-Har... | 1 | long dgnc_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
unsigned long flags;
void __user *uarg = (void __user *)arg;
switch (cmd) {
case DIGI_GETDD:
{
/*
* This returns the total number of boards
* in the system, as well as driver version
* and has space for a reserved entry
*... | 193,364,450,923,515,900,000,000,000,000,000,000,000 | dgnc_mgmt.c | 195,319,938,365,409,150,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2015-7885 | The dgnc_mgmt_ioctl function in drivers/staging/dgnc/dgnc_mgmt.c in the Linux kernel through 4.3.3 does not initialize a certain structure member, which allows local users to obtain sensitive information from kernel memory via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2015-7885 |
1,435 | linux | eda98796aff0d9bf41094b06811f5def3b4c333c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/eda98796aff0d9bf41094b06811f5def3b4c333c | [media] media/vivid-osd: fix info leak in ioctl
The vivid_fb_ioctl() code fails to initialize the 16 _reserved bytes of
struct fb_vblank after the ->hcount member. Add an explicit
memset(0) before filling the structure to avoid the info leak.
Signed-off-by: Salva Peiró <speirofr@gmail.com>
Signed-off-by: Hans Verkuil... | 1 | static int vivid_fb_ioctl(struct fb_info *info, unsigned cmd, unsigned long arg)
{
struct vivid_dev *dev = (struct vivid_dev *)info->par;
switch (cmd) {
case FBIOGET_VBLANK: {
struct fb_vblank vblank;
vblank.flags = FB_VBLANK_HAVE_COUNT | FB_VBLANK_HAVE_VCOUNT |
FB_VBLANK_HAVE_VSYNC;
vblank.count = ... | 326,103,382,253,395,940,000,000,000,000,000,000,000 | vivid-osd.c | 31,449,737,973,003,174,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2015-7884 | The vivid_fb_ioctl function in drivers/media/platform/vivid/vivid-osd.c in the Linux kernel through 4.3.3 does not initialize a certain structure member, which allows local users to obtain sensitive information from kernel memory via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2015-7884 |
1,436 | linux | ce1fad2740c648a4340f6f6c391a8a83769d2e8c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ce1fad2740c648a4340f6f6c391a8a83769d2e8c | Merge branch 'keys-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs
Pull key handling fixes from David Howells:
"Here are two patches, the first of which at least should go upstream
immediately:
(1) Prevent a user-triggerable crash in the keyrings destructor when a
negatively insta... | 1 | static noinline void key_gc_unused_keys(struct list_head *keys)
{
while (!list_empty(keys)) {
struct key *key =
list_entry(keys->next, struct key, graveyard_link);
list_del(&key->graveyard_link);
kdebug("- %u", key->serial);
key_check(key);
/* Throw away the key data */
if (key->type->destroy)
... | 121,918,299,636,917,930,000,000,000,000,000,000,000 | gc.c | 241,205,744,750,980,900,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2015-7872 | The key_gc_unused_keys function in security/keys/gc.c in the Linux kernel through 4.2.6 allows local users to cause a denial of service (OOPS) via crafted keyctl commands. | https://nvd.nist.gov/vuln/detail/CVE-2015-7872 |
1,437 | linux | b9a532277938798b53178d5a66af6e2915cb27cf | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9a532277938798b53178d5a66af6e2915cb27cf | Initialize msg/shm IPC objects before doing ipc_addid()
As reported by Dmitry Vyukov, we really shouldn't do ipc_addid() before
having initialized the IPC object state. Yes, we initialize the IPC
object in a locked state, but with all the lockless RCU lookup work,
that IPC object lock no longer means that the state c... | 1 | static int newque(struct ipc_namespace *ns, struct ipc_params *params)
{
struct msg_queue *msq;
int id, retval;
key_t key = params->key;
int msgflg = params->flg;
msq = ipc_rcu_alloc(sizeof(*msq));
if (!msq)
return -ENOMEM;
msq->q_perm.mode = msgflg & S_IRWXUGO;
msq->q_perm.key = key;
msq->q_perm.security... | 145,137,506,070,763,420,000,000,000,000,000,000,000 | msg.c | 137,063,545,741,306,320,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2015-7613 | Race condition in the IPC object implementation in the Linux kernel through 4.2.3 allows local users to gain privileges by triggering an ipc_addid call that leads to uid and gid comparisons against uninitialized data, related to msg.c, shm.c, and util.c. | https://nvd.nist.gov/vuln/detail/CVE-2015-7613 |
1,438 | linux | b9a532277938798b53178d5a66af6e2915cb27cf | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9a532277938798b53178d5a66af6e2915cb27cf | Initialize msg/shm IPC objects before doing ipc_addid()
As reported by Dmitry Vyukov, we really shouldn't do ipc_addid() before
having initialized the IPC object state. Yes, we initialize the IPC
object in a locked state, but with all the lockless RCU lookup work,
that IPC object lock no longer means that the state c... | 1 | static int newseg(struct ipc_namespace *ns, struct ipc_params *params)
{
key_t key = params->key;
int shmflg = params->flg;
size_t size = params->u.size;
int error;
struct shmid_kernel *shp;
size_t numpages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
struct file *file;
char name[13];
int id;
vm_flags_t acctflag =... | 280,625,932,635,716,960,000,000,000,000,000,000,000 | shm.c | 203,233,666,096,037,030,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2015-7613 | Race condition in the IPC object implementation in the Linux kernel through 4.2.3 allows local users to gain privileges by triggering an ipc_addid call that leads to uid and gid comparisons against uninitialized data, related to msg.c, shm.c, and util.c. | https://nvd.nist.gov/vuln/detail/CVE-2015-7613 |
1,439 | linux | b9a532277938798b53178d5a66af6e2915cb27cf | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9a532277938798b53178d5a66af6e2915cb27cf | Initialize msg/shm IPC objects before doing ipc_addid()
As reported by Dmitry Vyukov, we really shouldn't do ipc_addid() before
having initialized the IPC object state. Yes, we initialize the IPC
object in a locked state, but with all the lockless RCU lookup work,
that IPC object lock no longer means that the state c... | 1 | int ipc_addid(struct ipc_ids *ids, struct kern_ipc_perm *new, int size)
{
kuid_t euid;
kgid_t egid;
int id;
int next_id = ids->next_id;
if (size > IPCMNI)
size = IPCMNI;
if (ids->in_use >= size)
return -ENOSPC;
idr_preload(GFP_KERNEL);
spin_lock_init(&new->lock);
new->deleted = false;
rcu_read_lock()... | 260,213,467,137,768,860,000,000,000,000,000,000,000 | util.c | 249,665,259,441,201,800,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2015-7613 | Race condition in the IPC object implementation in the Linux kernel through 4.2.3 allows local users to gain privileges by triggering an ipc_addid call that leads to uid and gid comparisons against uninitialized data, related to msg.c, shm.c, and util.c. | https://nvd.nist.gov/vuln/detail/CVE-2015-7613 |
1,441 | linux | 74e98eb085889b0d2d4908f59f6e00026063014f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/74e98eb085889b0d2d4908f59f6e00026063014f | RDS: verify the underlying transport exists before creating a connection
There was no verification that an underlying transport exists when creating
a connection, this would cause dereferencing a NULL ptr.
It might happen on sockets that weren't properly bound before attempting to
send a message, which will cause a N... | 1 | static struct rds_connection *__rds_conn_create(struct net *net,
__be32 laddr, __be32 faddr,
struct rds_transport *trans, gfp_t gfp,
int is_outgoing)
{
struct rds_connection *conn, *parent = NULL;
struct hlist_head *head = rds_conn_bucket(laddr, faddr);
struct rds_transport *loop_trans;
... | 192,605,127,811,959,800,000,000,000,000,000,000,000 | connection.c | 228,446,343,956,843,780,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2015-6937 | The __rds_conn_create function in net/rds/connection.c in the Linux kernel through 4.2.3 allows local users to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by using a socket that was not properly bound. | https://nvd.nist.gov/vuln/detail/CVE-2015-6937 |
1,442 | openssh-portable | 5e75f5198769056089fb06c4d738ab0e5abc66f7 | https://github.com/openssh/openssh-portable | https://github.com/openssh/openssh-portable/commit/5e75f5198769056089fb06c4d738ab0e5abc66f7 | set sshpam_ctxt to NULL after free
Avoids use-after-free in monitor when privsep child is compromised.
Reported by Moritz Jodeit; ok dtucker@ | 1 | mm_answer_pam_free_ctx(int sock, Buffer *m)
{
debug3("%s", __func__);
(sshpam_device.free_ctx)(sshpam_ctxt);
buffer_clear(m);
mm_request_send(sock, MONITOR_ANS_PAM_FREE_CTX, m);
auth_method = "keyboard-interactive";
auth_submethod = "pam";
return (sshpam_authok == sshpam_ctxt);
}
| 205,096,995,958,077,860,000,000,000,000,000,000,000 | monitor.c | 314,905,608,812,230,500,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2015-6564 | Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request. | https://nvd.nist.gov/vuln/detail/CVE-2015-6564 |
1,443 | openssh-portable | d4697fe9a28dab7255c60433e4dd23cf7fce8a8b | https://github.com/openssh/openssh-portable | https://github.com/openssh/openssh-portable/commit/d4697fe9a28dab7255c60433e4dd23cf7fce8a8b | Don't resend username to PAM; it already has it.
Pointed out by Moritz Jodeit; ok dtucker@ | 1 | mm_answer_pam_init_ctx(int sock, Buffer *m)
{
debug3("%s", __func__);
authctxt->user = buffer_get_string(m, NULL);
sshpam_ctxt = (sshpam_device.init_ctx)(authctxt);
sshpam_authok = NULL;
buffer_clear(m);
if (sshpam_ctxt != NULL) {
monitor_permit(mon_dispatch, MONITOR_REQ_PAM_FREE_CTX, 1);
buffer_put_int... | 77,335,835,840,341,280,000,000,000,000,000,000,000 | monitor.c | 287,714,491,034,327,250,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2015-6563 | The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM... | https://nvd.nist.gov/vuln/detail/CVE-2015-6563 |
1,444 | openssh-portable | d4697fe9a28dab7255c60433e4dd23cf7fce8a8b | https://github.com/openssh/openssh-portable | https://github.com/openssh/openssh-portable/commit/d4697fe9a28dab7255c60433e4dd23cf7fce8a8b | Don't resend username to PAM; it already has it.
Pointed out by Moritz Jodeit; ok dtucker@ | 1 | mm_sshpam_init_ctx(Authctxt *authctxt)
{
Buffer m;
int success;
debug3("%s", __func__);
buffer_init(&m);
buffer_put_cstring(&m, authctxt->user);
mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_PAM_INIT_CTX, &m);
debug3("%s: waiting for MONITOR_ANS_PAM_INIT_CTX", __func__);
mm_request_receive_expect(pmoni... | 6,266,967,114,205,273,000,000,000,000,000,000,000 | monitor_wrap.c | 201,186,186,210,011,480,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2015-6563 | The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM... | https://nvd.nist.gov/vuln/detail/CVE-2015-6563 |
1,445 | linux | 9a5cbce421a283e6aea3c4007f141735bf9da8c3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9a5cbce421a283e6aea3c4007f141735bf9da8c3 | powerpc/perf: Cap 64bit userspace backtraces to PERF_MAX_STACK_DEPTH
We cap 32bit userspace backtraces to PERF_MAX_STACK_DEPTH
(currently 127), but we forgot to do the same for 64bit backtraces.
Cc: stable@vger.kernel.org
Signed-off-by: Anton Blanchard <anton@samba.org>
Signed-off-by: Michael Ellerman <mpe@ellerman.i... | 1 | static void perf_callchain_user_64(struct perf_callchain_entry *entry,
struct pt_regs *regs)
{
unsigned long sp, next_sp;
unsigned long next_ip;
unsigned long lr;
long level = 0;
struct signal_frame_64 __user *sigframe;
unsigned long __user *fp, *uregs;
next_ip = perf_instruction_pointer(regs);
lr = reg... | 223,862,452,787,017,050,000,000,000,000,000,000,000 | callchain.c | 29,252,321,502,543,094,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2015-6526 | The perf_callchain_user_64 function in arch/powerpc/perf/callchain.c in the Linux kernel before 4.0.2 on ppc64 platforms allows local users to cause a denial of service (infinite loop) via a deep 64-bit userspace backtrace. | https://nvd.nist.gov/vuln/detail/CVE-2015-6526 |
1,449 | linux | 7932c0bd7740f4cd2aa168d3ce0199e7af7d72d5 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/7932c0bd7740f4cd2aa168d3ce0199e7af7d72d5 | vhost: actually track log eventfd file
While reviewing vhost log code, I found out that log_file is never
set. Note: I haven't tested the change (QEMU doesn't use LOG_FD yet).
Cc: stable@vger.kernel.org
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com> | 1 | long vhost_dev_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *argp)
{
struct file *eventfp, *filep = NULL;
struct eventfd_ctx *ctx = NULL;
u64 p;
long r;
int i, fd;
/* If you are not the owner, you can become one */
if (ioctl == VHOST_SET_OWNER) {
r = vhost_dev_set_owner(d);
goto done;
}
/* ... | 259,350,127,464,630,780,000,000,000,000,000,000,000 | vhost.c | 299,385,267,607,711,380,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2015-6252 | The vhost_dev_ioctl function in drivers/vhost/vhost.c in the Linux kernel before 4.1.5 allows local users to cause a denial of service (memory consumption) via a VHOST_SET_LOG_FD ioctl call that triggers permanent file-descriptor allocation. | https://nvd.nist.gov/vuln/detail/CVE-2015-6252 |
1,450 | miniupnp | 79cca974a4c2ab1199786732a67ff6d898051b78 | https://github.com/miniupnp/miniupnp | https://github.com/miniupnp/miniupnp/commit/79cca974a4c2ab1199786732a67ff6d898051b78 | igd_desc_parse.c: fix buffer overflow | 1 | void IGDstartelt(void * d, const char * name, int l)
{
struct IGDdatas * datas = (struct IGDdatas *)d;
memcpy( datas->cureltname, name, l);
datas->cureltname[l] = '\0';
datas->level++;
if( (l==7) && !memcmp(name, "service", l) ) {
datas->tmp.controlurl[0] = '\0';
datas->tmp.eventsuburl[0] = '\0';
datas... | 81,376,760,744,966,150,000,000,000,000,000,000,000 | igd_desc_parse.c | 340,208,766,696,793,100,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2015-6031 | Buffer overflow in the IGDstartelt function in igd_desc_parse.c in the MiniUPnP client (aka MiniUPnPc) before 1.9.20150917 allows remote UPNP servers to cause a denial of service (application crash) and possibly execute arbitrary code via an "oversized" XML element name. | https://nvd.nist.gov/vuln/detail/CVE-2015-6031 |
1,451 | linux | f15133df088ecadd141ea1907f2c96df67c729f0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f15133df088ecadd141ea1907f2c96df67c729f0 | path_openat(): fix double fput()
path_openat() jumps to the wrong place after do_tmpfile() - it has
already done path_cleanup() (as part of path_lookupat() called by
do_tmpfile()), so doing that again can lead to double fput().
Cc: stable@vger.kernel.org # v3.11+
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk> | 1 | static struct file *path_openat(int dfd, struct filename *pathname,
struct nameidata *nd, const struct open_flags *op, int flags)
{
struct file *file;
struct path path;
int opened = 0;
int error;
file = get_empty_filp();
if (IS_ERR(file))
return file;
file->f_flags = op->open_flag;
if (unlikely(file->f... | 75,770,052,784,686,880,000,000,000,000,000,000,000 | namei.c | 323,949,164,317,720,170,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2015-5706 | Use-after-free vulnerability in the path_openat function in fs/namei.c in the Linux kernel 3.x and 4.x before 4.0.4 allows local users to cause a denial of service or possibly have unspecified other impact via O_TMPFILE filesystem operations that leverage a duplicate cleanup operation. | https://nvd.nist.gov/vuln/detail/CVE-2015-5706 |
1,452 | linux | b6878d9e03043695dbf3fa1caa6dfc09db225b16 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b6878d9e03043695dbf3fa1caa6dfc09db225b16 | md: use kzalloc() when bitmap is disabled
In drivers/md/md.c get_bitmap_file() uses kmalloc() for creating a
mdu_bitmap_file_t called "file".
5769 file = kmalloc(sizeof(*file), GFP_NOIO);
5770 if (!file)
5771 return -ENOMEM;
This structure is copied to user space at the end of the fun... | 1 | static int get_bitmap_file(struct mddev *mddev, void __user * arg)
{
mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
char *ptr;
int err;
file = kmalloc(sizeof(*file), GFP_NOIO);
if (!file)
return -ENOMEM;
err = 0;
spin_lock(&mddev->lock);
/* bitmap disabled, zero the first byte and ... | 233,692,859,281,768,060,000,000,000,000,000,000,000 | md.c | 31,073,914,606,817,860,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2015-5697 | The get_bitmap_file function in drivers/md/md.c in the Linux kernel before 4.1.6 does not initialize a certain bitmap data structure, which allows local users to obtain sensitive information from kernel memory via a GET_BITMAP_FILE ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2015-5697 |
1,453 | linux | beb39db59d14990e401e235faf66a6b9b31240b0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/beb39db59d14990e401e235faf66a6b9b31240b0 | udp: fix behavior of wrong checksums
We have two problems in UDP stack related to bogus checksums :
1) We return -EAGAIN to application even if receive queue is not empty.
This breaks applications using edge trigger epoll()
2) Under UDP flood, we can loop forever without yielding to other
processes, potentiall... | 1 | int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int noblock,
int flags, int *addr_len)
{
struct inet_sock *inet = inet_sk(sk);
DECLARE_SOCKADDR(struct sockaddr_in *, sin, msg->msg_name);
struct sk_buff *skb;
unsigned int ulen, copied;
int peeked, off = 0;
int err;
int is_udplite = IS_UDPLITE(s... | 200,373,655,058,309,960,000,000,000,000,000,000,000 | udp.c | 207,907,517,686,896,670,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2015-5366 | The (1) udp_recvmsg and (2) udpv6_recvmsg functions in the Linux kernel before 4.0.6 provide inappropriate -EAGAIN return values, which allows remote attackers to cause a denial of service (EPOLLET epoll application read outage) via an incorrect checksum in a UDP packet, a different vulnerability than CVE-2015-5364. | https://nvd.nist.gov/vuln/detail/CVE-2015-5366 |
1,454 | linux | beb39db59d14990e401e235faf66a6b9b31240b0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/beb39db59d14990e401e235faf66a6b9b31240b0 | udp: fix behavior of wrong checksums
We have two problems in UDP stack related to bogus checksums :
1) We return -EAGAIN to application even if receive queue is not empty.
This breaks applications using edge trigger epoll()
2) Under UDP flood, we can loop forever without yielding to other
processes, potentiall... | 1 | int udpv6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
int noblock, int flags, int *addr_len)
{
struct ipv6_pinfo *np = inet6_sk(sk);
struct inet_sock *inet = inet_sk(sk);
struct sk_buff *skb;
unsigned int ulen, copied;
int peeked, off = 0;
int err;
int is_udplite = IS_UDPLITE(sk);
int is_udp4;
... | 122,715,536,700,597,060,000,000,000,000,000,000,000 | udp.c | 240,477,898,096,045,670,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2015-5366 | The (1) udp_recvmsg and (2) udpv6_recvmsg functions in the Linux kernel before 4.0.6 provide inappropriate -EAGAIN return values, which allows remote attackers to cause a denial of service (EPOLLET epoll application read outage) via an incorrect checksum in a UDP packet, a different vulnerability than CVE-2015-5364. | https://nvd.nist.gov/vuln/detail/CVE-2015-5366 |
1,455 | linux | 54a20552e1eae07aa240fa370a0293e006b5faed | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/54a20552e1eae07aa240fa370a0293e006b5faed | KVM: x86: work around infinite loop in microcode when #AC is delivered
It was found that a guest can DoS a host by triggering an infinite
stream of "alignment check" (#AC) exceptions. This causes the
microcode to enter an infinite loop where the core never receives
another interrupt. The host kernel panics pretty qu... | 1 | static void init_vmcb(struct vcpu_svm *svm)
{
struct vmcb_control_area *control = &svm->vmcb->control;
struct vmcb_save_area *save = &svm->vmcb->save;
svm->vcpu.fpu_active = 1;
svm->vcpu.arch.hflags = 0;
set_cr_intercept(svm, INTERCEPT_CR0_READ);
set_cr_intercept(svm, INTERCEPT_CR3_READ);
set_cr_intercept(svm,... | 279,366,401,211,128,940,000,000,000,000,000,000,000 | svm.c | 46,777,106,013,319,800,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2015-5307 | The KVM subsystem in the Linux kernel through 4.2.6, and Xen 4.3.x through 4.6.x, allows guest OS users to cause a denial of service (host OS panic or hang) by triggering many #AC (aka Alignment Check) exceptions, related to svm.c and vmx.c. | https://nvd.nist.gov/vuln/detail/CVE-2015-5307 |
1,461 | abrt | 3c1b60cfa62d39e5fff5a53a5bc53dae189e740e | https://github.com/abrt/abrt | https://github.com/abrt/abrt/commit/3c1b60cfa62d39e5fff5a53a5bc53dae189e740e | ccpp: save abrt core files only to new files
Prior this commit abrt-hook-ccpp saved a core file generated by a
process running a program whose name starts with "abrt" in
DUMP_LOCATION/$(basename program)-coredump. If the file was a symlink,
the hook followed and wrote core file to the symlink's target.
Addresses CVE-... | 1 | int main(int argc, char** argv)
{
/* Kernel starts us with all fd's closed.
* But it's dangerous:
* fprintf(stderr) can dump messages into random fds, etc.
* Ensure that if any of fd 0,1,2 is closed, we open it to /dev/null.
*/
int fd = xopen("/dev/null", O_RDWR);
while (fd < 2)
... | 287,347,886,890,565,600,000,000,000,000,000,000,000 | None | null | [
"CWE-59"
] | CVE-2015-5287 | The abrt-hook-ccpp help program in Automatic Bug Reporting Tool (ABRT) before 2.7.1 allows local users with certain permissions to gain privileges via a symlink attack on a file with a predictable name, as demonstrated by /var/tmp/abrt/abrt-hax-coredump or /var/spool/abrt/abrt-hax-coredump. | https://nvd.nist.gov/vuln/detail/CVE-2015-5287 |
1,463 | linux | 8e2d61e0aed2b7c4ecb35844fe07e0b2b762dee4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8e2d61e0aed2b7c4ecb35844fe07e0b2b762dee4 | sctp: fix race on protocol/netns initialization
Consider sctp module is unloaded and is being requested because an user
is creating a sctp socket.
During initialization, sctp will add the new protocol type and then
initialize pernet subsys:
status = sctp_v4_protosw_init();
if (status)
... | 1 | static __init int sctp_init(void)
{
int i;
int status = -EINVAL;
unsigned long goal;
unsigned long limit;
int max_share;
int order;
sock_skb_cb_check_size(sizeof(struct sctp_ulpevent));
/* Allocate bind_bucket and chunk caches. */
status = -ENOBUFS;
sctp_bucket_cachep = kmem_cache_create("sctp_bind_bucket",... | 167,189,804,297,399,060,000,000,000,000,000,000,000 | protocol.c | 19,924,814,074,907,472,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2015-5283 | The sctp_init function in net/sctp/protocol.c in the Linux kernel before 4.2.3 has an incorrect sequence of protocol-initialization steps, which allows local users to cause a denial of service (panic or memory corruption) by creating SCTP sockets before all of the steps have finished. | https://nvd.nist.gov/vuln/detail/CVE-2015-5283 |
1,466 | abrt | 50ee8130fb4cd4ef1af7682a2c85dd99cb99424e | https://github.com/abrt/abrt | https://github.com/abrt/abrt/commit/50ee8130fb4cd4ef1af7682a2c85dd99cb99424e | a-a-i-d-to-abrt-cache: make own random temporary directory
The set-user-ID wrapper must use own new temporary directory in order to
avoid security issues with unpacking specially crafted debuginfo
packages that might be used to create files or symlinks anywhere on the
file system as the abrt user.
Withot the forking ... | 1 | int main(int argc, char **argv)
{
/* I18n */
setlocale(LC_ALL, "");
#if ENABLE_NLS
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
abrt_init(argv);
/* Can't keep these strings/structs static: _() doesn't support that */
const char *program_usage_string = _(
"& [-y] ... | 92,934,402,516,180,260,000,000,000,000,000,000,000 | None | null | [
"CWE-59"
] | CVE-2015-5273 | The abrt-action-install-debuginfo-to-abrt-cache help program in Automatic Bug Reporting Tool (ABRT) before 2.7.1 allows local users to write to arbitrary files via a symlink attack on unpacked.cpio in a pre-created directory with a predictable name in /var/tmp. | https://nvd.nist.gov/vuln/detail/CVE-2015-5273 |
1,467 | linux | 48900cb6af4282fa0fb6ff4d72a81aa3dadb5c39 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/48900cb6af4282fa0fb6ff4d72a81aa3dadb5c39 | virtio-net: drop NETIF_F_FRAGLIST
virtio declares support for NETIF_F_FRAGLIST, but assumes
that there are at most MAX_SKB_FRAGS + 2 fragments which isn't
always true with a fraglist.
A longer fraglist in the skb will make the call to skb_to_sgvec overflow
the sg array, leading to memory corruption.
Drop NETIF_F_FRA... | 1 | static int virtnet_probe(struct virtio_device *vdev)
{
int i, err;
struct net_device *dev;
struct virtnet_info *vi;
u16 max_queue_pairs;
if (!vdev->config->get) {
dev_err(&vdev->dev, "%s failure: config access disabled\n",
__func__);
return -EINVAL;
}
if (!virtnet_validate_features(vdev))
return -EINV... | 286,743,572,691,752,180,000,000,000,000,000,000,000 | virtio_net.c | 226,259,448,298,505,000,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2015-5156 | The virtnet_probe function in drivers/net/virtio_net.c in the Linux kernel before 4.2 attempts to support a FRAGLIST feature without proper memory allocation, which allows guest OS users to cause a denial of service (buffer overflow and memory corruption) via a crafted sequence of fragmented packets. | https://nvd.nist.gov/vuln/detail/CVE-2015-5156 |
1,468 | linux | 3f7352bf21f8fd7ba3e2fcef9488756f188e12be | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/3f7352bf21f8fd7ba3e2fcef9488756f188e12be | x86: bpf_jit: fix compilation of large bpf programs
x86 has variable length encoding. x86 JIT compiler is trying
to pick the shortest encoding for given bpf instruction.
While doing so the jump targets are changing, so JIT is doing
multiple passes over the program. Typical program needs 3 passes.
Some very short progr... | 1 | void bpf_int_jit_compile(struct bpf_prog *prog)
{
struct bpf_binary_header *header = NULL;
int proglen, oldproglen = 0;
struct jit_context ctx = {};
u8 *image = NULL;
int *addrs;
int pass;
int i;
if (!bpf_jit_enable)
return;
if (!prog || !prog->len)
return;
addrs = kmalloc(prog->len * sizeof(*addrs), G... | 286,732,731,074,854,750,000,000,000,000,000,000,000 | bpf_jit_comp.c | 247,386,070,920,950,060,000,000,000,000,000,000,000 | [
"CWE-17"
] | CVE-2015-4700 | The bpf_int_jit_compile function in arch/x86/net/bpf_jit_comp.c in the Linux kernel before 4.0.6 allows local users to cause a denial of service (system crash) by creating a packet filter and then loading crafted BPF instructions that trigger late convergence by the JIT compiler. | https://nvd.nist.gov/vuln/detail/CVE-2015-4700 |
1,469 | libmspack | 18b6a2cc0b87536015bedd4f7763e6b02d5aa4f3 | https://github.com/kyz/libmspack | https://github.com/kyz/libmspack/commit/18b6a2cc0b87536015bedd4f7763e6b02d5aa4f3 | Prevent a 1-byte underread of the input buffer if an odd-sized data block comes just before an uncompressed block header | 1 | int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
/* bitstream and huffman reading variables */
register unsigned int bit_buffer;
register int bits_left, i=0;
unsigned char *i_ptr, *i_end;
register unsigned short sym;
int match_length, length_footer, extra, verbatim_bits, bytes_todo;
int th... | 301,703,386,296,293,370,000,000,000,000,000,000,000 | lzxd.c | 337,003,730,914,340,000,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2015-4471 | Off-by-one error in the lzxd_decompress function in lzxd.c in libmspack before 0.5 allows remote attackers to cause a denial of service (buffer under-read and application crash) via a crafted CAB archive. | https://nvd.nist.gov/vuln/detail/CVE-2015-4471 |
1,470 | linux | 23b133bdc452aa441fcb9b82cbf6dd05cfd342d0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/23b133bdc452aa441fcb9b82cbf6dd05cfd342d0 | udf: Check length of extended attributes and allocation descriptors
Check length of extended attributes and allocation descriptors when
loading inodes from disk. Otherwise corrupted filesystems could confuse
the code and make the kernel oops.
Reported-by: Carl Henrik Lunde <chlunde@ping.uio.no>
CC: stable@vger.kernel... | 1 | static int udf_read_inode(struct inode *inode, bool hidden_inode)
{
struct buffer_head *bh = NULL;
struct fileEntry *fe;
struct extendedFileEntry *efe;
uint16_t ident;
struct udf_inode_info *iinfo = UDF_I(inode);
struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
struct kernel_lb_addr *iloc = &iinfo->i_location;
un... | 154,377,499,296,836,300,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2015-4167 | The udf_read_inode function in fs/udf/inode.c in the Linux kernel before 3.19.1 does not validate certain length values, which allows local users to cause a denial of service (incorrect data representation or integer overflow, and OOPS) via a crafted UDF filesystem. | https://nvd.nist.gov/vuln/detail/CVE-2015-4167 |
1,472 | linux | 04bf464a5dfd9ade0dda918e44366c2c61fce80b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/04bf464a5dfd9ade0dda918e44366c2c61fce80b | ozwpan: divide-by-zero leading to panic
A network supplied parameter was not checked before division, leading to
a divide-by-zero. Since this happens in the softirq path, it leads to a
crash. A PoC follows below, which requires the ozprotocol.h file from
this module.
=-=-=-=-=-=
#include <arpa/inet.h>
#include <li... | 1 | static void oz_usb_handle_ep_data(struct oz_usb_ctx *usb_ctx,
struct oz_usb_hdr *usb_hdr, int len)
{
struct oz_data *data_hdr = (struct oz_data *)usb_hdr;
switch (data_hdr->format) {
case OZ_DATA_F_MULTIPLE_FIXED: {
struct oz_multiple_fixed *body =
(struct oz_multiple_fixed *)data_hdr;
u8 *data = body... | 108,503,765,742,072,030,000,000,000,000,000,000,000 | ozusbsvc1.c | 4,167,953,671,616,514,400,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2015-4003 | The oz_usb_handle_ep_data function in drivers/staging/ozwpan/ozusbsvc1.c in the OZWPAN driver in the Linux kernel through 4.0.5 allows remote attackers to cause a denial of service (divide-by-zero error and system crash) via a crafted packet. | https://nvd.nist.gov/vuln/detail/CVE-2015-4003 |
1,473 | linux | d114b9fe78c8d6fc6e70808c2092aa307c36dc8e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d114b9fe78c8d6fc6e70808c2092aa307c36dc8e | ozwpan: Use proper check to prevent heap overflow
Since elt->length is a u8, we can make this variable a u8. Then we can
do proper bounds checking more easily. Without this, a potentially
negative value is passed to the memcpy inside oz_hcd_get_desc_cnf,
resulting in a remotely exploitable heap overflow with network
s... | 1 | void oz_usb_rx(struct oz_pd *pd, struct oz_elt *elt)
{
struct oz_usb_hdr *usb_hdr = (struct oz_usb_hdr *)(elt + 1);
struct oz_usb_ctx *usb_ctx;
spin_lock_bh(&pd->app_lock[OZ_APPID_USB]);
usb_ctx = (struct oz_usb_ctx *)pd->app_ctx[OZ_APPID_USB];
if (usb_ctx)
oz_usb_get(usb_ctx);
spin_unlock_bh(&pd->app_lock[OZ_... | 205,444,369,337,433,030,000,000,000,000,000,000,000 | ozusbsvc1.c | 49,251,549,535,178,640,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2015-4002 | drivers/staging/ozwpan/ozusbsvc1.c in the OZWPAN driver in the Linux kernel through 4.0.5 does not ensure that certain length values are sufficiently large, which allows remote attackers to cause a denial of service (system crash or large loop) or possibly execute arbitrary code via a crafted packet, related to the (1)... | https://nvd.nist.gov/vuln/detail/CVE-2015-4002 |
1,474 | linux | b1bb5b49373b61bf9d2c73a4d30058ba6f069e4c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b1bb5b49373b61bf9d2c73a4d30058ba6f069e4c | ozwpan: Use unsigned ints to prevent heap overflow
Using signed integers, the subtraction between required_size and offset
could wind up being negative, resulting in a memcpy into a heap buffer
with a negative length, resulting in huge amounts of network-supplied
data being copied into the heap, which could potentiall... | 1 | void oz_hcd_get_desc_cnf(void *hport, u8 req_id, int status, const u8 *desc,
int length, int offset, int total_size)
{
struct oz_port *port = hport;
struct urb *urb;
int err = 0;
oz_dbg(ON, "oz_hcd_get_desc_cnf length = %d offs = %d tot_size = %d\n",
length, offset, total_size);
urb = oz_find_urb_by... | 320,708,195,163,871,100,000,000,000,000,000,000,000 | ozhcd.c | 306,747,271,140,156,940,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2015-4001 | Integer signedness error in the oz_hcd_get_desc_cnf function in drivers/staging/ozwpan/ozhcd.c in the OZWPAN driver in the Linux kernel through 4.0.5 allows remote attackers to cause a denial of service (system crash) or possibly execute arbitrary code via a crafted packet. | https://nvd.nist.gov/vuln/detail/CVE-2015-4001 |
1,477 | rawstudio | 983bda1f0fa5fa86884381208274198a620f006e | https://github.com/rawstudio/rawstudio | https://github.com/rawstudio/rawstudio/commit/983bda1f0fa5fa86884381208274198a620f006e | Avoid overflow in ljpeg_start(). | 1 | int CLASS ljpeg_start (struct jhead *jh, int info_only)
{
int c, tag, len;
uchar data[0x10000];
const uchar *dp;
memset (jh, 0, sizeof *jh);
jh->restart = INT_MAX;
fread (data, 2, 1, ifp);
if (data[1] != 0xd8) return 0;
do {
fread (data, 2, 2, ifp);
tag = data[0] << 8 | data[1];
len =... | 291,937,476,956,930,900,000,000,000,000,000,000,000 | dcraw.cc | 297,550,824,630,771,470,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2015-3885 | Integer overflow in the ljpeg_start function in dcraw 7.00 and earlier allows remote attackers to cause a denial of service (crash) via a crafted image, which triggers a buffer overflow, related to the len variable. | https://nvd.nist.gov/vuln/detail/CVE-2015-3885 |
1,478 | linux | a134f083e79fb4c3d0a925691e732c56911b4326 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a134f083e79fb4c3d0a925691e732c56911b4326 | ipv4: Missing sk_nulls_node_init() in ping_unhash().
If we don't do that, then the poison value is left in the ->pprev
backlink.
This can cause crashes if we do a disconnect, followed by a connect().
Tested-by: Linus Torvalds <torvalds@linux-foundation.org>
Reported-by: Wen Xu <hotdog3645@gmail.com>
Signed-off-by: D... | 1 | void ping_unhash(struct sock *sk)
{
struct inet_sock *isk = inet_sk(sk);
pr_debug("ping_unhash(isk=%p,isk->num=%u)\n", isk, isk->inet_num);
if (sk_hashed(sk)) {
write_lock_bh(&ping_table.lock);
hlist_nulls_del(&sk->sk_nulls_node);
sock_put(sk);
isk->inet_num = 0;
isk->inet_sport = 0;
sock_prot_inus... | 310,891,391,724,566,200,000,000,000,000,000,000,000 | ping.c | 208,150,909,002,443,060,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2015-3636 | The ping_unhash function in net/ipv4/ping.c in the Linux kernel before 4.0.3 does not initialize a certain list data structure during an unhash operation, which allows local users to gain privileges or cause a denial of service (use-after-free and system crash) by leveraging the ability to make a SOCK_DGRAM socket syst... | https://nvd.nist.gov/vuln/detail/CVE-2015-3636 |
1,479 | FFmpeg | e8714f6f93d1a32f4e4655209960afcf4c185214 | https://github.com/FFmpeg/FFmpeg | https://github.com/FFmpeg/FFmpeg/commit/e8714f6f93d1a32f4e4655209960afcf4c185214 | avcodec/h264: Clear delayed_pic on deallocation
Fixes use of freed memory
Fixes: case5_av_frame_copy_props.mp4
Found-by: Michal Zalewski <lcamtuf@coredump.cx>
Signed-off-by: Michael Niedermayer <michaelni@gmx.at> | 1 | void ff_h264_free_tables(H264Context *h, int free_rbsp)
{
int i;
H264Context *hx;
av_freep(&h->intra4x4_pred_mode);
av_freep(&h->chroma_pred_mode_table);
av_freep(&h->cbp_table);
av_freep(&h->mvd_table[0]);
av_freep(&h->mvd_table[1]);
av_freep(&h->direct_table);
av_freep(&h->non_zer... | 160,444,303,816,193,310,000,000,000,000,000,000,000 | h264.c | 130,045,572,076,372,200,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2015-3417 | Use-after-free vulnerability in the ff_h264_free_tables function in libavcodec/h264.c in FFmpeg before 2.3.6 allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted H.264 data in an MP4 file, as demonstrated by an HTML VIDEO element that references H.264 data. | https://nvd.nist.gov/vuln/detail/CVE-2015-3417 |
1,480 | linux | 8b01fc86b9f425899f8a3a8fc1c47d73c2c20543 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8b01fc86b9f425899f8a3a8fc1c47d73c2c20543 | fs: take i_mutex during prepare_binprm for set[ug]id executables
This prevents a race between chown() and execve(), where chowning a
setuid-user binary to root would momentarily make the binary setuid
root.
This patch was mostly written by Linus Torvalds.
Signed-off-by: Jann Horn <jann@thejh.net>
Signed-off-by: Linu... | 1 | int prepare_binprm(struct linux_binprm *bprm)
{
struct inode *inode = file_inode(bprm->file);
umode_t mode = inode->i_mode;
int retval;
/* clear any previous set[ug]id data from a previous binary */
bprm->cred->euid = current_euid();
bprm->cred->egid = current_egid();
if (!(bprm->file->f_path.mnt->mnt_flags... | 335,498,349,453,083,000,000,000,000,000,000,000,000 | exec.c | 9,385,387,174,828,543,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2015-3339 | Race condition in the prepare_binprm function in fs/exec.c in the Linux kernel before 3.19.6 allows local users to gain privileges by executing a setuid program at a time instant when a chown to root is in progress, and the ownership is changed but the setuid bit is not yet stripped. | https://nvd.nist.gov/vuln/detail/CVE-2015-3339 |
1,481 | linux | ccfe8c3f7e52ae83155cb038753f4c75b774ca8a | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ccfe8c3f7e52ae83155cb038753f4c75b774ca8a | crypto: aesni - fix memory usage in GCM decryption
The kernel crypto API logic requires the caller to provide the
length of (ciphertext || authentication tag) as cryptlen for the
AEAD decryption operation. Thus, the cipher implementation must
calculate the size of the plaintext output itself and cannot simply use
cryp... | 1 | static int __driver_rfc4106_decrypt(struct aead_request *req)
{
u8 one_entry_in_sg = 0;
u8 *src, *dst, *assoc;
unsigned long tempCipherLen = 0;
__be32 counter = cpu_to_be32(1);
int retval = 0;
struct crypto_aead *tfm = crypto_aead_reqtfm(req);
struct aesni_rfc4106_gcm_ctx *ctx = aesni_rfc4106_gcm_ctx_get(tfm);
... | 235,636,219,205,578,550,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2015-3331 | The __driver_rfc4106_decrypt function in arch/x86/crypto/aesni-intel_glue.c in the Linux kernel before 3.19.3 does not properly determine the memory locations used for encrypted data, which allows context-dependent attackers to cause a denial of service (buffer overflow and system crash) or possibly execute arbitrary c... | https://nvd.nist.gov/vuln/detail/CVE-2015-3331 |
1,488 | linux | 6fd99094de2b83d1d4c8457f2c83483b2828e75a | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6fd99094de2b83d1d4c8457f2c83483b2828e75a | ipv6: Don't reduce hop limit for an interface
A local route may have a lower hop_limit set than global routes do.
RFC 3756, Section 4.2.7, "Parameter Spoofing"
> 1. The attacker includes a Current Hop Limit of one or another small
> number which the attacker knows will cause legitimate packets to
> be... | 1 | static void ndisc_router_discovery(struct sk_buff *skb)
{
struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
struct neighbour *neigh = NULL;
struct inet6_dev *in6_dev;
struct rt6_info *rt = NULL;
int lifetime;
struct ndisc_options ndopts;
int optlen;
unsigned int pref = 0;
__u8 *opt = (__u8 *... | 143,930,665,896,709,250,000,000,000,000,000,000,000 | ndisc.c | 115,440,394,696,074,500,000,000,000,000,000,000,000 | [
"CWE-17"
] | CVE-2015-2922 | The ndisc_router_discovery function in net/ipv6/ndisc.c in the Neighbor Discovery (ND) protocol implementation in the IPv6 stack in the Linux kernel before 3.19.6 allows remote attackers to reconfigure a hop-limit setting via a small hop_limit value in a Router Advertisement (RA) message. | https://nvd.nist.gov/vuln/detail/CVE-2015-2922 |
1,489 | das_watchdog | bd20bb02e75e2c0483832b52f2577253febfb690 | https://github.com/kmatheussen/das_watchdog | https://github.com/kmatheussen/das_watchdog/commit/bd20bb02e75e2c0483832b52f2577253febfb690 | Fix memory overflow if the name of an environment is larger than 500 characters. Bug found by Adam Sampson. | 1 | static char *get_pid_environ_val(pid_t pid,char *val){
char temp[500];
int i=0;
int foundit=0;
FILE *fp;
sprintf(temp,"/proc/%d/environ",pid);
fp=fopen(temp,"r");
if(fp==NULL)
return NULL;
for(;;){
temp[i]=fgetc(fp);
if(foundit==1 && (temp[i]==0 || temp[i]=='\0' || temp[... | 127,977,327,279,497,000,000,000,000,000,000,000,000 | das_watchdog.c | 25,596,189,492,826,565,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2015-2831 | Buffer overflow in das_watchdog 0.9.0 allows local users to execute arbitrary code with root privileges via a large string in the XAUTHORITY environment variable. | https://nvd.nist.gov/vuln/detail/CVE-2015-2831 |
1,490 | krb5 | 3db8dfec1ef50ddd78d6ba9503185995876a39fd | https://github.com/krb5/krb5 | https://github.com/krb5/krb5/commit/3db8dfec1ef50ddd78d6ba9503185995876a39fd | Fix IAKERB context export/import [CVE-2015-2698]
The patches for CVE-2015-2696 contained a regression in the newly
added IAKERB iakerb_gss_export_sec_context() function, which could
cause it to corrupt memory. Fix the regression by properly
dereferencing the context_handle pointer before casting it.
Also, the patche... | 1 | iakerb_gss_export_sec_context(OM_uint32 *minor_status,
gss_ctx_id_t *context_handle,
gss_buffer_t interprocess_token)
{
OM_uint32 maj;
iakerb_ctx_id_t ctx = (iakerb_ctx_id_t)context_handle;
/* We don't currently support exporting partially es... | 327,336,867,353,175,950,000,000,000,000,000,000,000 | iakerb.c | 282,483,658,881,223,100,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2015-2698 | The iakerb_gss_export_sec_context function in lib/gssapi/krb5/iakerb.c in MIT Kerberos 5 (aka krb5) 1.14 pre-release 2015-09-14 improperly accesses a certain pointer, which allows remote authenticated users to cause a denial of service (memory corruption) or possibly have unspecified other impact by interacting with an... | https://nvd.nist.gov/vuln/detail/CVE-2015-2698 |
1,491 | krb5 | f0c094a1b745d91ef2f9a4eae2149aac026a5789 | https://github.com/krb5/krb5 | https://github.com/krb5/krb5/commit/f0c094a1b745d91ef2f9a4eae2149aac026a5789 | Fix build_principal memory bug [CVE-2015-2697]
In build_principal_va(), use k5memdup0() instead of strdup() to make a
copy of the realm, to ensure that we allocate the correct number of
bytes and do not read past the end of the input string. This bug
affects krb5_build_principal(), krb5_build_principal_va(), and
krb5... | 1 | build_principal_va(krb5_context context, krb5_principal princ,
unsigned int rlen, const char *realm, va_list ap)
{
krb5_error_code retval = 0;
char *r = NULL;
krb5_data *data = NULL;
krb5_int32 count = 0;
krb5_int32 size = 2; /* initial guess at needed space */
char *componen... | 284,043,475,302,472,930,000,000,000,000,000,000,000 | bld_princ.c | 27,830,430,857,955,170,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2015-2697 | The build_principal_va function in lib/krb5/krb/bld_princ.c in MIT Kerberos 5 (aka krb5) before 1.14 allows remote authenticated users to cause a denial of service (out-of-bounds read and KDC crash) via an initial '\0' character in a long realm field within a TGS request. | https://nvd.nist.gov/vuln/detail/CVE-2015-2697 |
1,523 | krb5 | e3b5a5e5267818c97750b266df50b6a3d4649604 | https://github.com/krb5/krb5 | https://github.com/krb5/krb5/commit/e3b5a5e5267818c97750b266df50b6a3d4649604 | Prevent requires_preauth bypass [CVE-2015-2694]
In the OTP kdcpreauth module, don't set the TKT_FLG_PRE_AUTH bit until
the request is successfully verified. In the PKINIT kdcpreauth
module, don't respond with code 0 on empty input or an unconfigured
realm. Together these bugs could cause the KDC preauth framework to... | 1 | pkinit_server_verify_padata(krb5_context context,
krb5_data *req_pkt,
krb5_kdc_req * request,
krb5_enc_tkt_part * enc_tkt_reply,
krb5_pa_data * data,
krb5_kdcpreauth_callbacks cb,
... | 7,409,460,042,177,961,000,000,000,000,000,000,000 | pkinit_srv.c | 27,162,181,412,772,705,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2015-2694 | The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugin... | https://nvd.nist.gov/vuln/detail/CVE-2015-2694 |
1,524 | linux | f84598bd7c851f8b0bf8cd0d7c3be0d73c432ff4 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f84598bd7c851f8b0bf8cd0d7c3be0d73c432ff4 | x86/microcode/intel: Guard against stack overflow in the loader
mc_saved_tmp is a static array allocated on the stack, we need to make
sure mc_saved_count stays within its bounds, otherwise we're overflowing
the stack in _save_mc(). A specially crafted microcode header could lead
to a kernel crash or potentially kerne... | 1 | get_matching_model_microcode(int cpu, unsigned long start,
void *data, size_t size,
struct mc_saved_data *mc_saved_data,
unsigned long *mc_saved_in_initrd,
struct ucode_cpu_info *uci)
{
u8 *ucode_ptr = data;
unsigned int leftover = size;
enum ucode_state state = UCODE_OK;
unsigned in... | 43,839,155,311,078,540,000,000,000,000,000,000,000 | intel_early.c | 194,639,615,795,702,100,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2015-2666 | Stack-based buffer overflow in the get_matching_model_microcode function in arch/x86/kernel/cpu/microcode/intel_early.c in the Linux kernel before 4.0 allows context-dependent attackers to gain privileges by constructing a crafted microcode header and leveraging root privileges for write access to the initrd. | https://nvd.nist.gov/vuln/detail/CVE-2015-2666 |
1,529 | pacemaker | 84ac07c | https://github.com/ClusterLabs/pacemaker | https://github.com/ClusterLabs/pacemaker/commit/84ac07c | Fix: acl: Do not delay evaluation of added nodes in some situations
It is not appropriate when the node has no children as it is not a
placeholder | 1 | __xml_acl_post_process(xmlNode * xml)
{
xmlNode *cIter = __xml_first_child(xml);
xml_private_t *p = xml->_private;
if(is_set(p->flags, xpf_created)) {
xmlAttr *xIter = NULL;
/* Always allow new scaffolding, ie. node with no attributes or only an 'id' */
for (xIter = crm_firs... | 62,179,770,258,691,625,000,000,000,000,000,000,000 | xml.c | 2,819,314,212,835,514,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2015-1867 | Pacemaker before 1.1.13 does not properly evaluate added nodes, which allows remote read-only users to gain privileges via an acl command. | https://nvd.nist.gov/vuln/detail/CVE-2015-1867 |
1,532 | linux | f0d1bec9d58d4c038d0ac958c9af82be6eb18045 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f0d1bec9d58d4c038d0ac958c9af82be6eb18045 | new helper: copy_page_from_iter()
parallel to copy_page_to_iter(). pipe_write() switched to it (and became
->write_iter()).
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk> | 1 | pipe_write(struct kiocb *iocb, const struct iovec *_iov,
unsigned long nr_segs, loff_t ppos)
{
struct file *filp = iocb->ki_filp;
struct pipe_inode_info *pipe = filp->private_data;
ssize_t ret;
int do_wakeup;
struct iovec *iov = (struct iovec *)_iov;
size_t total_len;
ssize_t chars;
total_len = iov_l... | 332,092,449,061,268,540,000,000,000,000,000,000,000 | pipe.c | 294,209,790,332,872,760,000,000,000,000,000,000,000 | [
"CWE-17"
] | CVE-2015-1805 | The (1) pipe_read and (2) pipe_write implementations in fs/pipe.c in the Linux kernel before 3.16 do not properly consider the side effects of failed __copy_to_user_inatomic and __copy_from_user_inatomic calls, which allows local users to cause a denial of service (system crash) or possibly gain privileges via a crafte... | https://nvd.nist.gov/vuln/detail/CVE-2015-1805 |
1,534 | openssl | cd30f03ac5bf2962f44bd02ae8d88245dff2f12c | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/cd30f03ac5bf2962f44bd02ae8d88245dff2f12c | Canonicalise input in CMS_verify.
If content is detached and not binary mode translate the input to
CRLF format. Before this change the input was verified verbatim
which lead to a discrepancy between sign and verify. | 1 | static void do_free_upto(BIO *f, BIO *upto)
{
if (upto)
{
BIO *tbio;
do
{
tbio = BIO_pop(f);
BIO_free(f);
f = tbio;
}
while (f != upto);
}
else
BIO_free_all(f);
}
| 77,045,330,790,459,330,000,000,000,000,000,000,000 | None | null | [
"CWE-399"
] | CVE-2015-1792 | The do_free_upto function in crypto/cms/cms_smime.c in OpenSSL before 0.9.8zg, 1.0.0 before 1.0.0s, 1.0.1 before 1.0.1n, and 1.0.2 before 1.0.2b allows remote attackers to cause a denial of service (infinite loop) via vectors that trigger a NULL value of a BIO data structure, as demonstrated by an unrecognized X.660 OI... | https://nvd.nist.gov/vuln/detail/CVE-2015-1792 |
1,535 | openssl | 98ece4eebfb6cd45cc8d550c6ac0022965071afc | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/98ece4eebfb6cd45cc8d550c6ac0022965071afc | Fix race condition in NewSessionTicket
If a NewSessionTicket is received by a multi-threaded client when
attempting to reuse a previous ticket then a race condition can occur
potentially leading to a double free of the ticket data.
CVE-2015-1791
This also fixes RT#3808 where a session ID is changed for a session alr... | 1 | int ssl3_get_new_session_ticket(SSL *s)
{
int ok, al, ret = 0, ticklen;
long n;
const unsigned char *p;
unsigned char *d;
n = s->method->ssl_get_message(s,
SSL3_ST_CR_SESSION_TICKET_A,
SSL3_ST_CR_SESSION_TICKET_B,
... | 136,608,154,302,472,780,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2015-1791 | Race condition in the ssl3_get_new_session_ticket function in ssl/s3_clnt.c in OpenSSL before 0.9.8zg, 1.0.0 before 1.0.0s, 1.0.1 before 1.0.1n, and 1.0.2 before 1.0.2b, when used for a multi-threaded client, allows remote attackers to cause a denial of service (double free and application crash) or possibly have unspe... | https://nvd.nist.gov/vuln/detail/CVE-2015-1791 |
1,536 | openssl | 59302b600e8d5b77ef144e447bb046fd7ab72686 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/59302b600e8d5b77ef144e447bb046fd7ab72686 | PKCS#7: Fix NULL dereference with missing EncryptedContent.
CVE-2015-1790
Reviewed-by: Rich Salz <rsalz@openssl.org> | 1 | BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert)
{
int i, j;
BIO *out = NULL, *btmp = NULL, *etmp = NULL, *bio = NULL;
X509_ALGOR *xa;
ASN1_OCTET_STRING *data_body = NULL;
const EVP_MD *evp_md;
const EVP_CIPHER *evp_cipher = NULL;
EVP_CIPHER_CTX *evp_ctx = NULL;
... | 294,269,827,177,663,870,000,000,000,000,000,000,000 | None | null | [
"CWE-703"
] | CVE-2015-1790 | The PKCS7_dataDecodefunction in crypto/pkcs7/pk7_doit.c in OpenSSL before 0.9.8zg, 1.0.0 before 1.0.0s, 1.0.1 before 1.0.1n, and 1.0.2 before 1.0.2b allows remote attackers to cause a denial of service (NULL pointer dereference and application crash) via a PKCS#7 blob that uses ASN.1 encoding and lacks inner EncryptedC... | https://nvd.nist.gov/vuln/detail/CVE-2015-1790 |
1,537 | openssl | f48b83b4fb7d6689584cf25f61ca63a4891f5b11 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/f48b83b4fb7d6689584cf25f61ca63a4891f5b11 | Fix length checks in X509_cmp_time to avoid out-of-bounds reads.
Also tighten X509_cmp_time to reject more than three fractional
seconds in the time; and to reject trailing garbage after the offset.
CVE-2015-1789
Reviewed-by: Viktor Dukhovni <viktor@openssl.org>
Reviewed-by: Richard Levitte <levitte@openssl.org> | 1 | int X509_cmp_time(const ASN1_TIME *ctm, time_t *cmp_time)
{
char *str;
ASN1_TIME atm;
long offset;
char buff1[24], buff2[24], *p;
int i, j;
p = buff1;
i = ctm->length;
str = (char *)ctm->data;
if (ctm->type == V_ASN1_UTCTIME) {
if ((i < 11) || (i > 17))
r... | 277,602,867,865,507,800,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2015-1789 | The X509_cmp_time function in crypto/x509/x509_vfy.c in OpenSSL before 0.9.8zg, 1.0.0 before 1.0.0s, 1.0.1 before 1.0.1n, and 1.0.2 before 1.0.2b allows remote attackers to cause a denial of service (out-of-bounds read and application crash) via a crafted length field in ASN1_TIME data, as demonstrated by an attack aga... | https://nvd.nist.gov/vuln/detail/CVE-2015-1789 |
1,538 | linux | 4e7c22d447bb6d7e37bfe39ff658486ae78e8d77 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4e7c22d447bb6d7e37bfe39ff658486ae78e8d77 | x86, mm/ASLR: Fix stack randomization on 64-bit systems
The issue is that the stack for processes is not properly randomized on
64 bit architectures due to an integer overflow.
The affected function is randomize_stack_top() in file
"fs/binfmt_elf.c":
static unsigned long randomize_stack_top(unsigned long stack_top... | 1 | static unsigned int stack_maxrandom_size(void)
{
unsigned int max = 0;
if ((current->flags & PF_RANDOMIZE) &&
!(current->personality & ADDR_NO_RANDOMIZE)) {
max = ((-1U) & STACK_RND_MASK) << PAGE_SHIFT;
}
return max;
}
| 221,663,256,924,278,800,000,000,000,000,000,000,000 | mmap.c | 64,657,617,513,672,540,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2015-1593 | The stack randomization feature in the Linux kernel before 3.19.1 on 64-bit platforms uses incorrect data types for the results of bitwise left-shift operations, which makes it easier for attackers to bypass the ASLR protection mechanism by predicting the address of the top of the stack, related to the randomize_stack_... | https://nvd.nist.gov/vuln/detail/CVE-2015-1593 |
1,539 | linux | 4e7c22d447bb6d7e37bfe39ff658486ae78e8d77 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4e7c22d447bb6d7e37bfe39ff658486ae78e8d77 | x86, mm/ASLR: Fix stack randomization on 64-bit systems
The issue is that the stack for processes is not properly randomized on
64 bit architectures due to an integer overflow.
The affected function is randomize_stack_top() in file
"fs/binfmt_elf.c":
static unsigned long randomize_stack_top(unsigned long stack_top... | 1 | static unsigned long randomize_stack_top(unsigned long stack_top)
{
unsigned int random_variable = 0;
if ((current->flags & PF_RANDOMIZE) &&
!(current->personality & ADDR_NO_RANDOMIZE)) {
random_variable = get_random_int() & STACK_RND_MASK;
random_variable <<= PAGE_SHIFT;
}
#ifdef CONFIG_STACK_GROWSUP... | 272,678,573,193,334,060,000,000,000,000,000,000,000 | binfmt_elf.c | 233,173,923,575,517,170,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2015-1593 | The stack randomization feature in the Linux kernel before 3.19.1 on 64-bit platforms uses incorrect data types for the results of bitwise left-shift operations, which makes it easier for attackers to bypass the ASLR protection mechanism by predicting the address of the top of the stack, related to the randomize_stack_... | https://nvd.nist.gov/vuln/detail/CVE-2015-1593 |
1,542 | linux | 600ddd6825543962fb807884169e57b580dba208 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/600ddd6825543962fb807884169e57b580dba208 | net: sctp: fix slab corruption from use after free on INIT collisions
When hitting an INIT collision case during the 4WHS with AUTH enabled, as
already described in detail in commit 1be9a950c646 ("net: sctp: inherit
auth_capable on INIT collisions"), it can happen that we occasionally
still remotely trigger the follow... | 1 | void sctp_assoc_update(struct sctp_association *asoc,
struct sctp_association *new)
{
struct sctp_transport *trans;
struct list_head *pos, *temp;
/* Copy in new parameters of peer. */
asoc->c = new->c;
asoc->peer.rwnd = new->peer.rwnd;
asoc->peer.sack_needed = new->peer.sack_needed;
asoc->peer.auth_cap... | 245,205,618,481,032,000,000,000,000,000,000,000,000 | associola.c | 137,893,471,795,738,340,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2015-1421 | Use-after-free vulnerability in the sctp_assoc_update function in net/sctp/associola.c in the Linux kernel before 3.18.8 allows remote attackers to cause a denial of service (slab corruption and panic) or possibly have unspecified other impact by triggering an INIT collision that leads to improper handling of shared-ke... | https://nvd.nist.gov/vuln/detail/CVE-2015-1421 |
1,543 | lxcfs | 8ee2a503e102b1a43ec4d83113dc275ab20a869a | https://github.com/lxc/lxcfs | https://github.com/lxc/lxcfs/commit/8ee2a503e102b1a43ec4d83113dc275ab20a869a | Implement privilege check when moving tasks
When writing pids to a tasks file in lxcfs, lxcfs was checking
for privilege over the tasks file but not over the pid being
moved. Since the cgm_movepid request is done as root on the host,
not with the requestor's credentials, we must copy the check which
cgmanager was doi... | 1 | static bool do_write_pids(pid_t tpid, const char *contrl, const char *cg, const char *file, const char *buf)
{
int sock[2] = {-1, -1};
pid_t qpid, cpid = -1;
FILE *pids_file = NULL;
bool answer = false, fail = false;
pids_file = open_pids_file(contrl, cg);
if (!pids_file)
return false;
/*
* write the pi... | 6,339,406,417,675,714,000,000,000,000,000,000,000 | None | null | [
"CWE-264"
] | CVE-2015-1344 | The do_write_pids function in lxcfs.c in LXCFS before 0.12 does not properly check permissions, which allows local users to gain privileges by writing a pid to the tasks file. | https://nvd.nist.gov/vuln/detail/CVE-2015-1344 |
1,565 | lxc | 72cf81f6a3404e35028567db2c99a90406e9c6e6 | https://github.com/lxc/lxc | https://github.com/lxc/lxc/commit/72cf81f6a3404e35028567db2c99a90406e9c6e6 | CVE-2015-1331: lxclock: use /run/lxc/lock rather than /run/lock/lxc
This prevents an unprivileged user to use LXC to create arbitrary file
on the filesystem.
Signed-off-by: Serge Hallyn <serge.hallyn@ubuntu.com>
Signed-off-by: Tyler Hicks <tyhicks@canonical.com>
Acked-by: Stéphane Graber <stgraber@ubuntu.com> | 1 | static char *lxclock_name(const char *p, const char *n)
{
int ret;
int len;
char *dest;
char *rundir;
/* lockfile will be:
* "/run" + "/lock/lxc/$lxcpath/$lxcname + '\0' if root
* or
* $XDG_RUNTIME_DIR + "/lock/lxc/$lxcpath/$lxcname + '\0' if non-root
*/
/* length of "/lock/lxc/" + $lxcpath + "/" ... | 245,452,041,723,366,300,000,000,000,000,000,000,000 | lxclock.c | 215,606,032,687,124,040,000,000,000,000,000,000,000 | [
"CWE-59"
] | CVE-2015-1331 | lxclock.c in LXC 1.1.2 and earlier allows local users to create arbitrary files via a symlink attack on /run/lock/lxc/*. | https://nvd.nist.gov/vuln/detail/CVE-2015-1331 |
1,567 | libuv | 66ab38918c911bcff025562cf06237d7fedaba0c | https://github.com/libuv/libuv | https://github.com/libuv/libuv/commit/66ab38918c911bcff025562cf06237d7fedaba0c | unix: call setgoups before calling setuid/setgid
Partial fix for #1093 | 1 | static void uv__process_child_init(const uv_process_options_t* options,
int stdio_count,
int (*pipes)[2],
int error_fd) {
int close_fd;
int use_fd;
int fd;
if (options->flags & UV_PROCESS_DETACHED)
sets... | 260,532,967,559,578,820,000,000,000,000,000,000,000 | process.c | 230,071,590,411,145,400,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2015-0278 | libuv before 0.10.34 does not properly drop group privileges, which allows context-dependent attackers to gain privileges via unspecified vectors. | https://nvd.nist.gov/vuln/detail/CVE-2015-0278 |
1,578 | linux | f3747379accba8e95d70cec0eae0582c8c182050 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f3747379accba8e95d70cec0eae0582c8c182050 | KVM: x86: SYSENTER emulation is broken
SYSENTER emulation is broken in several ways:
1. It misses the case of 16-bit code segments completely (CVE-2015-0239).
2. MSR_IA32_SYSENTER_CS is checked in 64-bit mode incorrectly (bits 0 and 1 can
still be set without causing #GP).
3. MSR_IA32_SYSENTER_EIP and MSR_IA32_SYSE... | 1 | static int em_sysenter(struct x86_emulate_ctxt *ctxt)
{
const struct x86_emulate_ops *ops = ctxt->ops;
struct desc_struct cs, ss;
u64 msr_data;
u16 cs_sel, ss_sel;
u64 efer = 0;
ops->get_msr(ctxt, MSR_EFER, &efer);
/* inject #GP if in real mode */
if (ctxt->mode == X86EMUL_MODE_REAL)
return emulate_gp(ctxt, ... | 288,467,064,513,453,420,000,000,000,000,000,000,000 | emulate.c | 260,001,730,116,912,800,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2015-0239 | The em_sysenter function in arch/x86/kvm/emulate.c in the Linux kernel before 3.18.5, when the guest OS lacks SYSENTER MSR initialization, allows guest OS users to gain guest OS privileges or cause a denial of service (guest OS crash) by triggering use of a 16-bit code segment for emulation of a SYSENTER instruction. | https://nvd.nist.gov/vuln/detail/CVE-2015-0239 |
1,579 | php-src | b585a3aed7880a5fa5c18e2b838fc96f40e075bd | https://github.com/php/php-src | https://github.com/php/php-src/commit/b585a3aed7880a5fa5c18e2b838fc96f40e075bd | Fix for bug #68710 (Use After Free Vulnerability in PHP's unserialize()) | 1 | static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long elements, int objprops)
{
while (elements-- > 0) {
zval *key, *data, **old_data;
ALLOC_INIT_ZVAL(key);
if (!php_var_unserialize(&key, p, max, NULL TSRMLS_CC)) {
zval_dtor(key);
FREE_ZVAL(key);
return 0;
}
if (Z_TYPE_... | 722,330,690,057,935,600,000,000,000,000,000,000 | None | null | [
"CWE-94"
] | CVE-2015-0231 | Use-after-free vulnerability in the process_nested_data function in ext/standard/var_unserializer.re in PHP before 5.4.37, 5.5.x before 5.5.21, and 5.6.x before 5.6.5 allows remote attackers to execute arbitrary code via a crafted unserialize call that leverages improper handling of duplicate numerical keys within the ... | https://nvd.nist.gov/vuln/detail/CVE-2015-0231 |
1,580 | openssl | 103b171d8fc282ef435f8de9afbf7782e312961f | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/103b171d8fc282ef435f8de9afbf7782e312961f | A memory leak can occur in dtls1_buffer_record if either of the calls to
ssl3_setup_buffers or pqueue_insert fail. The former will fail if there is a
malloc failure, whilst the latter will fail if attempting to add a duplicate
record to the queue. This should never happen because duplicate records should
be detected an... | 1 | dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority)
{
DTLS1_RECORD_DATA *rdata;
pitem *item;
/* Limit the size of the queue to prevent DOS attacks */
if (pqueue_size(queue->q) >= 100)
return 0;
rdata = OPENSSL_malloc(sizeof(DTLS1_RECORD_DATA));
item = pitem_new(priority, rdata);
... | 114,939,372,772,634,080,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2015-0206 | Memory leak in the dtls1_buffer_record function in d1_pkt.c in OpenSSL 1.0.0 before 1.0.0p and 1.0.1 before 1.0.1k allows remote attackers to cause a denial of service (memory consumption) by sending many duplicate records for the next epoch, leading to failure of replay detection. | https://nvd.nist.gov/vuln/detail/CVE-2015-0206 |
1,584 | openssl | 1421e0c584ae9120ca1b88098f13d6d2e90b83a3 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/1421e0c584ae9120ca1b88098f13d6d2e90b83a3 | Unauthenticated DH client certificate fix.
Fix to prevent use of DH client certificates without sending
certificate verify message.
If we've used a client certificate to generate the premaster secret
ssl3_get_client_key_exchange returns 2 and ssl3_get_cert_verify is
never called.
We can only skip the certificate ver... | 1 | int ssl3_get_cert_verify(SSL *s)
{
EVP_PKEY *pkey=NULL;
unsigned char *p;
int al,ok,ret=0;
long n;
int type=0,i,j;
X509 *peer;
const EVP_MD *md = NULL;
EVP_MD_CTX mctx;
EVP_MD_CTX_init(&mctx);
n=s->method->ssl_get_message(s,
SSL3_ST_SR_CERT_VRFY_A,
SSL3_ST_SR_CERT_VRFY_B,
-1,
SSL3_RT_MAX_PLAIN_LENGT... | 212,984,391,365,092,660,000,000,000,000,000,000,000 | None | null | [
"CWE-310"
] | CVE-2015-0205 | The ssl3_get_cert_verify function in s3_srvr.c in OpenSSL 1.0.0 before 1.0.0p and 1.0.1 before 1.0.1k accepts client authentication with a Diffie-Hellman (DH) certificate without requiring a CertificateVerify message, which allows remote attackers to obtain access without knowledge of a private key via crafted TLS Hand... | https://nvd.nist.gov/vuln/detail/CVE-2015-0205 |
1,586 | openssl | ce325c60c74b0fa784f5872404b722e120e5cab0 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/ce325c60c74b0fa784f5872404b722e120e5cab0 | Only allow ephemeral RSA keys in export ciphersuites.
OpenSSL clients would tolerate temporary RSA keys in non-export
ciphersuites. It also had an option SSL_OP_EPHEMERAL_RSA which
enabled this server side. Remove both options as they are a
protocol violation.
Thanks to Karthikeyan Bhargavan for reporting this issue.... | 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... | 19,329,931,296,243,780,000,000,000,000,000,000,000 | None | null | [
"CWE-310"
] | CVE-2015-0204 | 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 RSA-to-EXPORT_RSA downgrade attacks and facilitate brute-force decryption by offering a weak ephemeral RSA key in a noncompliant role, related to the "FREAK" issue... | https://nvd.nist.gov/vuln/detail/CVE-2015-0204 |
1,593 | linux | e237ec37ec154564f8690c5bd1795339955eeef9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e237ec37ec154564f8690c5bd1795339955eeef9 | udf: Check component length before reading it
Check that length specified in a component of a symlink fits in the
input buffer we are reading. Also properly ignore component length for
component types that do not use it. Otherwise we read memory after end
of buffer for corrupted udf image.
Reported-by: Carl Henrik Lu... | 1 | static int udf_pc_to_char(struct super_block *sb, unsigned char *from,
int fromlen, unsigned char *to, int tolen)
{
struct pathComponent *pc;
int elen = 0;
int comp_len;
unsigned char *p = to;
/* Reserve one byte for terminating \0 */
tolen--;
while (elen < fromlen) {
pc = (struct pathComponent *)(fro... | 325,864,361,331,960,330,000,000,000,000,000,000,000 | symlink.c | 76,715,452,543,384,660,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2014-9730 | The udf_pc_to_char function in fs/udf/symlink.c in the Linux kernel before 3.18.2 relies on component lengths that are unused, which allows local users to cause a denial of service (system crash) via a crafted UDF filesystem image. | https://nvd.nist.gov/vuln/detail/CVE-2014-9730 |
1,596 | linux | 942080643bce061c3dd9d5718d3b745dcb39a8bc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/942080643bce061c3dd9d5718d3b745dcb39a8bc | eCryptfs: Remove buggy and unnecessary write in file name decode routine
Dmitry Chernenkov used KASAN to discover that eCryptfs writes past the
end of the allocated buffer during encrypted filename decoding. This
fix corrects the issue by getting rid of the unnecessary 0 write when
the current bit offset is 2.
Signed... | 1 | ecryptfs_decode_from_filename(unsigned char *dst, size_t *dst_size,
const unsigned char *src, size_t src_size)
{
u8 current_bit_offset = 0;
size_t src_byte_offset = 0;
size_t dst_byte_offset = 0;
if (dst == NULL) {
(*dst_size) = ecryptfs_max_decoded_size(src_size);
goto out;
}
while (src_byte_offset... | 288,062,041,952,122,140,000,000,000,000,000,000,000 | crypto.c | 83,043,817,776,762,890,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-9683 | Off-by-one error in the ecryptfs_decode_from_filename function in fs/ecryptfs/crypto.c in the eCryptfs subsystem in the Linux kernel before 3.18.2 allows local users to cause a denial of service (buffer overflow and system crash) or possibly gain privileges via a crafted filename. | https://nvd.nist.gov/vuln/detail/CVE-2014-9683 |
1,600 | linux | 4943ba16bbc2db05115707b3ff7b4874e9e3c560 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4943ba16bbc2db05115707b3ff7b4874e9e3c560 | crypto: include crypto- module prefix in template
This adds the module loading prefix "crypto-" to the template lookup
as well.
For example, attempting to load 'vfat(blowfish)' via AF_ALG now correctly
includes the "crypto-" prefix at every level, correctly rejecting "vfat":
net-pf-38
algif-hash
crypto-vfat(blowf... | 1 | struct crypto_template *crypto_lookup_template(const char *name)
{
return try_then_request_module(__crypto_lookup_template(name), "%s",
name);
}
| 116,020,862,207,451,470,000,000,000,000,000,000,000 | algapi.c | 187,872,088,690,328,180,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-9644 | The Crypto API in the Linux kernel before 3.18.5 allows local users to load arbitrary kernel modules via a bind system call for an AF_ALG socket with a parenthesized module template expression in the salg_name field, as demonstrated by the vfat(aes) expression, a different vulnerability than CVE-2013-7421. | https://nvd.nist.gov/vuln/detail/CVE-2014-9644 |
1,601 | file | 65437cee25199dbd385fb35901bc0011e164276c | https://github.com/file/file | https://github.com/file/file/commit/65437cee25199dbd385fb35901bc0011e164276c | Limit string printing to 100 chars, and add flags I forgot in the previous
commit. | 1 | donote(struct magic_set *ms, void *vbuf, size_t offset, size_t size,
int clazz, int swap, size_t align, int *flags, uint16_t *notecount)
{
Elf32_Nhdr nh32;
Elf64_Nhdr nh64;
size_t noff, doff;
uint32_t namesz, descsz;
unsigned char *nbuf = CAST(unsigned char *, vbuf);
if (*notecount == 0)
return 0;
--*note... | 206,842,038,504,383,380,000,000,000,000,000,000,000 | readelf.c | 196,087,564,373,822,200,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2014-9621 | The ELF parser in file 5.16 through 5.21 allows remote attackers to cause a denial of service via a long string. | https://nvd.nist.gov/vuln/detail/CVE-2014-9621 |
1,611 | linux | 4e2024624e678f0ebb916e6192bd23c1f9fdf696 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4e2024624e678f0ebb916e6192bd23c1f9fdf696 | isofs: Fix unchecked printing of ER records
We didn't check length of rock ridge ER records before printing them.
Thus corrupted isofs image can cause us to access and print some memory
behind the buffer with obvious consequences.
Reported-and-tested-by: Carl Henrik Lunde <chlunde@ping.uio.no>
CC: stable@vger.kernel.... | 1 | parse_rock_ridge_inode_internal(struct iso_directory_record *de,
struct inode *inode, int flags)
{
int symlink_len = 0;
int cnt, sig;
unsigned int reloc_block;
struct inode *reloc;
struct rock_ridge *rr;
int rootflag;
struct rock_state rs;
int ret = 0;
if (!ISOFS_SB(inode->i_sb)->s_rock)
return 0;
ini... | 76,826,098,986,089,410,000,000,000,000,000,000,000 | rock.c | 282,024,907,067,004,600,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-9584 | The parse_rock_ridge_inode_internal function in fs/isofs/rock.c in the Linux kernel before 3.18.2 does not validate a length value in the Extensions Reference (ER) System Use Field, which allows local users to obtain sensitive information from kernel memory via a crafted iso9660 image. | https://nvd.nist.gov/vuln/detail/CVE-2014-9584 |
1,612 | linux | a3a8784454692dd72e5d5d34dcdab17b4420e74c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a3a8784454692dd72e5d5d34dcdab17b4420e74c | KEYS: close race between key lookup and freeing
When a key is being garbage collected, it's key->user would get put before
the ->destroy() callback is called, where the key is removed from it's
respective tracking structures.
This leaves a key hanging in a semi-invalid state which leaves a window open
for a different... | 1 | static noinline void key_gc_unused_keys(struct list_head *keys)
{
while (!list_empty(keys)) {
struct key *key =
list_entry(keys->next, struct key, graveyard_link);
list_del(&key->graveyard_link);
kdebug("- %u", key->serial);
key_check(key);
security_key_free(key);
/* deal with the user's key tracking... | 146,841,926,446,616,660,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-9529 | Race condition in the key_gc_unused_keys function in security/keys/gc.c in the Linux kernel through 3.18.2 allows local users to cause a denial of service (memory corruption or panic) or possibly have unspecified other impact via keyctl commands that trigger access to a key structure member during garbage collection of... | https://nvd.nist.gov/vuln/detail/CVE-2014-9529 |
1,613 | libsndfile | dbe14f00030af5d3577f4cabbf9861db59e9c378 | https://github.com/erikd/libsndfile | https://github.com/erikd/libsndfile/commit/dbe14f00030af5d3577f4cabbf9861db59e9c378 | src/sd2.c : Fix two potential buffer read overflows.
Closes: https://github.com/erikd/libsndfile/issues/93 | 1 | sd2_parse_rsrc_fork (SF_PRIVATE *psf)
{ SD2_RSRC rsrc ;
int k, marker, error = 0 ;
psf_use_rsrc (psf, SF_TRUE) ;
memset (&rsrc, 0, sizeof (rsrc)) ;
rsrc.rsrc_len = psf_get_filelen (psf) ;
psf_log_printf (psf, "Resource length : %d (0x%04X)\n", rsrc.rsrc_len, rsrc.rsrc_len) ;
if (rsrc.rsrc_len > SIGNED_SIZEOF ... | 340,051,541,888,924,920,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2014-9496 | The sd2_parse_rsrc_fork function in sd2.c in libsndfile allows attackers to have unspecified impact via vectors related to a (1) map offset or (2) rsrc marker, which triggers an out-of-bounds read. | https://nvd.nist.gov/vuln/detail/CVE-2014-9496 |
1,618 | krb5 | a197e92349a4aa2141b5dff12e9dd44c2a2166e3 | https://github.com/krb5/krb5 | https://github.com/krb5/krb5/commit/a197e92349a4aa2141b5dff12e9dd44c2a2166e3 | Fix kadm5/gssrpc XDR double free [CVE-2014-9421]
[MITKRB5-SA-2015-001] In auth_gssapi_unwrap_data(), do not free
partial deserialization results upon failure to deserialize. This
responsibility belongs to the callers, svctcp_getargs() and
svcudp_getargs(); doing it in the unwrap function results in freeing
the result... | 1 | bool_t auth_gssapi_unwrap_data(
OM_uint32 *major,
OM_uint32 *minor,
gss_ctx_id_t context,
uint32_t seq_num,
XDR *in_xdrs,
bool_t (*xdr_func)(),
caddr_t xdr_ptr)
{
gss_buffer_desc in_buf, out_buf;
XDR temp_xdrs;
uint32_t verf_seq_num;
int conf, qop;
unsigned in... | 6,731,538,295,626,295,000,000,000,000,000,000,000 | auth_gssapi_misc.c | 249,867,039,175,423,800,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2014-9421 | The auth_gssapi_unwrap_data function in lib/rpc/auth_gssapi_misc.c in MIT Kerberos 5 (aka krb5) through 1.11.5, 1.12.x through 1.12.2, and 1.13.x before 1.13.1 does not properly handle partial XDR deserialization, which allows remote authenticated users to cause a denial of service (use-after-free and double free, and ... | https://nvd.nist.gov/vuln/detail/CVE-2014-9421 |
1,619 | openssl | 470990fee0182566d439ef7e82d1abf18b7085d7 | https://github.com/openssl/openssl | https://github.com/openssl/openssl/commit/470990fee0182566d439ef7e82d1abf18b7085d7 | Free up s->d1->buffered_app_data.q properly.
PR#3286 | 1 | static void dtls1_clear_queues(SSL *s)
{
pitem *item = NULL;
hm_fragment *frag = NULL;
DTLS1_RECORD_DATA *rdata;
while( (item = pqueue_pop(s->d1->unprocessed_rcds.q)) != NULL)
{
rdata = (DTLS1_RECORD_DATA *) item->data;
if (rdata->rbuf.buf)
{
OPENSSL_free(rdata->rbuf.buf);
}
... | 120,961,465,274,779,570,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2014-8176 | The dtls1_clear_queues function in ssl/d1_lib.c in OpenSSL before 0.9.8za, 1.0.0 before 1.0.0m, and 1.0.1 before 1.0.1h frees data structures without considering that application data can arrive between a ChangeCipherSpec message and a Finished message, which allows remote DTLS peers to cause a denial of service (memor... | https://nvd.nist.gov/vuln/detail/CVE-2014-8176 |
1,634 | linux | db29a9508a9246e77087c5531e45b2c88ec6988b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/db29a9508a9246e77087c5531e45b2c88ec6988b | netfilter: conntrack: disable generic tracking for known protocols
Given following iptables ruleset:
-P FORWARD DROP
-A FORWARD -m sctp --dport 9 -j ACCEPT
-A FORWARD -p tcp --dport 80 -j ACCEPT
-A FORWARD -p tcp -m conntrack -m state ESTABLISHED,RELATED -j ACCEPT
One would assume that this allows SCTP on port 9 and... | 1 | static bool generic_new(struct nf_conn *ct, const struct sk_buff *skb,
unsigned int dataoff, unsigned int *timeouts)
{
return true;
}
| 94,206,534,282,979,970,000,000,000,000,000,000,000 | nf_conntrack_proto_generic.c | 39,813,758,207,073,290,000,000,000,000,000,000,000 | [
"CWE-254"
] | CVE-2014-8160 | net/netfilter/nf_conntrack_proto_generic.c in the Linux kernel before 3.18 generates incorrect conntrack entries during handling of certain iptables rule sets for the SCTP, DCCP, GRE, and UDP-Lite protocols, which allows remote attackers to bypass intended access restrictions via packets with disallowed port numbers. | https://nvd.nist.gov/vuln/detail/CVE-2014-8160 |
1,635 | linux | 8d0207652cbe27d1f962050737848e5ad4671958 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8d0207652cbe27d1f962050737848e5ad4671958 | ->splice_write() via ->write_iter()
iter_file_splice_write() - a ->splice_write() instance that gathers the
pipe buffers, builds a bio_vec-based iov_iter covering those and feeds
it to ->write_iter(). A bunch of simple cases coverted to that...
[AV: fixed the braino spotted by Cyrill]
Signed-off-by: Al Viro <viro@z... | 1 | xfs_file_splice_write(
struct pipe_inode_info *pipe,
struct file *outfilp,
loff_t *ppos,
size_t count,
unsigned int flags)
{
struct inode *inode = outfilp->f_mapping->host;
struct xfs_inode *ip = XFS_I(inode);
int ioflags = 0;
ssize_t ret;
XFS_STATS_INC(xs_write_calls);
if (outfilp->f_mode & FMODE... | 58,931,614,698,813,260,000,000,000,000,000,000,000 | None | null | [
"CWE-264"
] | CVE-2014-7822 | The implementation of certain splice_write file operations in the Linux kernel before 3.16 does not enforce a restriction on the maximum size of a single file, which allows local users to cause a denial of service (system crash) or possibly have unspecified other impact via a crafted splice system call, as demonstrated... | https://nvd.nist.gov/vuln/detail/CVE-2014-7822 |
1,636 | krb5 | 102bb6ebf20f9174130c85c3b052ae104e5073ec | https://github.com/krb5/krb5 | https://github.com/krb5/krb5/commit/102bb6ebf20f9174130c85c3b052ae104e5073ec | Fix krb5_read_message handling [CVE-2014-5355]
In recvauth_common, do not use strcmp against the data fields of
krb5_data objects populated by krb5_read_message(), as there is no
guarantee that they are C strings. Instead, create an expected
krb5_data value and use data_eq().
In the sample user-to-user server applic... | 1 | int main(argc, argv)
int argc;
char *argv[];
{
krb5_data pname_data, tkt_data;
int sock = 0;
socklen_t l;
int retval;
struct sockaddr_in l_inaddr, f_inaddr; /* local, foreign address */
krb5_creds creds, *new_creds;
krb5_ccache cc;
krb5_data msgtext, msg;
krb5_context ... | 132,886,479,854,659,200,000,000,000,000,000,000,000 | server.c | 36,266,010,581,253,480,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2014-5355 | MIT Kerberos 5 (aka krb5) through 1.13.1 incorrectly expects that a krb5_read_message data field is represented as a string ending with a '\0' character, which allows remote attackers to (1) cause a denial of service (NULL pointer dereference) via a zero-byte version string or (2) cause a denial of service (out-of-boun... | https://nvd.nist.gov/vuln/detail/CVE-2014-5355 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.