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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
911 | linux | 7314e613d5ff9f0934f7a0f74ed7973b903315d1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/7314e613d5ff9f0934f7a0f74ed7973b903315d1 | Fix a few incorrectly checked [io_]remap_pfn_range() calls
Nico Golde reports a few straggling uses of [io_]remap_pfn_range() that
really should use the vm_iomap_memory() helper. This trivially converts
two of them to the helper, and comments about why the third one really
needs to continue to use remap_pfn_range(), ... | 1 | static int uio_mmap_physical(struct vm_area_struct *vma)
{
struct uio_device *idev = vma->vm_private_data;
int mi = uio_find_mem_index(vma);
if (mi < 0)
return -EINVAL;
vma->vm_ops = &uio_physical_vm_ops;
vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
return remap_pfn_range(vma,
... | 124,769,329,517,591,230,000,000,000,000,000,000,000 | uio.c | 189,572,155,418,257,000,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-6763 | The uio_mmap_physical function in drivers/uio/uio.c in the Linux kernel before 3.12 does not validate the size of a memory block, which allows local users to cause a denial of service (memory corruption) or possibly gain privileges via crafted mmap operations, a different vulnerability than CVE-2013-4511. | https://nvd.nist.gov/vuln/detail/CVE-2013-6763 |
912 | linux | 7314e613d5ff9f0934f7a0f74ed7973b903315d1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/7314e613d5ff9f0934f7a0f74ed7973b903315d1 | Fix a few incorrectly checked [io_]remap_pfn_range() calls
Nico Golde reports a few straggling uses of [io_]remap_pfn_range() that
really should use the vm_iomap_memory() helper. This trivially converts
two of them to the helper, and comments about why the third one really
needs to continue to use remap_pfn_range(), ... | 1 | int au1100fb_fb_mmap(struct fb_info *fbi, struct vm_area_struct *vma)
{
struct au1100fb_device *fbdev;
unsigned int len;
unsigned long start=0, off;
fbdev = to_au1100fb_device(fbi);
if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT)) {
return -EINVAL;
}
start = fbdev->fb_phys & PAGE_MASK;
len = PAGE_ALIGN((star... | 177,273,139,877,749,560,000,000,000,000,000,000,000 | au1100fb.c | 171,201,343,492,238,250,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-6763 | The uio_mmap_physical function in drivers/uio/uio.c in the Linux kernel before 3.12 does not validate the size of a memory block, which allows local users to cause a denial of service (memory corruption) or possibly gain privileges via crafted mmap operations, a different vulnerability than CVE-2013-4511. | https://nvd.nist.gov/vuln/detail/CVE-2013-6763 |
913 | linux | 7314e613d5ff9f0934f7a0f74ed7973b903315d1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/7314e613d5ff9f0934f7a0f74ed7973b903315d1 | Fix a few incorrectly checked [io_]remap_pfn_range() calls
Nico Golde reports a few straggling uses of [io_]remap_pfn_range() that
really should use the vm_iomap_memory() helper. This trivially converts
two of them to the helper, and comments about why the third one really
needs to continue to use remap_pfn_range(), ... | 1 | static int au1200fb_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
{
unsigned int len;
unsigned long start=0, off;
struct au1200fb_device *fbdev = info->par;
if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT)) {
return -EINVAL;
}
start = fbdev->fb_phys & PAGE_MASK;
len = PAGE_ALIGN((start & ~PAGE_MASK) +... | 67,752,722,467,221,080,000,000,000,000,000,000,000 | au1200fb.c | 20,588,446,351,461,834,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-6763 | The uio_mmap_physical function in drivers/uio/uio.c in the Linux kernel before 3.12 does not validate the size of a memory block, which allows local users to cause a denial of service (memory corruption) or possibly gain privileges via crafted mmap operations, a different vulnerability than CVE-2013-4511. | https://nvd.nist.gov/vuln/detail/CVE-2013-6763 |
914 | linux | cf970c002d270c36202bd5b9c2804d3097a52da0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cf970c002d270c36202bd5b9c2804d3097a52da0 | ping: prevent NULL pointer dereference on write to msg_name
A plain read() on a socket does set msg->msg_name to NULL. So check for
NULL pointer first.
Signed-off-by: Hannes Frederic Sowa <hannes@stressinduktion.org>
Signed-off-by: David S. Miller <davem@davemloft.net> | 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 sk_buff *skb;
int copied, err;
pr_debug("ping_recvmsg(sk=%p,sk->num=%u)\n", isk, isk->inet_num);
err = -EOPNOT... | 155,904,653,362,942,950,000,000,000,000,000,000,000 | ping.c | 52,362,142,179,938,880,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2013-6432 | The ping_recvmsg function in net/ipv4/ping.c in the Linux kernel before 3.12.4 does not properly interact with read system calls on ping sockets, which allows local users to cause a denial of service (NULL pointer dereference and system crash) by leveraging unspecified privileges to execute a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-6432 |
915 | linux | f856567b930dfcdbc3323261bf77240ccdde01f5 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f856567b930dfcdbc3323261bf77240ccdde01f5 | aacraid: missing capable() check in compat ioctl
In commit d496f94d22d1 ('[SCSI] aacraid: fix security weakness') we
added a check on CAP_SYS_RAWIO to the ioctl. The compat ioctls need the
check as well.
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <torv... | 1 | static int aac_compat_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
{
struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata;
return aac_compat_do_ioctl(dev, cmd, (unsigned long)arg);
}
| 240,252,914,944,451,600,000,000,000,000,000,000,000 | linit.c | 335,956,036,663,395,150,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2013-6383 | The aac_compat_ioctl function in drivers/scsi/aacraid/linit.c in the Linux kernel before 3.11.8 does not require the CAP_SYS_RAWIO capability, which allows local users to bypass intended access restrictions via a crafted ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-6383 |
916 | linux | 6fb392b1a63ae36c31f62bc3fc8630b49d602b62 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6fb392b1a63ae36c31f62bc3fc8630b49d602b62 | qeth: avoid buffer overflow in snmp ioctl
Check user-defined length in snmp ioctl request and allow request
only if it fits into a qeth command buffer.
Signed-off-by: Ursula Braun <ursula.braun@de.ibm.com>
Signed-off-by: Frank Blaschka <frank.blaschka@de.ibm.com>
Reviewed-by: Heiko Carstens <heicars2@linux.vnet.ibm.c... | 1 | int qeth_snmp_command(struct qeth_card *card, char __user *udata)
{
struct qeth_cmd_buffer *iob;
struct qeth_ipa_cmd *cmd;
struct qeth_snmp_ureq *ureq;
int req_len;
struct qeth_arp_query_info qinfo = {0, };
int rc = 0;
QETH_CARD_TEXT(card, 3, "snmpcmd");
if (card->info.guestlan)
return -EOPNOTSUPP;
... | 104,798,081,715,700,400,000,000,000,000,000,000,000 | qeth_core_main.c | 236,635,939,498,951,130,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-6381 | Buffer overflow in the qeth_snmp_command function in drivers/s390/net/qeth_core_main.c in the Linux kernel through 3.12.1 allows local users to cause a denial of service or possibly have unspecified other impact via an SNMP ioctl call with a length value that is incompatible with the command-buffer size. | https://nvd.nist.gov/vuln/detail/CVE-2013-6381 |
917 | linux | a497e47d4aec37aaf8f13509f3ef3d1f6a717d88 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a497e47d4aec37aaf8f13509f3ef3d1f6a717d88 | libertas: potential oops in debugfs
If we do a zero size allocation then it will oops. Also we can't be
sure the user passes us a NUL terminated string so I've added a
terminator.
This code can only be triggered by root.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-... | 1 | static ssize_t lbs_debugfs_write(struct file *f, const char __user *buf,
size_t cnt, loff_t *ppos)
{
int r, i;
char *pdata;
char *p;
char *p0;
char *p1;
char *p2;
struct debug_data *d = f->private_data;
pdata = kmalloc(cnt, GFP_KERNEL);
if (pdata == NULL)
return 0;
if (copy_from_user(pdata, b... | 75,946,839,779,695,430,000,000,000,000,000,000,000 | debugfs.c | 106,884,417,614,616,100,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-6378 | The lbs_debugfs_write function in drivers/net/wireless/libertas/debugfs.c in the Linux kernel through 3.12.1 allows local users to cause a denial of service (OOPS) by leveraging root privileges for a zero-length write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-6378 |
918 | linux | 17d68b763f09a9ce824ae23eb62c9efc57b69271 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/17d68b763f09a9ce824ae23eb62c9efc57b69271 | KVM: x86: fix guest-initiated crash with x2apic (CVE-2013-6376)
A guest can cause a BUG_ON() leading to a host kernel crash.
When the guest writes to the ICR to request an IPI, while in x2apic
mode the following things happen, the destination is read from
ICR2, which is a register that the guest can control.
kvm_irq_... | 1 | static void recalculate_apic_map(struct kvm *kvm)
{
struct kvm_apic_map *new, *old = NULL;
struct kvm_vcpu *vcpu;
int i;
new = kzalloc(sizeof(struct kvm_apic_map), GFP_KERNEL);
mutex_lock(&kvm->arch.apic_map_lock);
if (!new)
goto out;
new->ldr_bits = 8;
/* flat mode is default */
new->cid_shift = 8;
... | 90,650,423,270,339,170,000,000,000,000,000,000,000 | lapic.c | 190,243,646,842,195,860,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-6376 | The recalculate_apic_map function in arch/x86/kvm/lapic.c in the KVM subsystem in the Linux kernel through 3.12.5 allows guest OS users to cause a denial of service (host OS crash) via a crafted ICR write operation in x2apic mode. | https://nvd.nist.gov/vuln/detail/CVE-2013-6376 |
926 | linux | b963a22e6d1a266a67e9eecc88134713fd54775c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b963a22e6d1a266a67e9eecc88134713fd54775c | KVM: x86: Fix potential divide by 0 in lapic (CVE-2013-6367)
Under guest controllable circumstances apic_get_tmcct will execute a
divide by zero and cause a crash. If the guest cpuid support
tsc deadline timers and performs the following sequence of requests
the host will crash.
- Set the mode to periodic
- Set the T... | 1 | static u32 apic_get_tmcct(struct kvm_lapic *apic)
{
ktime_t remaining;
s64 ns;
u32 tmcct;
ASSERT(apic != NULL);
/* if initial count is 0, current count should also be 0 */
if (kvm_apic_get_reg(apic, APIC_TMICT) == 0)
return 0;
remaining = hrtimer_get_remaining(&apic->lapic_timer.timer);
if (ktime_to_... | 154,149,295,278,805,450,000,000,000,000,000,000,000 | lapic.c | 163,667,959,038,676,530,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-6367 | The apic_get_tmcct function in arch/x86/kvm/lapic.c in the KVM subsystem in the Linux kernel through 3.12.5 allows guest OS users to cause a denial of service (divide-by-zero error and host OS crash) via crafted modifications of the TMICT value. | https://nvd.nist.gov/vuln/detail/CVE-2013-6367 |
929 | polarssl | 1922a4e6aade7b1d685af19d4d9339ddb5c02859 | https://github.com/polarssl/polarssl | https://github.com/polarssl/polarssl/commit/1922a4e6aade7b1d685af19d4d9339ddb5c02859 | ssl_parse_certificate() now calls x509parse_crt_der() directly | 1 | int ssl_parse_certificate( ssl_context *ssl )
{
int ret;
size_t i, n;
SSL_DEBUG_MSG( 2, ( "=> parse certificate" ) );
if( ssl->endpoint == SSL_IS_SERVER &&
ssl->authmode == SSL_VERIFY_NONE )
{
ssl->verify_result = BADCERT_SKIP_VERIFY;
SSL_DEBUG_MSG( 2, ( "<= skip parse cert... | 79,433,638,809,905,910,000,000,000,000,000,000,000 | ssl_tls.c | 193,081,241,478,287,840,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-4623 | The x509parse_crt function in x509.h in PolarSSL 1.1.x before 1.1.7 and 1.2.x before 1.2.8 does not properly parse certificate messages during the SSL/TLS handshake, which allows remote attackers to cause a denial of service (infinite loop and CPU consumption) via a certificate message that contains a PEM encoded certi... | https://nvd.nist.gov/vuln/detail/CVE-2013-4623 |
930 | linux | 7d3e91a89b7adbc2831334def9e494dd9892f9af | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/7d3e91a89b7adbc2831334def9e494dd9892f9af | NFSv4: Check for buffer length in __nfs4_get_acl_uncached
Commit 1f1ea6c "NFSv4: Fix buffer overflow checking in
__nfs4_get_acl_uncached" accidently dropped the checking for too small
result buffer length.
If someone uses getxattr on "system.nfs4_acl" on an NFSv4 mount
supporting ACLs, the ACL has not been cached and... | 1 | static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
{
struct page *pages[NFS4ACL_MAXPAGES] = {NULL, };
struct nfs_getaclargs args = {
.fh = NFS_FH(inode),
.acl_pages = pages,
.acl_len = buflen,
};
struct nfs_getaclres res = {
.acl_len = buflen,
};
struct rpc_message msg =... | 318,227,710,018,918,440,000,000,000,000,000,000,000 | nfs4proc.c | 246,421,749,327,099,480,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4591 | Buffer overflow in the __nfs4_get_acl_uncached function in fs/nfs/nfs4proc.c in the Linux kernel before 3.7.2 allows local users to cause a denial of service (memory corruption and system crash) or possibly have unspecified other impact via a getxattr system call for the system.nfs4_acl extended attribute of a pathname... | https://nvd.nist.gov/vuln/detail/CVE-2013-4591 |
931 | linux | 04bcef2a83f40c6db24222b27a52892cba39dffb | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/04bcef2a83f40c6db24222b27a52892cba39dffb | ipvs: Add boundary check on ioctl arguments
The ipvs code has a nifty system for doing the size of ioctl command
copies; it defines an array with values into which it indexes the cmd
to find the right length.
Unfortunately, the ipvs code forgot to check if the cmd was in the
range that the array provides, allowing fo... | 1 | do_ip_vs_set_ctl(struct sock *sk, int cmd, void __user *user, unsigned int len)
{
int ret;
unsigned char arg[MAX_ARG_LEN];
struct ip_vs_service_user *usvc_compat;
struct ip_vs_service_user_kern usvc;
struct ip_vs_service *svc;
struct ip_vs_dest_user *udest_compat;
struct ip_vs_dest_user_kern udest;
if (!capab... | 83,673,314,409,807,090,000,000,000,000,000,000,000 | ip_vs_ctl.c | 16,053,961,743,391,224,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4588 | Multiple stack-based buffer overflows in net/netfilter/ipvs/ip_vs_ctl.c in the Linux kernel before 2.6.33, when CONFIG_IP_VS is used, allow local users to gain privileges by leveraging the CAP_NET_ADMIN capability for (1) a getsockopt system call, related to the do_ip_vs_get_ctl function, or (2) a setsockopt system cal... | https://nvd.nist.gov/vuln/detail/CVE-2013-4588 |
932 | linux | 338c7dbadd2671189cec7faf64c84d01071b3f96 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/338c7dbadd2671189cec7faf64c84d01071b3f96 | KVM: Improve create VCPU parameter (CVE-2013-4587)
In multiple functions the vcpu_id is used as an offset into a bitfield. Ag
malicious user could specify a vcpu_id greater than 255 in order to set or
clear bits in kernel memory. This could be used to elevate priveges in the
kernel. This patch verifies that the vcp... | 1 | static int kvm_vm_ioctl_create_vcpu(struct kvm *kvm, u32 id)
{
int r;
struct kvm_vcpu *vcpu, *v;
vcpu = kvm_arch_vcpu_create(kvm, id);
if (IS_ERR(vcpu))
return PTR_ERR(vcpu);
preempt_notifier_init(&vcpu->preempt_notifier, &kvm_preempt_ops);
r = kvm_arch_vcpu_setup(vcpu);
if (r)
goto vcpu_destroy;
... | 78,071,846,559,468,940,000,000,000,000,000,000,000 | kvm_main.c | 162,946,847,399,016,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-4587 | Array index error in the kvm_vm_ioctl_create_vcpu function in virt/kvm/kvm_main.c in the KVM subsystem in the Linux kernel through 3.12.5 allows local users to gain privileges via a large id value. | https://nvd.nist.gov/vuln/detail/CVE-2013-4587 |
933 | linux | 0e033e04c2678dbbe74a46b23fffb7bb918c288e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/0e033e04c2678dbbe74a46b23fffb7bb918c288e | ipv6: fix headroom calculation in udp6_ufo_fragment
Commit 1e2bd517c108816220f262d7954b697af03b5f9c ("udp6: Fix udp
fragmentation for tunnel traffic.") changed the calculation if
there is enough space to include a fragment header in the skb from a
skb->mac_header dervived one to skb_headroom. Because we already peeled... | 1 | static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb,
netdev_features_t features)
{
struct sk_buff *segs = ERR_PTR(-EINVAL);
unsigned int mss;
unsigned int unfrag_ip6hlen, unfrag_len;
struct frag_hdr *fptr;
u8 *packet_start, *prevhdr;
u8 nexthdr;
u8 frag_hdr_sz = sizeof(struct frag_hdr);
int offse... | 168,959,719,558,504,360,000,000,000,000,000,000,000 | udp_offload.c | 333,651,348,407,875,630,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-4563 | The udp6_ufo_fragment function in net/ipv6/udp_offload.c in the Linux kernel through 3.12, when UDP Fragmentation Offload (UFO) is enabled, does not properly perform a certain size comparison before inserting a fragment header, which allows remote attackers to cause a denial of service (panic) via a large IPv6 UDP pack... | https://nvd.nist.gov/vuln/detail/CVE-2013-4563 |
934 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 1 | static int mp_get_count(struct sb_uart_state *state, struct serial_icounter_struct *icnt)
{
struct serial_icounter_struct icount;
struct sb_uart_icount cnow;
struct sb_uart_port *port = state->port;
spin_lock_irq(&port->lock);
memcpy(&cnow, &port->icount, sizeof(struct sb_uart_icount));
spin_unlock_irq(&por... | 46,385,543,661,315,150,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
935 | linux | 8d1e72250c847fa96498ec029891de4dc638a5ba | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8d1e72250c847fa96498ec029891de4dc638a5ba | Staging: bcm: info leak in ioctl
The DevInfo.u32Reserved[] array isn't initialized so it leaks kernel
information to user space.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus To... | 1 | static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
{
struct bcm_tarang_data *pTarang = filp->private_data;
void __user *argp = (void __user *)arg;
struct bcm_mini_adapter *Adapter = pTarang->Adapter;
INT Status = STATUS_FAILURE;
int timeout = 0;
struct bcm_ioctl_buffer IoBuffer;
int bytes;
BCM_... | 15,758,140,552,209,270,000,000,000,000,000,000,000 | Bcmchar.c | 297,513,847,153,823,100,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-4515 | The bcm_char_ioctl function in drivers/staging/bcm/Bcmchar.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via an IOCTL_BCM_GET_DEVICE_DRIVER_INFO ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4515 |
936 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 1 | int wvlan_set_station_nickname(struct net_device *dev,
struct iw_request_info *info,
union iwreq_data *wrqu,
char *extra)
{
struct wl_private *lp = wl_priv(dev);
unsigned long flags;
int ret = 0;
/*------------------------------------------------------------------------*/
DB... | 62,431,484,736,668,090,000,000,000,000,000,000,000 | wl_priv.c | 140,308,459,115,906,430,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
937 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 1 | int wvlan_uil_put_info(struct uilreq *urq, struct wl_private *lp)
{
int result = 0;
ltv_t *pLtv;
bool_t ltvAllocated = FALSE;
ENCSTRCT sEncryption;
#ifdef USE_WDS
hcf_16 hcfPort = HCF_PORT_0;
#endif /* USE_WDS */
/*---... | 192,300,055,996,805,040,000,000,000,000,000,000,000 | wl_priv.c | 140,308,459,115,906,430,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
938 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 1 | static ssize_t oz_cdev_write(struct file *filp, const char __user *buf,
size_t count, loff_t *fpos)
{
struct oz_pd *pd;
struct oz_elt_buf *eb;
struct oz_elt_info *ei;
struct oz_elt *elt;
struct oz_app_hdr *app_hdr;
struct oz_serial_ctx *ctx;
spin_lock_bh(&g_cdev.lock);
pd = g_cdev.active_pd;
if (pd)
... | 33,191,172,042,980,295,000,000,000,000,000,000,000 | ozcdev.c | 132,604,815,029,829,930,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
956 | linux | 6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | ipc,sem: fine grained locking for semtimedop
Introduce finer grained locking for semtimedop, to handle the common case
of a program wanting to manipulate one semaphore from an array with
multiple semaphores.
If the call is a semop manipulating just one semaphore in an array with
multiple semaphores, only take the loc... | 1 | void ipc_rcu_putref(void *ptr)
{
if (--container_of(ptr, struct ipc_rcu_hdr, data)->refcount > 0)
return;
if (container_of(ptr, struct ipc_rcu_hdr, data)->is_vmalloc) {
call_rcu(&container_of(ptr, struct ipc_rcu_grace, data)->rcu,
ipc_schedule_free);
} else {
kfree_rcu(container_of(ptr, struct ipc_rc... | 147,913,652,096,999,230,000,000,000,000,000,000,000 | util.c | 17,292,951,975,649,307,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-4483 | The ipc_rcu_putref function in ipc/util.c in the Linux kernel before 3.10 does not properly manage a reference count, which allows local users to cause a denial of service (memory consumption or system crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-4483 |
957 | linux | e93b7d748be887cd7639b113ba7d7ef792a7efb9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e93b7d748be887cd7639b113ba7d7ef792a7efb9 | ip_output: do skb ufo init for peeked non ufo skb as well
Now, if user application does:
sendto len<mtu flag MSG_MORE
sendto len>mtu flag 0
The skb is not treated as fragmented one because it is not initialized
that way. So move the initialization to fix this.
introduced by:
commit e89e9cf539a28df7d0eb1d0a545368e9920... | 1 | static inline int ip_ufo_append_data(struct sock *sk,
struct sk_buff_head *queue,
int getfrag(void *from, char *to, int offset, int len,
int odd, struct sk_buff *skb),
void *from, int length, int hh_len, int fragheaderlen,
int transhdrlen, int maxfraglen, unsigned int flags)
{
struct sk_buff *skb... | 119,382,236,388,357,000,000,000,000,000,000,000,000 | None | null | [
"CWE-264"
] | CVE-2013-4470 | The Linux kernel before 3.12, when UDP Fragmentation Offload (UFO) is enabled, does not properly initialize certain data structures, which allows local users to cause a denial of service (memory corruption and system crash) or possibly gain privileges via a crafted application that uses the UDP_CORK option in a setsock... | https://nvd.nist.gov/vuln/detail/CVE-2013-4470 |
962 | linux | d661684cf6820331feae71146c35da83d794467e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d661684cf6820331feae71146c35da83d794467e | net: Check the correct namespace when spoofing pid over SCM_RIGHTS
This is a security bug.
The follow-up will fix nsproxy to discourage this type of issue from
happening again.
Cc: stable@vger.kernel.org
Signed-off-by: Andy Lutomirski <luto@amacapital.net>
Reviewed-by: "Eric W. Biederman" <ebiederm@xmission.com>
Sig... | 1 | static __inline__ int scm_check_creds(struct ucred *creds)
{
const struct cred *cred = current_cred();
kuid_t uid = make_kuid(cred->user_ns, creds->uid);
kgid_t gid = make_kgid(cred->user_ns, creds->gid);
if (!uid_valid(uid) || !gid_valid(gid))
return -EINVAL;
if ((creds->pid == task_tgid_vnr(current) ||
... | 113,094,377,788,410,970,000,000,000,000,000,000,000 | scm.c | 87,676,516,371,579,840,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2013-4300 | The scm_check_creds function in net/core/scm.c in the Linux kernel before 3.11 performs a capability check in an incorrect namespace, which allows local users to gain privileges via PID spoofing. | https://nvd.nist.gov/vuln/detail/CVE-2013-4300 |
964 | linux | 2433c8f094a008895e66f25bd1773cdb01c91d01 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/2433c8f094a008895e66f25bd1773cdb01c91d01 | net: Update the sysctl permissions handler to test effective uid/gid
Modify the code to use current_euid(), and in_egroup_p, as in done
in fs/proc/proc_sysctl.c:test_perm()
Cc: stable@vger.kernel.org
Reviewed-by: Eric Sandeen <sandeen@redhat.com>
Reported-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Eric W. ... | 1 | static int net_ctl_permissions(struct ctl_table_header *head,
struct ctl_table *table)
{
struct net *net = container_of(head->set, struct net, sysctls);
kuid_t root_uid = make_kuid(net->user_ns, 0);
kgid_t root_gid = make_kgid(net->user_ns, 0);
/* Allow network administrator to have same access as root... | 4,251,532,209,852,224,000,000,000,000,000,000,000 | sysctl_net.c | 256,848,416,992,939,300,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-4270 | The net_ctl_permissions function in net/sysctl_net.c in the Linux kernel before 3.11.5 does not properly determine uid and gid values, which allows local users to bypass intended /proc/sys/net restrictions via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-4270 |
965 | FFmpeg | c94f9e854228e0ea00e1de8769d8d3f7cab84a55 | https://github.com/FFmpeg/FFmpeg | https://github.com/FFmpeg/FFmpeg/commit/c94f9e854228e0ea00e1de8769d8d3f7cab84a55 | avutil/mem: Fix flipped condition
Fixes return code and later null pointer dereference
Found-by: Laurent Butti <laurentb@gmail.com>
Signed-off-by: Michael Niedermayer <michaelni@gmx.at> | 1 | int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
{
void **ptrptr = ptr;
*ptrptr = av_realloc_f(*ptrptr, nmemb, size);
if (!*ptrptr && !(nmemb && size))
return AVERROR(ENOMEM);
return 0;
}
| 104,455,358,682,340,870,000,000,000,000,000,000,000 | mem.c | 308,060,967,527,841,900,000,000,000,000,000,000,000 | [
"CWE-476"
] | CVE-2013-4265 | The av_reallocp_array function in libavutil/mem.c in FFmpeg before 2.0.1 has an unspecified impact and remote vectors related to a "wrong return code" and a resultant NULL pointer dereference. | https://nvd.nist.gov/vuln/detail/CVE-2013-4265 |
977 | linux | c95eb3184ea1a3a2551df57190c81da695e2144b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c95eb3184ea1a3a2551df57190c81da695e2144b | ARM: 7809/1: perf: fix event validation for software group leaders
It is possible to construct an event group with a software event as a
group leader and then subsequently add a hardware event to the group.
This results in the event group being validated by adding all members
of the group to a fake PMU and attempting ... | 1 | validate_event(struct pmu_hw_events *hw_events,
struct perf_event *event)
{
struct arm_pmu *armpmu = to_arm_pmu(event->pmu);
struct pmu *leader_pmu = event->group_leader->pmu;
if (event->pmu != leader_pmu || event->state < PERF_EVENT_STATE_OFF)
return 1;
if (event->state == PERF_EVENT_STATE_OFF &&... | 214,965,441,703,397,300,000,000,000,000,000,000,000 | perf_event.c | 244,258,602,866,703,960,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-4254 | The validate_event function in arch/arm/kernel/perf_event.c in the Linux kernel before 3.10.8 on the ARM platform allows local users to gain privileges or cause a denial of service (NULL pointer dereference and system crash) by adding a hardware event to an event group led by a software event. | https://nvd.nist.gov/vuln/detail/CVE-2013-4254 |
978 | linux | 1fc29bacedeabb278080e31bb9c1ecb49f143c3b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fc29bacedeabb278080e31bb9c1ecb49f143c3b | cifs: fix off-by-one bug in build_unc_path_to_root
commit 839db3d10a (cifs: fix up handling of prefixpath= option) changed
the code such that the vol->prepath no longer contained a leading
delimiter and then fixed up the places that accessed that field to
account for that change.
One spot in build_unc_path_to_root wa... | 1 | build_unc_path_to_root(const struct smb_vol *vol,
const struct cifs_sb_info *cifs_sb)
{
char *full_path, *pos;
unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
if (full_path == NUL... | 8,340,581,254,640,439,000,000,000,000,000,000,000 | connect.c | 127,914,316,993,594,920,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-4247 | Off-by-one error in the build_unc_path_to_root function in fs/cifs/connect.c in the Linux kernel before 3.9.6 allows remote attackers to cause a denial of service (memory corruption and system crash) via a DFS share mount operation that triggers use of an unexpected DFS referral name length. | https://nvd.nist.gov/vuln/detail/CVE-2013-4247 |
979 | libtiff | ce6841d9e41d621ba23cf18b190ee6a23b2cc833 | https://github.com/vadz/libtiff | https://github.com/vadz/libtiff/commit/ce6841d9e41d621ba23cf18b190ee6a23b2cc833 | fix possible OOB write in gif2tiff.c | 1 | process(register int code, unsigned char** fill)
{
int incode;
static unsigned char firstchar;
if (code == clear) {
codesize = datasize + 1;
codemask = (1 << codesize) - 1;
avail = clear + 2;
oldcode = -1;
return 1;
}
if (oldcode == -1) {
*(*fill)++ = suffix[code];
firstchar = oldcode ... | 49,639,759,056,433,870,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2013-4244 | The LZW decompressor in the gif2tiff tool in libtiff 4.0.3 and earlier allows context-dependent attackers to cause a denial of service (out-of-bounds write and crash) or possibly execute arbitrary code via a crafted GIF image. | https://nvd.nist.gov/vuln/detail/CVE-2013-4244 |
980 | linux | 9955ac47f4ba1c95ecb6092aeaefb40a22e99268 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9955ac47f4ba1c95ecb6092aeaefb40a22e99268 | arm64: don't kill the kernel on a bad esr from el0
Rather than completely killing the kernel if we receive an esr value we
can't deal with in the el0 handlers, send the process a SIGILL and log
the esr value in the hope that we can debug it. If we receive a bad esr
from el1, we'll die() as before.
Signed-off-by: Mark... | 1 | asmlinkage void bad_mode(struct pt_regs *regs, int reason, unsigned int esr)
{
console_verbose();
pr_crit("Bad mode in %s handler detected, code 0x%08x\n",
handler[reason], esr);
die("Oops - bad mode", regs, 0);
local_irq_disable();
panic("bad mode");
}
| 172,340,806,476,661,160,000,000,000,000,000,000,000 | traps.c | 194,636,283,620,040,100,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2013-4220 | The bad_mode function in arch/arm64/kernel/traps.c in the Linux kernel before 3.9.5 on the ARM64 platform allows local users to cause a denial of service (system crash) via vectors involving an attempted register access that triggers an unexpected value in the Exception Syndrome Register (ESR). | https://nvd.nist.gov/vuln/detail/CVE-2013-4220 |
982 | linux | 75a493e60ac4bbe2e977e7129d6d8cbb0dd236be | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/75a493e60ac4bbe2e977e7129d6d8cbb0dd236be | ipv6: ip6_append_data_mtu did not care about pmtudisc and frag_size
If the socket had an IPV6_MTU value set, ip6_append_data_mtu lost track
of this when appending the second frame on a corked socket. This results
in the following splat:
[37598.993962] ------------[ cut here ]------------
[37598.994008] kernel BUG at ... | 1 | static void ip6_append_data_mtu(int *mtu,
int *maxfraglen,
unsigned int fragheaderlen,
struct sk_buff *skb,
struct rt6_info *rt)
{
if (!(rt->dst.flags & DST_XFRM_TUNNEL)) {
if (skb == NULL) {
/* first fragment, reserve header_len */
*mtu = *mtu - rt->dst.header_len;
} else {
/*
... | 249,477,262,173,279,060,000,000,000,000,000,000,000 | ip6_output.c | 32,175,030,324,283,845,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-4163 | The ip6_append_data_mtu function in net/ipv6/ip6_output.c in the IPv6 implementation in the Linux kernel through 3.10.3 does not properly maintain information about whether the IPV6_MTU setsockopt option had been specified, which allows local users to cause a denial of service (BUG and system crash) via a crafted appli... | https://nvd.nist.gov/vuln/detail/CVE-2013-4163 |
984 | linux | 8822b64a0fa64a5dd1dfcf837c5b0be83f8c05d1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8822b64a0fa64a5dd1dfcf837c5b0be83f8c05d1 | ipv6: call udp_push_pending_frames when uncorking a socket with AF_INET pending data
We accidentally call down to ip6_push_pending_frames when uncorking
pending AF_INET data on a ipv6 socket. This results in the following
splat (from Dave Jones):
skbuff: skb_under_panic: text:ffffffff816765f6 len:48 put:40 head:ffff8... | 1 | static int udp_v6_push_pending_frames(struct sock *sk)
{
struct sk_buff *skb;
struct udphdr *uh;
struct udp_sock *up = udp_sk(sk);
struct inet_sock *inet = inet_sk(sk);
struct flowi6 *fl6 = &inet->cork.fl.u.ip6;
int err = 0;
int is_udplite = IS_UDPLITE(sk);
__wsum csum = 0;
/* Grab the skbuff where U... | 308,814,749,542,050,950,000,000,000,000,000,000,000 | udp.c | 46,858,807,665,352,770,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-4162 | The udp_v6_push_pending_frames function in net/ipv6/udp.c in the IPv6 implementation in the Linux kernel through 3.10.3 makes an incorrect function call for pending data, which allows local users to cause a denial of service (BUG and system crash) via a crafted application that uses the UDP_CORK option in a setsockopt ... | https://nvd.nist.gov/vuln/detail/CVE-2013-4162 |
985 | linux | c7e8e8a8f7a70b343ca1e0f90a31e35ab2d16de1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c7e8e8a8f7a70b343ca1e0f90a31e35ab2d16de1 | bridge: fix some kernel warning in multicast timer
Several people reported the warning: "kernel BUG at kernel/timer.c:729!"
and the stack trace is:
#7 [ffff880214d25c10] mod_timer+501 at ffffffff8106d905
#8 [ffff880214d25c50] br_multicast_del_pg.isra.20+261 at ffffffffa0731d25 [bridge]
#9 [ffff880214d25c80] br_mul... | 1 | static int __br_mdb_del(struct net_bridge *br, struct br_mdb_entry *entry)
{
struct net_bridge_mdb_htable *mdb;
struct net_bridge_mdb_entry *mp;
struct net_bridge_port_group *p;
struct net_bridge_port_group __rcu **pp;
struct br_ip ip;
int err = -EINVAL;
if (!netif_running(br->dev) || br->multicast_disabled)
... | 182,535,534,055,103,100,000,000,000,000,000,000,000 | br_mdb.c | 276,386,508,481,368,340,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-4129 | The bridge multicast implementation in the Linux kernel through 3.10.3 does not check whether a certain timer is armed before modifying the timeout value of that timer, which allows local users to cause a denial of service (BUG and system crash) via vectors involving the shutdown of a KVM virtual machine, related to ne... | https://nvd.nist.gov/vuln/detail/CVE-2013-4129 |
986 | linux | c7e8e8a8f7a70b343ca1e0f90a31e35ab2d16de1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c7e8e8a8f7a70b343ca1e0f90a31e35ab2d16de1 | bridge: fix some kernel warning in multicast timer
Several people reported the warning: "kernel BUG at kernel/timer.c:729!"
and the stack trace is:
#7 [ffff880214d25c10] mod_timer+501 at ffffffff8106d905
#8 [ffff880214d25c50] br_multicast_del_pg.isra.20+261 at ffffffffa0731d25 [bridge]
#9 [ffff880214d25c80] br_mul... | 1 | static void br_multicast_del_pg(struct net_bridge *br,
struct net_bridge_port_group *pg)
{
struct net_bridge_mdb_htable *mdb;
struct net_bridge_mdb_entry *mp;
struct net_bridge_port_group *p;
struct net_bridge_port_group __rcu **pp;
mdb = mlock_dereference(br->mdb, br);
mp = br_mdb_ip_get(mdb, &pg->addr);
... | 74,664,793,578,988,530,000,000,000,000,000,000,000 | br_multicast.c | 3,552,800,112,656,103,400,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-4129 | The bridge multicast implementation in the Linux kernel through 3.10.3 does not check whether a certain timer is armed before modifying the timeout value of that timer, which allows local users to cause a denial of service (BUG and system crash) via vectors involving the shutdown of a KVM virtual machine, related to ne... | https://nvd.nist.gov/vuln/detail/CVE-2013-4129 |
987 | linux | dd7633ecd553a5e304d349aa6f8eb8a0417098c5 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/dd7633ecd553a5e304d349aa6f8eb8a0417098c5 | vhost-net: fix use-after-free in vhost_net_flush
vhost_net_ubuf_put_and_wait has a confusing name:
it will actually also free it's argument.
Thus since commit 1280c27f8e29acf4af2da914e80ec27c3dbd5c01
"vhost-net: flush outstanding DMAs on memory change"
vhost_net_flush tries to use the argument after passing it
to ... | 1 | static long vhost_net_set_backend(struct vhost_net *n, unsigned index, int fd)
{
struct socket *sock, *oldsock;
struct vhost_virtqueue *vq;
struct vhost_net_virtqueue *nvq;
struct vhost_net_ubuf_ref *ubufs, *oldubufs = NULL;
int r;
mutex_lock(&n->dev.mutex);
r = vhost_dev_check_owner(&n->dev);
if (r)
goto er... | 241,366,389,520,784,070,000,000,000,000,000,000,000 | net.c | 277,417,259,469,627,080,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-4127 | Use-after-free vulnerability in the vhost_net_set_backend function in drivers/vhost/net.c in the Linux kernel through 3.10.3 allows local users to cause a denial of service (OOPS and system crash) via vectors involving powering on a virtual machine. | https://nvd.nist.gov/vuln/detail/CVE-2013-4127 |
988 | linux | 307f2fb95e9b96b3577916e73d92e104f8f26494 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/307f2fb95e9b96b3577916e73d92e104f8f26494 | ipv6: only static routes qualify for equal cost multipathing
Static routes in this case are non-expiring routes which did not get
configured by autoconf or by icmpv6 redirects.
To make sure we actually get an ecmp route while searching for the first
one in this fib6_node's leafs, also make sure it matches the ecmp ro... | 1 | static int fib6_add_rt2node(struct fib6_node *fn, struct rt6_info *rt,
struct nl_info *info)
{
struct rt6_info *iter = NULL;
struct rt6_info **ins;
int replace = (info->nlh &&
(info->nlh->nlmsg_flags & NLM_F_REPLACE));
int add = (!info->nlh ||
(info->nlh->nlmsg_flags & NLM_F_CREATE));
int f... | 27,152,909,099,956,750,000,000,000,000,000,000,000 | ip6_fib.c | 287,079,937,670,340,830,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-4125 | The fib6_add_rt2node function in net/ipv6/ip6_fib.c in the IPv6 stack in the Linux kernel through 3.10.1 does not properly handle Router Advertisement (RA) messages in certain circumstances involving three routes that initially qualified for membership in an ECMP route set until a change occurred for one of the first t... | https://nvd.nist.gov/vuln/detail/CVE-2013-4125 |
992 | linux | ea702b80e0bbb2448e201472127288beb82ca2fe | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ea702b80e0bbb2448e201472127288beb82ca2fe | cifs: move check for NULL socket into smb_send_rqst
Cai reported this oops:
[90701.616664] BUG: unable to handle kernel NULL pointer dereference at 0000000000000028
[90701.625438] IP: [<ffffffff814a343e>] kernel_setsockopt+0x2e/0x60
[90701.632167] PGD fea319067 PUD 103fda4067 PMD 0
[90701.637255] Oops: 0000 [#1] SMP
... | 1 | smb_send_rqst(struct TCP_Server_Info *server, struct smb_rqst *rqst)
{
int rc;
struct kvec *iov = rqst->rq_iov;
int n_vec = rqst->rq_nvec;
unsigned int smb_buf_length = get_rfc1002_length(iov[0].iov_base);
unsigned int i;
size_t total_len = 0, sent;
struct socket *ssocket = server->ssocket;
int val = 1;
c... | 125,179,843,386,250,260,000,000,000,000,000,000,000 | transport.c | 274,077,842,134,574,640,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2013-3302 | Race condition in the smb_send_rqst function in fs/cifs/transport.c in the Linux kernel before 3.7.2 allows local users to cause a denial of service (NULL pointer dereference and OOPS) or possibly have unspecified other impact via vectors involving a reconnection event. | https://nvd.nist.gov/vuln/detail/CVE-2013-3302 |
993 | linux | 6a76f8c0ab19f215af2a3442870eeb5f0e81998d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6a76f8c0ab19f215af2a3442870eeb5f0e81998d | tracing: Fix possible NULL pointer dereferences
Currently set_ftrace_pid and set_graph_function files use seq_lseek
for their fops. However seq_open() is called only for FMODE_READ in
the fops->open() so that if an user tries to seek one of those file
when she open it for writing, it sees NULL seq_file and then panic... | 1 | ftrace_regex_lseek(struct file *file, loff_t offset, int whence)
{
loff_t ret;
if (file->f_mode & FMODE_READ)
ret = seq_lseek(file, offset, whence);
else
file->f_pos = ret = 1;
return ret;
}
| 93,795,587,963,981,600,000,000,000,000,000,000,000 | ftrace.c | 76,813,553,117,675,730,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2013-3301 | The ftrace implementation in the Linux kernel before 3.8.8 allows local users to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by leveraging the CAP_SYS_ADMIN capability for write access to the (1) set_ftrace_pid or (2) set_graph_function file, and then ... | https://nvd.nist.gov/vuln/detail/CVE-2013-3301 |
994 | linux | d5e0d0f607a7a029c6563a0470d88255c89a8d11 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d5e0d0f607a7a029c6563a0470d88255c89a8d11 | VSOCK: Fix missing msg_namelen update in vsock_stream_recvmsg()
The code misses to update the msg_namelen member to 0 and therefore
makes net/socket.c leak the local, uninitialized sockaddr_storage
variable to userland -- 128 bytes of kernel stack memory.
Cc: Andy King <acking@vmware.com>
Cc: Dmitry Torokhov <dtor@vm... | 1 | vsock_stream_recvmsg(struct kiocb *kiocb,
struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
struct sock *sk;
struct vsock_sock *vsk;
int err;
size_t target;
ssize_t copied;
long timeout;
struct vsock_transport_recv_notify_data recv_data;
DEFINE_WAIT(wait);
sk = sock->sk;
vsk =... | 314,567,100,570,998,200,000,000,000,000,000,000,000 | af_vsock.c | 195,983,561,794,879,180,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3237 | The vsock_stream_sendmsg function in net/vmw_vsock/af_vsock.c in the Linux kernel before 3.9-rc7 does not initialize a certain length variable, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3237 |
995 | linux | 680d04e0ba7e926233e3b9cee59125ce181f66ba | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/680d04e0ba7e926233e3b9cee59125ce181f66ba | VSOCK: vmci - fix possible info leak in vmci_transport_dgram_dequeue()
In case we received no data on the call to skb_recv_datagram(), i.e.
skb->data is NULL, vmci_transport_dgram_dequeue() will return with 0
without updating msg_namelen leading to net/socket.c leaking the local,
uninitialized sockaddr_storage variabl... | 1 | static int vmci_transport_dgram_dequeue(struct kiocb *kiocb,
struct vsock_sock *vsk,
struct msghdr *msg, size_t len,
int flags)
{
int err;
int noblock;
struct vmci_datagram *dg;
size_t payload_len;
struct sk_buff *skb;
noblock = flags & MSG_DONTWAIT;
if (flags & MSG_OOB || flags & MSG_ERRQUEUE)... | 299,433,778,323,540,940,000,000,000,000,000,000,000 | vmci_transport.c | 219,632,399,675,326,650,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3236 | The vmci_transport_dgram_dequeue function in net/vmw_vsock/vmci_transport.c in the Linux kernel before 3.9-rc7 does not properly initialize a certain length variable, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3236 |
999 | linux | 4a184233f21645cf0b719366210ed445d1024d72 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4a184233f21645cf0b719366210ed445d1024d72 | rose: fix info leak via msg_name in rose_recvmsg()
The code in rose_recvmsg() does not initialize all of the members of
struct sockaddr_rose/full_sockaddr_rose when filling the sockaddr info.
Nor does it initialize the padding bytes of the structure inserted by
the compiler for alignment. This will lead to leaking uni... | 1 | static int rose_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t size, int flags)
{
struct sock *sk = sock->sk;
struct rose_sock *rose = rose_sk(sk);
struct sockaddr_rose *srose = (struct sockaddr_rose *)msg->msg_name;
size_t copied;
unsigned char *asmptr;
struct sk_buff *skb;
int n... | 8,668,028,458,710,471,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-3234 | The rose_recvmsg function in net/rose/af_rose.c in the Linux kernel before 3.9-rc7 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3234 |
1,000 | linux | d26d6504f23e803824e8ebd14e52d4fc0a0b09cb | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d26d6504f23e803824e8ebd14e52d4fc0a0b09cb | NFC: llcp: fix info leaks via msg_name in llcp_sock_recvmsg()
The code in llcp_sock_recvmsg() does not initialize all the members of
struct sockaddr_nfc_llcp when filling the sockaddr info. Nor does it
initialize the padding bytes of the structure inserted by the compiler
for alignment.
Also, if the socket is in stat... | 1 | static int llcp_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
int noblock = flags & MSG_DONTWAIT;
struct sock *sk = sock->sk;
unsigned int copied, rlen;
struct sk_buff *skb, *cskb;
int err = 0;
pr_debug("%p %zu\n", sk, len);
lock_sock(sk);
if... | 122,362,862,671,268,250,000,000,000,000,000,000,000 | sock.c | 231,788,118,584,435,060,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3233 | The llcp_sock_recvmsg function in net/nfc/llcp/sock.c in the Linux kernel before 3.9-rc7 does not initialize a certain length variable and a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3233 |
1,001 | linux | 3ce5efad47b62c57a4f5c54248347085a750ce0e | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/3ce5efad47b62c57a4f5c54248347085a750ce0e | netrom: fix info leak via msg_name in nr_recvmsg()
In case msg_name is set the sockaddr info gets filled out, as
requested, but the code fails to initialize the padding bytes of
struct sockaddr_ax25 inserted by the compiler for alignment. Also
the sax25_ndigis member does not get assigned, leaking four more
bytes.
Bo... | 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... | 180,984,074,270,992,030,000,000,000,000,000,000,000 | af_netrom.c | 82,889,468,786,918,020,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3232 | The nr_recvmsg function in net/netrom/af_netrom.c in the Linux kernel before 3.9-rc7 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3232 |
1,002 | linux | c77a4b9cffb6215a15196ec499490d116dfad181 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c77a4b9cffb6215a15196ec499490d116dfad181 | llc: Fix missing msg_namelen update in llc_ui_recvmsg()
For stream sockets the code misses to update the msg_namelen member
to 0 and therefore makes net/socket.c leak the local, uninitialized
sockaddr_storage variable to userland -- 128 bytes of kernel stack
memory. The msg_namelen update is also missing for datagram ... | 1 | static int llc_ui_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
struct sockaddr_llc *uaddr = (struct sockaddr_llc *)msg->msg_name;
const int nonblock = flags & MSG_DONTWAIT;
struct sk_buff *skb = NULL;
struct sock *sk = sock->sk;
struct llc_sock *llc = llc_sk(sk... | 63,715,411,456,460,920,000,000,000,000,000,000,000 | af_llc.c | 114,091,511,487,822,400,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3231 | The llc_ui_recvmsg function in net/llc/af_llc.c in the Linux kernel before 3.9-rc7 does not initialize a certain length variable, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3231 |
1,003 | linux | b860d3cc62877fad02863e2a08efff69a19382d2 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b860d3cc62877fad02863e2a08efff69a19382d2 | l2tp: fix info leak in l2tp_ip6_recvmsg()
The L2TP code for IPv6 fails to initialize the l2tp_conn_id member of
struct sockaddr_l2tpip6 and therefore leaks four bytes kernel stack
in l2tp_ip6_recvmsg() in case msg_name is set.
Initialize l2tp_conn_id with 0 to avoid the info leak.
Signed-off-by: Mathias Krause <mini... | 1 | static int l2tp_ip6_recvmsg(struct kiocb *iocb, struct sock *sk,
struct msghdr *msg, size_t len, int noblock,
int flags, int *addr_len)
{
struct ipv6_pinfo *np = inet6_sk(sk);
struct sockaddr_l2tpip6 *lsa = (struct sockaddr_l2tpip6 *)msg->msg_name;
size_t copied = 0;
int err = -EOPNOTSUPP;
struct sk_... | 153,456,865,559,495,400,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-3230 | The l2tp_ip6_recvmsg function in net/l2tp/l2tp_ip6.c in the Linux kernel before 3.9-rc7 does not initialize a certain structure member, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3230 |
1,004 | linux | a5598bd9c087dc0efc250a5221e5d0e6f584ee88 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a5598bd9c087dc0efc250a5221e5d0e6f584ee88 | iucv: Fix missing msg_namelen update in iucv_sock_recvmsg()
The current code does not fill the msg_name member in case it is set.
It also does not set the msg_namelen member to 0 and therefore makes
net/socket.c leak the local, uninitialized sockaddr_storage variable
to userland -- 128 bytes of kernel stack memory.
F... | 1 | static int iucv_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
int noblock = flags & MSG_DONTWAIT;
struct sock *sk = sock->sk;
struct iucv_sock *iucv = iucv_sk(sk);
unsigned int copied, rlen;
struct sk_buff *skb, *rskb, *cskb;
int err = 0;
if ((sk-... | 292,835,413,067,186,280,000,000,000,000,000,000,000 | af_iucv.c | 219,701,138,014,006,630,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3229 | The iucv_sock_recvmsg function in net/iucv/af_iucv.c in the Linux kernel before 3.9-rc7 does not initialize a certain length variable, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3229 |
1,005 | linux | 5ae94c0d2f0bed41d6718be743985d61b7f5c47d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5ae94c0d2f0bed41d6718be743985d61b7f5c47d | irda: Fix missing msg_namelen update in irda_recvmsg_dgram()
The current code does not fill the msg_name member in case it is set.
It also does not set the msg_namelen member to 0 and therefore makes
net/socket.c leak the local, uninitialized sockaddr_storage variable
to userland -- 128 bytes of kernel stack memory.
... | 1 | static int irda_recvmsg_dgram(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t size, int flags)
{
struct sock *sk = sock->sk;
struct irda_sock *self = irda_sk(sk);
struct sk_buff *skb;
size_t copied;
int err;
IRDA_DEBUG(4, "%s()\n", __func__);
skb = skb_recv_datagram(sk, flags &... | 124,022,070,218,876,070,000,000,000,000,000,000,000 | af_irda.c | 27,854,743,174,609,383,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3228 | The irda_recvmsg_dgram function in net/irda/af_irda.c in the Linux kernel before 3.9-rc7 does not initialize a certain length variable, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3228 |
1,006 | linux | 2d6fbfe733f35c6b355c216644e08e149c61b271 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/2d6fbfe733f35c6b355c216644e08e149c61b271 | caif: Fix missing msg_namelen update in caif_seqpkt_recvmsg()
The current code does not fill the msg_name member in case it is set.
It also does not set the msg_namelen member to 0 and therefore makes
net/socket.c leak the local, uninitialized sockaddr_storage variable
to userland -- 128 bytes of kernel stack memory.
... | 1 | static int caif_seqpkt_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *m, size_t len, int flags)
{
struct sock *sk = sock->sk;
struct sk_buff *skb;
int ret;
int copylen;
ret = -EOPNOTSUPP;
if (m->msg_flags&MSG_OOB)
goto read_error;
skb = skb_recv_datagram(sk, flags, 0 , &ret);
if (... | 338,803,166,792,488,470,000,000,000,000,000,000,000 | caif_socket.c | 303,346,703,858,979,250,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3227 | The caif_seqpkt_recvmsg function in net/caif/caif_socket.c in the Linux kernel before 3.9-rc7 does not initialize a certain length variable, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3227 |
1,007 | linux | e11e0455c0d7d3d62276a0c55d9dfbc16779d691 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e11e0455c0d7d3d62276a0c55d9dfbc16779d691 | Bluetooth: RFCOMM - Fix missing msg_namelen update in rfcomm_sock_recvmsg()
If RFCOMM_DEFER_SETUP is set in the flags, rfcomm_sock_recvmsg() returns
early with 0 without updating the possibly set msg_namelen member. This,
in turn, leads to a 128 byte kernel stack leak in net/socket.c.
Fix this by updating msg_namelen... | 1 | static int rfcomm_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t size, int flags)
{
struct sock *sk = sock->sk;
struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
int len;
if (test_and_clear_bit(RFCOMM_DEFER_SETUP, &d->flags)) {
rfcomm_dlc_accept(d);
return 0;
}
len... | 318,172,830,474,011,800,000,000,000,000,000,000,000 | sock.c | 118,776,679,674,709,350,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3225 | The rfcomm_sock_recvmsg function in net/bluetooth/rfcomm/sock.c in the Linux kernel before 3.9-rc7 does not initialize a certain length variable, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3225 |
1,008 | linux | 4683f42fde3977bdb4e8a09622788cc8b5313778 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4683f42fde3977bdb4e8a09622788cc8b5313778 | Bluetooth: fix possible info leak in bt_sock_recvmsg()
In case the socket is already shutting down, bt_sock_recvmsg() returns
with 0 without updating msg_namelen leading to net/socket.c leaking the
local, uninitialized sockaddr_storage variable to userland -- 128 bytes
of kernel stack memory.
Fix this by moving the m... | 1 | int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
int noblock = flags & MSG_DONTWAIT;
struct sock *sk = sock->sk;
struct sk_buff *skb;
size_t copied;
int err;
BT_DBG("sock %p sk %p len %zu", sock, sk, len);
if (flags & (MSG_OOB))
return -EOPNOTSUP... | 4,403,052,444,065,820,700,000,000,000,000,000,000 | af_bluetooth.c | 92,794,431,760,555,800,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3224 | The bt_sock_recvmsg function in net/bluetooth/af_bluetooth.c in the Linux kernel before 3.9-rc7 does not properly initialize a certain length variable, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3224 |
1,009 | linux | ef3313e84acbf349caecae942ab3ab731471f1a1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ef3313e84acbf349caecae942ab3ab731471f1a1 | ax25: fix info leak via msg_name in ax25_recvmsg()
When msg_namelen is non-zero the sockaddr info gets filled out, as
requested, but the code fails to initialize the padding bytes of struct
sockaddr_ax25 inserted by the compiler for alignment. Additionally the
msg_namelen value is updated to sizeof(struct full_sockadd... | 1 | static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t size, int flags)
{
struct sock *sk = sock->sk;
struct sk_buff *skb;
int copied;
int err = 0;
lock_sock(sk);
/*
* This works for seqpacket too. The receiver has ordered the
* queue for us! We do one quick check first... | 198,649,123,377,212,600,000,000,000,000,000,000,000 | af_ax25.c | 123,370,855,927,941,530,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3223 | The ax25_recvmsg function in net/ax25/af_ax25.c in the Linux kernel before 3.9-rc7 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3223 |
1,010 | linux | 9b3e617f3df53822345a8573b6d358f6b9e5ed87 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9b3e617f3df53822345a8573b6d358f6b9e5ed87 | atm: update msg_namelen in vcc_recvmsg()
The current code does not fill the msg_name member in case it is set.
It also does not set the msg_namelen member to 0 and therefore makes
net/socket.c leak the local, uninitialized sockaddr_storage variable
to userland -- 128 bytes of kernel stack memory.
Fix that by simply s... | 1 | int vcc_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
size_t size, int flags)
{
struct sock *sk = sock->sk;
struct atm_vcc *vcc;
struct sk_buff *skb;
int copied, error = -EINVAL;
if (sock->state != SS_CONNECTED)
return -ENOTCONN;
/* only handle MSG_DONTWAIT and MSG_PEEK */
if (... | 84,284,193,461,125,215,000,000,000,000,000,000,000 | common.c | 105,103,316,668,524,350,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3222 | The vcc_recvmsg function in net/atm/common.c in the Linux kernel before 3.9-rc7 does not initialize a certain length variable, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-3222 |
1,011 | linux | 72a763d805a48ac8c0bf48fdb510e84c12de51fe | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/72a763d805a48ac8c0bf48fdb510e84c12de51fe | crypto: algif - suppress sending source address information in recvmsg
The current code does not set the msg_namelen member to 0 and therefore
makes net/socket.c leak the local sockaddr_storage variable to userland
-- 128 bytes of kernel stack memory. Fix that.
Cc: <stable@vger.kernel.org> # 2.6.38
Signed-off-by: Mat... | 1 | static int skcipher_recvmsg(struct kiocb *unused, struct socket *sock,
struct msghdr *msg, size_t ignored, int flags)
{
struct sock *sk = sock->sk;
struct alg_sock *ask = alg_sk(sk);
struct skcipher_ctx *ctx = ask->private;
unsigned bs = crypto_ablkcipher_blocksize(crypto_ablkcipher_reqtfm(
&ctx->req));
s... | 54,729,755,431,548,460,000,000,000,000,000,000,000 | algif_skcipher.c | 322,536,590,163,032,800,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-3076 | The crypto API in the Linux kernel through 3.9-rc8 does not initialize certain length variables, which allows local users to obtain sensitive information from kernel stack memory via a crafted recvmsg or recvfrom system call, related to the hash_recvmsg function in crypto/algif_hash.c and the skcipher_recvmsg function ... | https://nvd.nist.gov/vuln/detail/CVE-2013-3076 |
1,012 | linux | 12ae030d54ef250706da5642fc7697cc60ad0df7 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/12ae030d54ef250706da5642fc7697cc60ad0df7 | perf/ftrace: Fix paranoid level for enabling function tracer
The current default perf paranoid level is "1" which has
"perf_paranoid_kernel()" return false, and giving any operations that
use it, access to normal users. Unfortunately, this includes function
tracing and normal users should not be allowed to enable func... | 1 | static int perf_trace_event_perm(struct ftrace_event_call *tp_event,
struct perf_event *p_event)
{
/* The ftrace function trace is allowed only for root. */
if (ftrace_event_is_function(tp_event) &&
perf_paranoid_kernel() && !capable(CAP_SYS_ADMIN))
return -EPERM;
/* No tracing, just counting, so ... | 282,170,608,950,902,630,000,000,000,000,000,000,000 | trace_event_perf.c | 103,737,043,602,954,010,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2013-2930 | The perf_trace_event_perm function in kernel/trace/trace_event_perf.c in the Linux kernel before 3.12.2 does not properly restrict access to the perf subsystem, which allows local users to enable function tracing via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-2930 |
1,013 | linux | d049f74f2dbe71354d43d393ac3a188947811348 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d049f74f2dbe71354d43d393ac3a188947811348 | exec/ptrace: fix get_dumpable() incorrect tests
The get_dumpable() return value is not boolean. Most users of the
function actually want to be testing for non-SUID_DUMP_USER(1) rather than
SUID_DUMP_DISABLE(0). The SUID_DUMP_ROOT(2) is also considered a
protected state. Almost all places did this correctly, excepti... | 1 | static int __ptrace_may_access(struct task_struct *task, unsigned int mode)
{
const struct cred *cred = current_cred(), *tcred;
/* May we inspect the given task?
* This check is used both for attaching with ptrace
* and for allowing access to sensitive information in /proc.
*
* ptrace_attach denies several c... | 145,541,299,218,287,470,000,000,000,000,000,000,000 | ptrace.c | 292,077,372,195,169,620,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2013-2929 | The Linux kernel before 3.12.2 does not properly use the get_dumpable function, which allows local users to bypass intended ptrace restrictions or obtain sensitive information from IA64 scratch registers via a crafted application, related to kernel/ptrace.c and arch/ia64/include/asm/processor.h. | https://nvd.nist.gov/vuln/detail/CVE-2013-2929 |
1,014 | linux | cea4dcfdad926a27a18e188720efe0f2c9403456 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cea4dcfdad926a27a18e188720efe0f2c9403456 | iscsi-target: fix heap buffer overflow on error
If a key was larger than 64 bytes, as checked by iscsi_check_key(), the
error response packet, generated by iscsi_add_notunderstood_response(),
would still attempt to copy the entire key into the packet, overflowing
the structure on the heap.
Remote preauthentication ke... | 1 | static int iscsi_add_notunderstood_response(
char *key,
char *value,
struct iscsi_param_list *param_list)
{
struct iscsi_extra_response *extra_response;
if (strlen(value) > VALUE_MAXLEN) {
pr_err("Value for notunderstood key \"%s\" exceeds %d,"
" protocol error.\n", key, VALUE_MAXLEN);
return -1;
}
extr... | 100,762,060,795,839,660,000,000,000,000,000,000,000 | iscsi_target_parameters.c | 259,649,241,332,208,500,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-2850 | Heap-based buffer overflow in the iscsi_add_notunderstood_response function in drivers/target/iscsi/iscsi_target_parameters.c in the iSCSI target subsystem in the Linux kernel through 3.9.4 allows remote attackers to cause a denial of service (memory corruption and OOPS) or possibly execute arbitrary code via a long ke... | https://nvd.nist.gov/vuln/detail/CVE-2013-2850 |
1,020 | linux | 84d73cd3fb142bf1298a8c13fd4ca50fd2432372 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/84d73cd3fb142bf1298a8c13fd4ca50fd2432372 | rtnl: fix info leak on RTM_GETLINK request for VF devices
Initialize the mac address buffer with 0 as the driver specific function
will probably not fill the whole buffer. In fact, all in-kernel drivers
fill only ETH_ALEN of the MAX_ADDR_LEN bytes, i.e. 6 of the 32 possible
bytes. Therefore we currently leak 26 bytes ... | 1 | static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
int type, u32 pid, u32 seq, u32 change,
unsigned int flags, u32 ext_filter_mask)
{
struct ifinfomsg *ifm;
struct nlmsghdr *nlh;
struct rtnl_link_stats64 temp;
const struct rtnl_link_stats64 *stats;
struct nlattr *attr, *af_spec;... | 305,591,951,297,307,640,000,000,000,000,000,000,000 | rtnetlink.c | 128,134,176,972,809,380,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2635 | The rtnl_fill_ifinfo function in net/core/rtnetlink.c in the Linux kernel before 3.8.4 does not initialize a certain structure member, which allows local users to obtain sensitive information from kernel stack memory via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-2635 |
1,022 | linux | fc9bbca8f650e5f738af8806317c0a041a48ae4a | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/fc9bbca8f650e5f738af8806317c0a041a48ae4a | vm: convert fb_mmap to vm_iomap_memory() helper
This is my example conversion of a few existing mmap users. The
fb_mmap() case is a good example because it is a bit more complicated
than some: fb_mmap() mmaps one of two different memory areas depending
on the page offset of the mmap (but happily there is never any mi... | 1 | fb_mmap(struct file *file, struct vm_area_struct * vma)
{
struct fb_info *info = file_fb_info(file);
struct fb_ops *fb;
unsigned long off;
unsigned long start;
u32 len;
if (!info)
return -ENODEV;
if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
return -EINVAL;
off = vma->vm_pgoff << PAGE_SHIFT;
fb = inf... | 61,607,845,425,516,360,000,000,000,000,000,000,000 | fbmem.c | 127,339,374,413,477,720,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-2596 | Integer overflow in the fb_mmap function in drivers/video/fbmem.c in the Linux kernel before 3.8.9, as used in a certain Motorola build of Android 4.1.2 and other products, allows local users to create a read-write memory mapping for the entirety of kernel memory, and consequently gain privileges, via crafted /dev/grap... | https://nvd.nist.gov/vuln/detail/CVE-2013-2596 |
1,030 | linux | 9a5467bf7b6e9e02ec9c3da4e23747c05faeaac6 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9a5467bf7b6e9e02ec9c3da4e23747c05faeaac6 | crypto: user - fix info leaks in report API
Three errors resulting in kernel memory disclosure:
1/ The structures used for the netlink based crypto algorithm report API
are located on the stack. As snprintf() does not fill the remainder of
the buffer with null bytes, those stack bytes will be disclosed to users
of th... | 1 | static int crypto_report_one(struct crypto_alg *alg,
struct crypto_user_alg *ualg, struct sk_buff *skb)
{
memcpy(&ualg->cru_name, &alg->cra_name, sizeof(ualg->cru_name));
memcpy(&ualg->cru_driver_name, &alg->cra_driver_name,
sizeof(ualg->cru_driver_name));
memcpy(&ualg->cru_module_name, module_nam... | 20,209,587,001,997,520,000,000,000,000,000,000,000 | crypto_user.c | 164,121,594,634,091,500,000,000,000,000,000,000,000 | [
"CWE-310"
] | CVE-2013-2546 | The report API in the crypto user configuration API in the Linux kernel through 3.8.2 uses an incorrect C library function for copying strings, which allows local users to obtain sensitive information from kernel stack memory by leveraging the CAP_NET_ADMIN capability. | https://nvd.nist.gov/vuln/detail/CVE-2013-2546 |
1,034 | linux | 85dfb745ee40232876663ae206cba35f24ab2a40 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/85dfb745ee40232876663ae206cba35f24ab2a40 | af_key: initialize satype in key_notify_policy_flush()
This field was left uninitialized. Some user daemons perform check against this
field.
Signed-off-by: Nicolas Dichtel <nicolas.dichtel@6wind.com>
Signed-off-by: Steffen Klassert <steffen.klassert@secunet.com> | 1 | static int key_notify_policy_flush(const struct km_event *c)
{
struct sk_buff *skb_out;
struct sadb_msg *hdr;
skb_out = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
if (!skb_out)
return -ENOBUFS;
hdr = (struct sadb_msg *) skb_put(skb_out, sizeof(struct sadb_msg));
hdr->sadb_msg_type = SADB_X_SPDFLUSH;
... | 25,111,496,152,480,300,000,000,000,000,000,000,000 | af_key.c | 178,017,057,552,300,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-2237 | The key_notify_policy_flush function in net/key/af_key.c in the Linux kernel before 3.9 does not initialize a certain structure member, which allows local users to obtain sensitive information from kernel heap memory by reading a broadcast message from the notify_policy interface of an IPSec key_socket. | https://nvd.nist.gov/vuln/detail/CVE-2013-2237 |
1,035 | linux | a5cc68f3d63306d0d288f31edfc2ae6ef8ecd887 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a5cc68f3d63306d0d288f31edfc2ae6ef8ecd887 | af_key: fix info leaks in notify messages
key_notify_sa_flush() and key_notify_policy_flush() miss to initialize
the sadb_msg_reserved member of the broadcasted message and thereby
leak 2 bytes of heap memory to listeners. Fix that.
Signed-off-by: Mathias Krause <minipli@googlemail.com>
Cc: Steffen Klassert <steffen.... | 1 | static int key_notify_policy_flush(const struct km_event *c)
{
struct sk_buff *skb_out;
struct sadb_msg *hdr;
skb_out = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
if (!skb_out)
return -ENOBUFS;
hdr = (struct sadb_msg *) skb_put(skb_out, sizeof(struct sadb_msg));
hdr->sadb_msg_type = SADB_X_SPDFLUSH;
... | 89,775,021,181,796,410,000,000,000,000,000,000,000 | af_key.c | 327,866,515,311,335,880,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-2234 | The (1) key_notify_sa_flush and (2) key_notify_policy_flush functions in net/key/af_key.c in the Linux kernel before 3.10 do not initialize certain structure members, which allows local users to obtain sensitive information from kernel heap memory by reading a broadcast message from the notify interface of an IPSec key... | https://nvd.nist.gov/vuln/detail/CVE-2013-2234 |
1,036 | linux | a5cc68f3d63306d0d288f31edfc2ae6ef8ecd887 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a5cc68f3d63306d0d288f31edfc2ae6ef8ecd887 | af_key: fix info leaks in notify messages
key_notify_sa_flush() and key_notify_policy_flush() miss to initialize
the sadb_msg_reserved member of the broadcasted message and thereby
leak 2 bytes of heap memory to listeners. Fix that.
Signed-off-by: Mathias Krause <minipli@googlemail.com>
Cc: Steffen Klassert <steffen.... | 1 | static int key_notify_sa_flush(const struct km_event *c)
{
struct sk_buff *skb;
struct sadb_msg *hdr;
skb = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
if (!skb)
return -ENOBUFS;
hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
hdr->sadb_msg_satype = pfkey_proto2satype(c->data.proto);
... | 39,936,032,300,218,860,000,000,000,000,000,000,000 | af_key.c | 327,866,515,311,335,880,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-2234 | The (1) key_notify_sa_flush and (2) key_notify_policy_flush functions in net/key/af_key.c in the Linux kernel before 3.10 do not initialize certain structure members, which allows local users to obtain sensitive information from kernel heap memory by reading a broadcast message from the notify interface of an IPSec key... | https://nvd.nist.gov/vuln/detail/CVE-2013-2234 |
1,037 | linux | a963a37d384d71ad43b3e9e79d68d42fbe0901f3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a963a37d384d71ad43b3e9e79d68d42fbe0901f3 | ipv6: ip6_sk_dst_check() must not assume ipv6 dst
It's possible to use AF_INET6 sockets and to connect to an IPv4
destination. After this, socket dst cache is a pointer to a rtable,
not rt6_info.
ip6_sk_dst_check() should check the socket dst cache is IPv6, or else
various corruptions/crashes can happen.
Dave Jones ... | 1 | static struct dst_entry *ip6_sk_dst_check(struct sock *sk,
struct dst_entry *dst,
const struct flowi6 *fl6)
{
struct ipv6_pinfo *np = inet6_sk(sk);
struct rt6_info *rt = (struct rt6_info *)dst;
if (!dst)
goto out;
/* Yes, checking route validity in not connected
* case is not very simpl... | 297,614,718,685,075,820,000,000,000,000,000,000,000 | ip6_output.c | 19,620,935,478,555,194,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-2232 | The ip6_sk_dst_check function in net/ipv6/ip6_output.c in the Linux kernel before 3.10 allows local users to cause a denial of service (system crash) by using an AF_INET6 socket for a connection to an IPv4 interface. | https://nvd.nist.gov/vuln/detail/CVE-2013-2232 |
1,039 | linux | f2815633504b442ca0b0605c16bf3d88a3a0fcea | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f2815633504b442ca0b0605c16bf3d88a3a0fcea | sctp: Use correct sideffect command in duplicate cookie handling
When SCTP is done processing a duplicate cookie chunk, it tries
to delete a newly created association. For that, it has to set
the right association for the side-effect processing to work.
However, when it uses the SCTP_CMD_NEW_ASOC command, that perfor... | 1 | sctp_disposition_t sctp_sf_do_5_2_4_dupcook(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
sctp_disposition_t retval;
struct sctp_chunk *chunk = arg;
struct sctp_association *new_asoc;
i... | 32,908,841,536,456,587,000,000,000,000,000,000,000 | sm_statefuns.c | 263,504,569,047,803,900,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2013-2206 | The sctp_sf_do_5_2_4_dupcook function in net/sctp/sm_statefuns.c in the SCTP implementation in the Linux kernel before 3.8.5 does not properly handle associations during the processing of a duplicate COOKIE ECHO chunk, which allows remote attackers to cause a denial of service (NULL pointer dereference and system crash... | https://nvd.nist.gov/vuln/detail/CVE-2013-2206 |
1,040 | curl | 192c4f788d48f82c03e9cef40013f34370e90737 | https://github.com/curl/curl | https://github.com/bagder/curl/commit/192c4f788d48f82c03e9cef40013f34370e90737 | Curl_urldecode: no peeking beyond end of input buffer
Security problem: CVE-2013-2174
If a program would give a string like "%FF" to curl_easy_unescape() but
ask for it to decode only the first byte, it would still parse and
decode the full hex sequence. The function then not only read beyond the
allowed buffer but i... | 1 | CURLcode Curl_urldecode(struct SessionHandle *data,
const char *string, size_t length,
char **ostring, size_t *olen,
bool reject_ctrl)
{
size_t alloc = (length?length:strlen(string))+1;
char *ns = malloc(alloc);
unsigned char in;
size_t str... | 85,709,973,777,579,240,000,000,000,000,000,000,000 | escape.c | 170,290,579,417,472,230,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-2174 | Heap-based buffer overflow in the curl_easy_unescape function in lib/escape.c in cURL and libcurl 7.7 through 7.30.0 allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via a crafted string ending in a "%" (percent) character. | https://nvd.nist.gov/vuln/detail/CVE-2013-2174 |
1,041 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 1 | static int do_tkill(pid_t tgid, pid_t pid, int sig)
{
struct siginfo info;
info.si_signo = sig;
info.si_errno = 0;
info.si_code = SI_TKILL;
info.si_pid = task_tgid_vnr(current);
info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
return do_send_specific(tgid, pid, sig, &info);
}
| 92,468,020,625,669,770,000,000,000,000,000,000,000 | signal.c | 50,160,511,605,867,340,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
1,042 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 1 | static int dispatch_discard_io(struct xen_blkif *blkif,
struct blkif_request *req)
{
int err = 0;
int status = BLKIF_RSP_OKAY;
struct block_device *bdev = blkif->vbd.bdev;
unsigned long secure;
blkif->st_ds_req++;
xen_blkif_get(blkif);
secure = (blkif->vbd.discard_secure &&
(req->u.discard.flag &... | 326,182,960,843,920,000,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
1,043 | linux | baff42ab1494528907bf4d5870359e31711746ae | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/baff42ab1494528907bf4d5870359e31711746ae | net: Fix oops from tcp_collapse() when using splice()
tcp_read_sock() can have a eat skbs without immediately advancing copied_seq.
This can cause a panic in tcp_collapse() if it is called as a result
of the recv_actor dropping the socket lock.
A userspace program that splices data from a socket to either another
soc... | 1 | int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
sk_read_actor_t recv_actor)
{
struct sk_buff *skb;
struct tcp_sock *tp = tcp_sk(sk);
u32 seq = tp->copied_seq;
u32 offset;
int copied = 0;
if (sk->sk_state == TCP_LISTEN)
return -ENOTCONN;
while ((skb = tcp_recv_skb(sk, seq, &offset)) != NULL) {
... | 199,403,613,559,602,620,000,000,000,000,000,000,000 | tcp.c | 12,402,514,951,805,328,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-2128 | The tcp_read_sock function in net/ipv4/tcp.c in the Linux kernel before 2.6.34 does not properly manage skb consumption, which allows local users to cause a denial of service (system crash) via a crafted splice system call for a TCP socket. | https://nvd.nist.gov/vuln/detail/CVE-2013-2128 |
1,044 | openvpn | 11d21349a4e7e38a025849479b36ace7c2eec2ee | https://github.com/OpenVPN/openvpn | https://github.com/OpenVPN/openvpn/commit/11d21349a4e7e38a025849479b36ace7c2eec2ee | Use constant time memcmp when comparing HMACs in openvpn_decrypt.
Signed-off-by: Steffan Karger <steffan.karger@fox-it.com>
Acked-by: Gert Doering <gert@greenie.muc.de>
Signed-off-by: Gert Doering <gert@greenie.muc.de> | 1 | openvpn_decrypt (struct buffer *buf, struct buffer work,
const struct crypto_options *opt,
const struct frame* frame)
{
static const char error_prefix[] = "Authenticate/Decrypt packet error";
struct gc_arena gc;
gc_init (&gc);
if (buf->len > 0 && opt->key_ctx_bi)
{
struct key_ctx *ctx = &opt->k... | 289,938,016,318,508,460,000,000,000,000,000,000,000 | crypto.c | 243,766,420,768,321,600,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-2061 | The openvpn_decrypt function in crypto.c in OpenVPN 2.3.0 and earlier, when running in UDP mode, allows remote attackers to obtain sensitive information via a timing attack involving an HMAC comparison function that does not run in constant time and a padding oracle attack on the CBC mode cipher. | https://nvd.nist.gov/vuln/detail/CVE-2013-2061 |
1,045 | linux | 929473ea05db455ad88cdc081f2adc556b8dc48f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/929473ea05db455ad88cdc081f2adc556b8dc48f | usb: chipidea: Allow disabling streaming not only in udc mode
When running a scp transfer using a USB/Ethernet adapter the following crash
happens:
$ scp test.tar.gz fabio@192.168.1.100:/home/fabio
fabio@192.168.1.100's password:
test.tar.gz 0% 0 0.0KB/s --:-- ETA
-------... | 1 | static int host_start(struct ci13xxx *ci)
{
struct usb_hcd *hcd;
struct ehci_hcd *ehci;
int ret;
if (usb_disabled())
return -ENODEV;
hcd = usb_create_hcd(&ci_ehci_hc_driver, ci->dev, dev_name(ci->dev));
if (!hcd)
return -ENOMEM;
dev_set_drvdata(ci->dev, ci);
hcd->rsrc_start = ci->hw_bank.phys;
hcd->rsrc... | 178,357,202,326,078,400,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2013-2058 | The host_start function in drivers/usb/chipidea/host.c in the Linux kernel before 3.7.4 does not properly support a certain non-streaming option, which allows local users to cause a denial of service (system crash) by sending a large amount of network traffic through a USB/Ethernet adapter. | https://nvd.nist.gov/vuln/detail/CVE-2013-2058 |
1,047 | linux | 0e9a9a1ad619e7e987815d20262d36a2f95717ca | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/0e9a9a1ad619e7e987815d20262d36a2f95717ca | ext4: avoid hang when mounting non-journal filesystems with orphan list
When trying to mount a file system which does not contain a journal,
but which does have a orphan list containing an inode which needs to
be truncated, the mount call with hang forever in
ext4_orphan_cleanup() because ext4_orphan_del() will return... | 1 | int ext4_orphan_del(handle_t *handle, struct inode *inode)
{
struct list_head *prev;
struct ext4_inode_info *ei = EXT4_I(inode);
struct ext4_sb_info *sbi;
__u32 ino_next;
struct ext4_iloc iloc;
int err = 0;
if (!EXT4_SB(inode->i_sb)->s_journal)
return 0;
mutex_lock(&EXT4_SB(inode->i_sb)->s_orphan_lock... | 244,588,647,148,744,640,000,000,000,000,000,000,000 | namei.c | 70,402,644,734,207,050,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2015 | The ext4_orphan_del function in fs/ext4/namei.c in the Linux kernel before 3.7.3 does not properly handle orphan-list entries for non-journal filesystems, which allows physically proximate attackers to cause a denial of service (system hang) via a crafted filesystem on removable media, as demonstrated by the e2fsprogs ... | https://nvd.nist.gov/vuln/detail/CVE-2013-2015 |
1,050 | linux | 92f28d973cce45ef5823209aab3138eb45d8b349 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/92f28d973cce45ef5823209aab3138eb45d8b349 | scm: Require CAP_SYS_ADMIN over the current pidns to spoof pids.
Don't allow spoofing pids over unix domain sockets in the corner
cases where a user has created a user namespace but has not yet
created a pid namespace.
Cc: stable@vger.kernel.org
Reported-by: Andy Lutomirski <luto@amacapital.net>
Signed-off-by: "Eric ... | 1 | static __inline__ int scm_check_creds(struct ucred *creds)
{
const struct cred *cred = current_cred();
kuid_t uid = make_kuid(cred->user_ns, creds->uid);
kgid_t gid = make_kgid(cred->user_ns, creds->gid);
if (!uid_valid(uid) || !gid_valid(gid))
return -EINVAL;
if ((creds->pid == task_tgid_vnr(current) || ns... | 265,477,273,618,585,700,000,000,000,000,000,000,000 | None | null | [
"CWE-264"
] | CVE-2013-1958 | The scm_check_creds function in net/core/scm.c in the Linux kernel before 3.8.6 does not properly enforce capability requirements for controlling the PID value associated with a UNIX domain socket, which allows local users to bypass intended access restrictions by leveraging the time interval during which a user namesp... | https://nvd.nist.gov/vuln/detail/CVE-2013-1958 |
1,051 | linux | 132c94e31b8bca8ea921f9f96a57d684fa4ae0a9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/132c94e31b8bca8ea921f9f96a57d684fa4ae0a9 | vfs: Carefully propogate mounts across user namespaces
As a matter of policy MNT_READONLY should not be changable if the
original mounter had more privileges than creator of the mount
namespace.
Add the flag CL_UNPRIVILEGED to note when we are copying a mount from
a mount namespace that requires more privileges to a ... | 1 | static struct mount *clone_mnt(struct mount *old, struct dentry *root,
int flag)
{
struct super_block *sb = old->mnt.mnt_sb;
struct mount *mnt;
int err;
mnt = alloc_vfsmnt(old->mnt_devname);
if (!mnt)
return ERR_PTR(-ENOMEM);
if (flag & (CL_SLAVE | CL_PRIVATE | CL_SHARED_TO_SLAVE))
mnt->mnt_group_id = ... | 333,226,396,239,700,840,000,000,000,000,000,000,000 | namespace.c | 303,832,579,392,698,380,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2013-1957 | The clone_mnt function in fs/namespace.c in the Linux kernel before 3.8.6 does not properly restrict changes to the MNT_READONLY flag, which allows local users to bypass an intended read-only property of a filesystem by leveraging a separate mount namespace. | https://nvd.nist.gov/vuln/detail/CVE-2013-1957 |
1,054 | linux | 3151527ee007b73a0ebd296010f1c0454a919c7d | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/3151527ee007b73a0ebd296010f1c0454a919c7d | userns: Don't allow creation if the user is chrooted
Guarantee that the policy of which files may be access that is
established by setting the root directory will not be violated
by user namespaces by verifying that the root directory points
to the root of the mount namespace at the time of user namespace
creation.
... | 1 | int create_user_ns(struct cred *new)
{
struct user_namespace *ns, *parent_ns = new->user_ns;
kuid_t owner = new->euid;
kgid_t group = new->egid;
int ret;
/* The creator needs a mapping in the parent user namespace
* or else we won't be able to reasonably tell userspace who
* created a user_namespace.
... | 62,769,202,323,779,360,000,000,000,000,000,000,000 | user_namespace.c | 60,695,328,771,795,950,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2013-1956 | The create_user_ns function in kernel/user_namespace.c in the Linux kernel before 3.8.6 does not check whether a chroot directory exists that differs from the namespace root directory, which allows local users to bypass intended filesystem restrictions via a crafted clone system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-1956 |
1,055 | curl | 2eb8dcf26cb37f09cffe26909a646e702dbcab66 | https://github.com/curl/curl | https://github.com/bagder/curl/commit/2eb8dcf26cb37f09cffe26909a646e702dbcab66 | cookie: fix tailmatching to prevent cross-domain leakage
Cookies set for 'example.com' could accidentaly also be sent by libcurl
to the 'bexample.com' (ie with a prefix to the first domain name).
This is a security vulnerabilty, CVE-2013-1944.
Bug: http://curl.haxx.se/docs/adv_20130412.html | 1 | static bool tailmatch(const char *little, const char *bigone)
{
size_t littlelen = strlen(little);
size_t biglen = strlen(bigone);
if(littlelen > biglen)
return FALSE;
return Curl_raw_equal(little, bigone+biglen-littlelen) ? TRUE : FALSE;
}
| 325,637,020,867,287,500,000,000,000,000,000,000,000 | cookie.c | 232,761,289,799,062,120,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-1944 | The tailMatch function in cookie.c in cURL and libcurl before 7.30.0 does not properly match the path domain when sending cookies, which allows remote attackers to steal cookies via a matching suffix in the domain of a URL. | https://nvd.nist.gov/vuln/detail/CVE-2013-1944 |
1,056 | linux | 715230a44310a8cf66fbfb5a46f9a62a9b2de424 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/715230a44310a8cf66fbfb5a46f9a62a9b2de424 | tg3: fix length overflow in VPD firmware parsing
Commit 184b89044fb6e2a74611dafa69b1dce0d98612c6 ("tg3: Use VPD fw version
when present") introduced VPD parsing that contained a potential length
overflow.
Limit the hardware's reported firmware string length (max 255 bytes) to
stay inside the driver's firmware string ... | 1 | static void tg3_read_vpd(struct tg3 *tp)
{
u8 *vpd_data;
unsigned int block_end, rosize, len;
u32 vpdlen;
int j, i = 0;
vpd_data = (u8 *)tg3_vpd_readblock(tp, &vpdlen);
if (!vpd_data)
goto out_no_vpd;
i = pci_vpd_find_tag(vpd_data, 0, vpdlen, PCI_VPD_LRDT_RO_DATA);
if (i < 0)
goto out_not_found;
rosize ... | 112,924,613,750,397,920,000,000,000,000,000,000,000 | tg3.c | 243,393,128,707,233,270,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-1929 | Heap-based buffer overflow in the tg3_read_vpd function in drivers/net/ethernet/broadcom/tg3.c in the Linux kernel before 3.8.6 allows physically proximate attackers to cause a denial of service (system crash) or possibly execute arbitrary code via crafted firmware that specifies a long string in the Vital Product Data... | https://nvd.nist.gov/vuln/detail/CVE-2013-1929 |
1,057 | linux | 12176503366885edd542389eed3aaf94be163fdb | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/12176503366885edd542389eed3aaf94be163fdb | fs/compat_ioctl.c: VIDEO_SET_SPU_PALETTE missing error check
The compat ioctl for VIDEO_SET_SPU_PALETTE was missing an error check
while converting ioctl arguments. This could lead to leaking kernel
stack contents into userspace.
Patch extracted from existing fix in grsecurity.
Signed-off-by: Kees Cook <keescook@ch... | 1 | static int do_video_set_spu_palette(unsigned int fd, unsigned int cmd,
struct compat_video_spu_palette __user *up)
{
struct video_spu_palette __user *up_native;
compat_uptr_t palp;
int length, err;
err = get_user(palp, &up->palette);
err |= get_user(length, &up->length);
up_native = compat_alloc_user_sp... | 316,505,203,133,565,640,000,000,000,000,000,000,000 | compat_ioctl.c | 304,637,621,645,556,700,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-1928 | The do_video_set_spu_palette function in fs/compat_ioctl.c in the Linux kernel before 3.6.5 on unspecified architectures lacks a certain error check, which might allow local users to obtain sensitive information from kernel stack memory via a crafted VIDEO_SET_SPU_PALETTE ioctl call on a /dev/dvb device. | https://nvd.nist.gov/vuln/detail/CVE-2013-1928 |
1,058 | linux | c0f5ecee4e741667b2493c742b60b6218d40b3aa | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c0f5ecee4e741667b2493c742b60b6218d40b3aa | USB: cdc-wdm: fix buffer overflow
The buffer for responses must not overflow.
If this would happen, set a flag, drop the data and return
an error after user space has read all remaining data.
Signed-off-by: Oliver Neukum <oliver@neukum.org>
CC: stable@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundati... | 1 | static void wdm_in_callback(struct urb *urb)
{
struct wdm_device *desc = urb->context;
int status = urb->status;
spin_lock(&desc->iuspin);
clear_bit(WDM_RESPONDING, &desc->flags);
if (status) {
switch (status) {
case -ENOENT:
dev_dbg(&desc->intf->dev,
"nonzero urb status received: -ENOENT");
... | 263,555,284,317,390,400,000,000,000,000,000,000,000 | cdc-wdm.c | 233,028,530,119,557,450,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-1860 | Heap-based buffer overflow in the wdm_in_callback function in drivers/usb/class/cdc-wdm.c in the Linux kernel before 3.8.4 allows physically proximate attackers to cause a denial of service (system crash) or possibly execute arbitrary code via a crafted cdc-wdm USB device. | https://nvd.nist.gov/vuln/detail/CVE-2013-1860 |
1,065 | linux | 726bc6b092da4c093eb74d13c07184b18c1af0f1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/726bc6b092da4c093eb74d13c07184b18c1af0f1 | net/sctp: Validate parameter size for SCTP_GET_ASSOC_STATS
Building sctp may fail with:
In function ‘copy_from_user’,
inlined from ‘sctp_getsockopt_assoc_stats’ at
net/sctp/socket.c:5656:20:
arch/x86/include/asm/uaccess_32.h:211:26: error: call to
‘copy_from_user_overflow’ declared with attribute error: c... | 1 | static int sctp_getsockopt_assoc_stats(struct sock *sk, int len,
char __user *optval,
int __user *optlen)
{
struct sctp_assoc_stats sas;
struct sctp_association *asoc = NULL;
/* User must provide at least the assoc id */
if (len < sizeof(sctp_assoc_t))
return -EINVAL;
if (copy_from_us... | 170,963,965,115,843,570,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-1828 | The sctp_getsockopt_assoc_stats function in net/sctp/socket.c in the Linux kernel before 3.8.4 does not validate a size value before proceeding to a copy_from_user operation, which allows local users to gain privileges via a crafted application that contains an SCTP_GET_ASSOC_STATS getsockopt system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-1828 |
1,066 | linux | 864745d291b5ba80ea0bd0edcbe67273de368836 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/864745d291b5ba80ea0bd0edcbe67273de368836 | xfrm_user: return error pointer instead of NULL
When dump_one_state() returns an error, e.g. because of a too small
buffer to dump the whole xfrm state, xfrm_state_netlink() returns NULL
instead of an error pointer. But its callers expect an error pointer
and therefore continue to operate on a NULL skbuff.
This could... | 1 | static struct sk_buff *xfrm_state_netlink(struct sk_buff *in_skb,
struct xfrm_state *x, u32 seq)
{
struct xfrm_dump_info info;
struct sk_buff *skb;
skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
if (!skb)
return ERR_PTR(-ENOMEM);
info.in_skb = in_skb;
info.out_skb = skb;
info.nlmsg_seq = seq;... | 324,377,055,092,562,550,000,000,000,000,000,000,000 | xfrm_user.c | 252,384,883,337,736,730,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2013-1826 | The xfrm_state_netlink function in net/xfrm/xfrm_user.c in the Linux kernel before 3.5.7 does not properly handle error conditions in dump_one_state function calls, which allows local users to gain privileges or cause a denial of service (NULL pointer dereference and system crash) by leveraging the CAP_NET_ADMIN capabi... | https://nvd.nist.gov/vuln/detail/CVE-2013-1826 |
1,067 | linux | eb178619f930fa2ba2348de332a1ff1c66a31424 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/eb178619f930fa2ba2348de332a1ff1c66a31424 | xfs: fix _xfs_buf_find oops on blocks beyond the filesystem end
When _xfs_buf_find is passed an out of range address, it will fail
to find a relevant struct xfs_perag and oops with a null
dereference. This can happen when trying to walk a filesystem with a
metadata inode that has a partially corrupted extent map (i.e.... | 1 | _xfs_buf_find(
struct xfs_buftarg *btp,
struct xfs_buf_map *map,
int nmaps,
xfs_buf_flags_t flags,
xfs_buf_t *new_bp)
{
size_t numbytes;
struct xfs_perag *pag;
struct rb_node **rbp;
struct rb_node *parent;
xfs_buf_t *bp;
xfs_daddr_t blkno = map[0].bm_bn;
int numblks = 0;
int i;
for (i... | 91,424,937,264,814,560,000,000,000,000,000,000,000 | xfs_buf.c | 137,283,063,241,069,840,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-1819 | The _xfs_buf_find function in fs/xfs/xfs_buf.c in the Linux kernel before 3.7.6 does not validate block numbers, which allows local users to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by leveraging the ability to mount an XFS filesystem containing a m... | https://nvd.nist.gov/vuln/detail/CVE-2013-1819 |
1,068 | linux | a2c118bfab8bc6b8bb213abfc35201e441693d55 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a2c118bfab8bc6b8bb213abfc35201e441693d55 | KVM: Fix bounds checking in ioapic indirect register reads (CVE-2013-1798)
If the guest specifies a IOAPIC_REG_SELECT with an invalid value and follows
that with a read of the IOAPIC_REG_WINDOW KVM does not properly validate
that request. ioapic_read_indirect contains an
ASSERT(redir_index < IOAPIC_NUM_PINS), but the... | 1 | static unsigned long ioapic_read_indirect(struct kvm_ioapic *ioapic,
unsigned long addr,
unsigned long length)
{
unsigned long result = 0;
switch (ioapic->ioregsel) {
case IOAPIC_REG_VERSION:
result = ((((IOAPIC_NUM_PINS - 1) & 0xff) << 16)
| (IOAPIC_VERSION_ID & 0xff));
break;
case IOAPIC_... | 68,178,098,106,123,340,000,000,000,000,000,000,000 | ioapic.c | 243,802,327,646,897,500,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2013-1798 | The ioapic_read_indirect function in virt/kvm/ioapic.c in the Linux kernel through 3.8.4 does not properly handle a certain combination of invalid IOAPIC_REG_SELECT and IOAPIC_REG_WINDOW operations, which allows guest OS users to obtain sensitive information from host OS memory or cause a denial of service (host OS OOP... | https://nvd.nist.gov/vuln/detail/CVE-2013-1798 |
1,071 | linux | 0b79459b482e85cb7426aa7da683a9f2c97aeae1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/0b79459b482e85cb7426aa7da683a9f2c97aeae1 | KVM: x86: Convert MSR_KVM_SYSTEM_TIME to use gfn_to_hva_cache functions (CVE-2013-1797)
There is a potential use after free issue with the handling of
MSR_KVM_SYSTEM_TIME. If the guest specifies a GPA in a movable or removable
memory such as frame buffers then KVM might continue to write to that
address even after it... | 1 | int kvm_set_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr_info)
{
bool pr = false;
u32 msr = msr_info->index;
u64 data = msr_info->data;
switch (msr) {
case MSR_AMD64_NB_CFG:
case MSR_IA32_UCODE_REV:
case MSR_IA32_UCODE_WRITE:
case MSR_VM_HSAVE_PA:
case MSR_AMD64_PATCH_LOADER:
case MSR_AMD64_BU_CFG2... | 148,215,412,997,884,670,000,000,000,000,000,000,000 | x86.c | 92,946,483,395,699,820,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-1797 | Use-after-free vulnerability in arch/x86/kvm/x86.c in the Linux kernel through 3.8.4 allows guest OS users to cause a denial of service (host OS memory corruption) or possibly have unspecified other impact via a crafted application that triggers use of a guest physical address (GPA) in (1) movable or (2) removable memo... | https://nvd.nist.gov/vuln/detail/CVE-2013-1797 |
1,073 | linux | c300aa64ddf57d9c5d9c898a64b36877345dd4a9 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c300aa64ddf57d9c5d9c898a64b36877345dd4a9 | KVM: x86: fix for buffer overflow in handling of MSR_KVM_SYSTEM_TIME (CVE-2013-1796)
If the guest sets the GPA of the time_page so that the request to update the
time straddles a page then KVM will write onto an incorrect page. The
write is done byusing kmap atomic to get a pointer to the page for the time
structure ... | 1 | int kvm_set_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr_info)
{
bool pr = false;
u32 msr = msr_info->index;
u64 data = msr_info->data;
switch (msr) {
case MSR_AMD64_NB_CFG:
case MSR_IA32_UCODE_REV:
case MSR_IA32_UCODE_WRITE:
case MSR_VM_HSAVE_PA:
case MSR_AMD64_PATCH_LOADER:
case MSR_AMD64_BU_CFG2... | 283,608,099,968,125,200,000,000,000,000,000,000,000 | x86.c | 147,713,205,250,400,240,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-1796 | The kvm_set_msr_common function in arch/x86/kvm/x86.c in the Linux kernel through 3.8.4 does not ensure a required time_page alignment during an MSR_KVM_SYSTEM_TIME operation, which allows guest OS users to cause a denial of service (buffer overflow and host OS memory corruption) or possibly have unspecified other impa... | https://nvd.nist.gov/vuln/detail/CVE-2013-1796 |
1,074 | linux | 0da9dfdd2cd9889201bc6f6f43580c99165cd087 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/0da9dfdd2cd9889201bc6f6f43580c99165cd087 | keys: fix race with concurrent install_user_keyrings()
This fixes CVE-2013-1792.
There is a race in install_user_keyrings() that can cause a NULL pointer
dereference when called concurrently for the same user if the uid and
uid-session keyrings are not yet created. It might be possible for an
unprivileged user to tr... | 1 | int install_user_keyrings(void)
{
struct user_struct *user;
const struct cred *cred;
struct key *uid_keyring, *session_keyring;
key_perm_t user_keyring_perm;
char buf[20];
int ret;
uid_t uid;
user_keyring_perm = (KEY_POS_ALL & ~KEY_POS_SETATTR) | KEY_USR_ALL;
cred = current_cred();
user = cred->user;
uid = ... | 150,644,529,088,063,000,000,000,000,000,000,000,000 | process_keys.c | 57,230,651,678,538,710,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2013-1792 | Race condition in the install_user_keyrings function in security/keys/process_keys.c in the Linux kernel before 3.8.3 allows local users to cause a denial of service (NULL pointer dereference and system crash) via crafted keyctl system calls that trigger keyring operations in simultaneous threads. | https://nvd.nist.gov/vuln/detail/CVE-2013-1792 |
1,075 | linux | 1ee0a224bc9aad1de496c795f96bc6ba2c394811 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1ee0a224bc9aad1de496c795f96bc6ba2c394811 | USB: io_ti: Fix NULL dereference in chase_port()
The tty is NULL when the port is hanging up.
chase_port() needs to check for this.
This patch is intended for stable series.
The behavior was observed and tested in Linux 3.2 and 3.7.1.
Johan Hovold submitted a more elaborate patch for the mainline kernel.
[ 56.277... | 1 | static void chase_port(struct edgeport_port *port, unsigned long timeout,
int flush)
{
int baud_rate;
struct tty_struct *tty = tty_port_tty_get(&port->port->port);
struct usb_serial *serial = port->port->serial;
wait_queue_t wait;
unsigned long flags;
if (!timeout)
timeout = (HZ * EDGE_CLOSING_WAI... | 45,678,875,671,616,350,000,000,000,000,000,000,000 | None | null | [
"CWE-264"
] | CVE-2013-1774 | The chase_port function in drivers/usb/serial/io_ti.c in the Linux kernel before 3.7.4 allows local users to cause a denial of service (NULL pointer dereference and system crash) via an attempted /dev/ttyUSB read or write operation on a disconnected Edgeport USB serial converter. | https://nvd.nist.gov/vuln/detail/CVE-2013-1774 |
1,079 | linux | ce0030c00f95cf9110d9cdcd41e901e1fb814417 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ce0030c00f95cf9110d9cdcd41e901e1fb814417 | None | 1 | static void call_console_drivers(unsigned start, unsigned end)
{
unsigned cur_index, start_print;
static int msg_level = -1;
BUG_ON(((int)(start - end)) > 0);
cur_index = start;
start_print = start;
while (cur_index != end) {
if (msg_level < 0 && ((end - cur_index) > 2)) {
/* strip log prefix */
cur... | 150,497,347,424,301,980,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2013-1772 | The log_prefix function in kernel/printk.c in the Linux kernel 3.x before 3.4.33 does not properly remove a prefix string from a syslog header, which allows local users to cause a denial of service (buffer overflow and system crash) by leveraging /dev/kmsg write access and triggering a call_console_drivers function cal... | https://nvd.nist.gov/vuln/detail/CVE-2013-1772 |
1,080 | tinc | 17a33dfd95b1a29e90db76414eb9622df9632320 | https://github.com/gsliepen/tinc | https://github.com/gsliepen/tinc/commit/17a33dfd95b1a29e90db76414eb9622df9632320 | Drop packets forwarded via TCP if they are too big (CVE-2013-1428).
Normally all requests sent via the meta connections are checked so that they
cannot be larger than the input buffer. However, when packets are forwarded via
meta connections, they are copied into a packet buffer without checking whether
it fits into i... | 1 | void receive_tcppacket(connection_t *c, const char *buffer, int len) {
vpn_packet_t outpkt;
outpkt.len = len;
if(c->options & OPTION_TCPONLY)
outpkt.priority = 0;
else
outpkt.priority = -1;
memcpy(outpkt.data, buffer, len);
receive_packet(c->node, &outpkt);
}
| 130,046,906,967,549,600,000,000,000,000,000,000,000 | net_packet.c | 8,171,485,538,728,046,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-1428 | Stack-based buffer overflow in the receive_tcppacket function in net_packet.c in tinc before 1.0.21 and 1.1 before 1.1pre7 allows remote authenticated peers to cause a denial of service (crash) or possibly execute arbitrary code via a large TCP packet. | https://nvd.nist.gov/vuln/detail/CVE-2013-1428 |
1,083 | krb5 | 8ee70ec63931d1e38567905387ab9b1d45734d81 | https://github.com/krb5/krb5 | https://github.com/krb5/krb5/commit/8ee70ec63931d1e38567905387ab9b1d45734d81 | KDC TGS-REQ null deref [CVE-2013-1416]
By sending an unusual but valid TGS-REQ, an authenticated remote
attacker can cause the KDC process to crash by dereferencing a null
pointer.
prep_reprocess_req() can cause a null pointer dereference when
processing a service principal name. Code in this function can
inappropri... | 1 | prep_reprocess_req(krb5_kdc_req *request, krb5_principal *krbtgt_princ)
{
krb5_error_code retval = KRB5KRB_AP_ERR_BADMATCH;
char **realms, **cpp, *temp_buf=NULL;
krb5_data *comp1 = NULL, *comp2 = NULL;
char *comp1_str = NULL;
/* By now we know that server principal name is unknown.
* If CANONI... | 26,445,768,461,799,657,000,000,000,000,000,000,000 | do_tgs_req.c | 132,430,812,994,884,870,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-1416 | The prep_reprocess_req function in do_tgs_req.c in the Key Distribution Center (KDC) in MIT Kerberos 5 (aka krb5) before 1.10.5 does not properly perform service-principal realm referral, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted TGS-R... | https://nvd.nist.gov/vuln/detail/CVE-2013-1416 |
1,084 | krb5 | f249555301940c6df3a2cdda13b56b5674eebc2e | https://github.com/krb5/krb5 | https://github.com/krb5/krb5/commit/f249555301940c6df3a2cdda13b56b5674eebc2e | PKINIT null pointer deref [CVE-2013-1415]
Don't dereference a null pointer when cleaning up.
The KDC plugin for PKINIT can dereference a null pointer when a
malformed packet causes processing to terminate early, leading to
a crash of the KDC process. An attacker would need to have a valid
PKINIT certificate or have ... | 1 | pkinit_check_kdc_pkid(krb5_context context,
pkinit_plg_crypto_context plg_cryptoctx,
pkinit_req_crypto_context req_cryptoctx,
pkinit_identity_crypto_context id_cryptoctx,
unsigned char *pdid_buf,
unsigned int p... | 113,776,654,271,026,500,000,000,000,000,000,000,000 | None | null | [
"CWE-476"
] | CVE-2013-1415 | The pkinit_check_kdc_pkid function in plugins/preauth/pkinit/pkinit_crypto_openssl.c in the PKINIT implementation in the Key Distribution Center (KDC) in MIT Kerberos 5 (aka krb5) before 1.10.4 and 1.11.x before 1.11.1 does not properly handle errors during extraction of fields from an X.509 certificate, which allows r... | https://nvd.nist.gov/vuln/detail/CVE-2013-1415 |
1,085 | linux | 2ca39528c01a933f6689cd6505ce65bd6d68a530 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/2ca39528c01a933f6689cd6505ce65bd6d68a530 | signal: always clear sa_restorer on execve
When the new signal handlers are set up, the location of sa_restorer is
not cleared, leaking a parent process's address space location to
children. This allows for a potential bypass of the parent's ASLR by
examining the sa_restorer value returned when calling sigaction().
... | 1 | flush_signal_handlers(struct task_struct *t, int force_default)
{
int i;
struct k_sigaction *ka = &t->sighand->action[0];
for (i = _NSIG ; i != 0 ; i--) {
if (force_default || ka->sa.sa_handler != SIG_IGN)
ka->sa.sa_handler = SIG_DFL;
ka->sa.sa_flags = 0;
sigemptyset(&ka->sa.sa_mask);
ka++;
}
}
| 300,076,951,675,769,600,000,000,000,000,000,000,000 | None | null | [
"CWE-264"
] | CVE-2013-0914 | The flush_signal_handlers function in kernel/signal.c in the Linux kernel before 3.8.4 preserves the value of the sa_restorer field across an exec operation, which makes it easier for local users to bypass the ASLR protection mechanism via a crafted application containing a sigaction system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-0914 |
1,089 | linux | 0a9ab9bdb3e891762553f667066190c1d22ad62b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/0a9ab9bdb3e891762553f667066190c1d22ad62b | Bluetooth: Fix incorrect strncpy() in hidp_setup_hid()
The length parameter should be sizeof(req->name) - 1 because there is no
guarantee that string provided by userspace will contain the trailing
'\0'.
Can be easily reproduced by manually setting req->name to 128 non-zero
bytes prior to ioctl(HIDPCONNADD) and check... | 1 | static int hidp_setup_hid(struct hidp_session *session,
struct hidp_connadd_req *req)
{
struct hid_device *hid;
int err;
session->rd_data = kzalloc(req->rd_size, GFP_KERNEL);
if (!session->rd_data)
return -ENOMEM;
if (copy_from_user(session->rd_data, req->rd_data, req->rd_size)) {
err = -EFAULT;
goto f... | 293,512,902,537,004,240,000,000,000,000,000,000,000 | core.c | 327,221,048,127,945,550,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-0349 | The hidp_setup_hid function in net/bluetooth/hidp/core.c in the Linux kernel before 3.7.6 does not properly copy a certain name field, which allows local users to obtain sensitive information from kernel memory by setting a long name and making an HIDPCONNADD ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-0349 |
1,090 | linux | a67adb997419fb53540d4a4f79c6471c60bc69b6 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a67adb997419fb53540d4a4f79c6471c60bc69b6 | evm: checking if removexattr is not a NULL
The following lines of code produce a kernel oops.
fd = socket(PF_FILE, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
fchmod(fd, 0666);
[ 139.922364] BUG: unable to handle kernel NULL pointer dereference at (null)
[ 139.924982] IP: [< (null)>] (null)
[ 139.924982] *pd... | 1 | int evm_update_evmxattr(struct dentry *dentry, const char *xattr_name,
const char *xattr_value, size_t xattr_value_len)
{
struct inode *inode = dentry->d_inode;
struct evm_ima_xattr_data xattr_data;
int rc = 0;
rc = evm_calc_hmac(dentry, xattr_name, xattr_value,
xattr_value_len, xattr_data.digest);
if (r... | 305,997,047,583,974,500,000,000,000,000,000,000,000 | evm_crypto.c | 98,288,434,782,980,370,000,000,000,000,000,000,000 | [
"CWE-703"
] | CVE-2013-0313 | The evm_update_evmxattr function in security/integrity/evm/evm_crypto.c in the Linux kernel before 3.7.5, when the Extended Verification Module (EVM) is enabled, allows local users to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact via an attempted removex... | https://nvd.nist.gov/vuln/detail/CVE-2013-0313 |
1,092 | linux | 89d7ae34cdda4195809a5a987f697a517a2a3177 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/89d7ae34cdda4195809a5a987f697a517a2a3177 | cipso: don't follow a NULL pointer when setsockopt() is called
As reported by Alan Cox, and verified by Lin Ming, when a user
attempts to add a CIPSO option to a socket using the CIPSO_V4_TAG_LOCAL
tag the kernel dies a terrible death when it attempts to follow a NULL
pointer (the skb argument to cipso_v4_validate() i... | 1 | int cipso_v4_validate(const struct sk_buff *skb, unsigned char **option)
{
unsigned char *opt = *option;
unsigned char *tag;
unsigned char opt_iter;
unsigned char err_offset = 0;
u8 opt_len;
u8 tag_len;
struct cipso_v4_doi *doi_def = NULL;
u32 tag_iter;
/* caller already checks for length values that are too ... | 254,520,361,513,953,370,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2013-0310 | The cipso_v4_validate function in net/ipv4/cipso_ipv4.c in the Linux kernel before 3.4.8 allows local users to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact via an IPOPT_CIPSO IP_OPTIONS setsockopt system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-0310 |
1,093 | linux | 77c1090f94d1b0b5186fb13a1b71b47b1343f87f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/77c1090f94d1b0b5186fb13a1b71b47b1343f87f | net: fix infinite loop in __skb_recv_datagram()
Tommi was fuzzing with trinity and reported the following problem :
commit 3f518bf745 (datagram: Add offset argument to __skb_recv_datagram)
missed that a raw socket receive queue can contain skbs with no payload.
We can loop in __skb_recv_datagram() with MSG_PEEK mode... | 1 | struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned int flags,
int *peeked, int *off, int *err)
{
struct sk_buff *skb;
long timeo;
/*
* Caller is allowed not to check sk->sk_err before skb_recv_datagram()
*/
int error = sock_error(sk);
if (error)
goto no_packet;
timeo = sock_rcvtimeo(sk,... | 89,456,193,869,845,560,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-0290 | The __skb_recv_datagram function in net/core/datagram.c in the Linux kernel before 3.8 does not properly handle the MSG_PEEK flag with zero-length data, which allows local users to cause a denial of service (infinite loop and system hang) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-0290 |
1,115 | linux | c903f0456bc69176912dee6dd25c6a66ee1aed00 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c903f0456bc69176912dee6dd25c6a66ee1aed00 | x86/msr: Add capabilities check
At the moment the MSR driver only relies upon file system
checks. This means that anything as root with any capability set
can write to MSRs. Historically that wasn't very interesting but
on modern processors the MSRs are such that writing to them
provides several ways to execute arbita... | 1 | static int msr_open(struct inode *inode, struct file *file)
{
unsigned int cpu;
struct cpuinfo_x86 *c;
cpu = iminor(file->f_path.dentry->d_inode);
if (cpu >= nr_cpu_ids || !cpu_online(cpu))
return -ENXIO; /* No such CPU */
c = &cpu_data(cpu);
if (!cpu_has(c, X86_FEATURE_MSR))
return -EIO; /* MSR not s... | 134,954,684,690,763,780,000,000,000,000,000,000,000 | msr.c | 286,103,807,502,299,130,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2013-0268 | The msr_open function in arch/x86/kernel/msr.c in the Linux kernel before 3.7.6 allows local users to bypass intended capability restrictions by executing a crafted application as root, as demonstrated by msr32.c. | https://nvd.nist.gov/vuln/detail/CVE-2013-0268 |
1,123 | libarchive | 22531545514043e04633e1c015c7540b9de9dbe4 | https://github.com/libarchive/libarchive | https://github.com/libarchive/libarchive/commit/22531545514043e04633e1c015c7540b9de9dbe4 | Limit write requests to at most INT_MAX.
This prevents a certain common programming error (passing -1 to write)
from leading to other problems deeper in the library. | 1 | _archive_write_data(struct archive *_a, const void *buff, size_t s)
{
struct archive_write *a = (struct archive_write *)_a;
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_DATA, "archive_write_data");
archive_clear_error(&a->archive);
return ((a->format_write_data)(a, buff, s));
}
| 130,653,882,621,145,300,000,000,000,000,000,000,000 | archive_write.c | 270,035,346,370,556,250,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-0211 | Integer signedness error in the archive_write_zip_data function in archive_write_set_format_zip.c in libarchive 3.1.2 and earlier, when running on 64-bit machines, allows context-dependent attackers to cause a denial of service (crash) via unspecified vectors, which triggers an improper conversion between unsigned and ... | https://nvd.nist.gov/vuln/detail/CVE-2013-0211 |
1,124 | linux | fe685aabf7c8c9f138e5ea900954d295bf229175 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/fe685aabf7c8c9f138e5ea900954d295bf229175 | isofs: avoid info leak on export
For type 1 the parent_offset member in struct isofs_fid gets copied
uninitialized to userland. Fix this by initializing it to 0.
Signed-off-by: Mathias Krause <minipli@googlemail.com>
Signed-off-by: Jan Kara <jack@suse.cz> | 1 | isofs_export_encode_fh(struct inode *inode,
__u32 *fh32,
int *max_len,
struct inode *parent)
{
struct iso_inode_info * ei = ISOFS_I(inode);
int len = *max_len;
int type = 1;
__u16 *fh16 = (__u16*)fh32;
/*
* WARNING: max_len is 5 for NFSv2. Because of this
* limitation, we use the l... | 175,765,004,232,940,700,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2012-6549 | The isofs_export_encode_fh function in fs/isofs/export.c in the Linux kernel before 3.6 does not initialize a certain structure member, which allows local users to obtain sensitive information from kernel heap memory via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2012-6549 |
1,125 | linux | 0143fc5e9f6f5aad4764801015bc8d4b4a278200 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/0143fc5e9f6f5aad4764801015bc8d4b4a278200 | udf: avoid info leak on export
For type 0x51 the udf.parent_partref member in struct fid gets copied
uninitialized to userland. Fix this by initializing it to 0.
Signed-off-by: Mathias Krause <minipli@googlemail.com>
Signed-off-by: Jan Kara <jack@suse.cz> | 1 | static int udf_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
struct inode *parent)
{
int len = *lenp;
struct kernel_lb_addr location = UDF_I(inode)->i_location;
struct fid *fid = (struct fid *)fh;
int type = FILEID_UDF_WITHOUT_PARENT;
if (parent && (len < 5)) {
*lenp = 5;
return 255;
} else if (le... | 271,056,274,363,302,500,000,000,000,000,000,000,000 | namei.c | 30,071,079,208,846,090,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-6548 | The udf_encode_fh function in fs/udf/namei.c in the Linux kernel before 3.6 does not initialize a certain structure member, which allows local users to obtain sensitive information from kernel heap memory via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2012-6548 |
1,126 | linux | a117dacde0288f3ec60b6e5bcedae8fa37ee0dfc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a117dacde0288f3ec60b6e5bcedae8fa37ee0dfc | net/tun: fix ioctl() based info leaks
The tun module leaks up to 36 bytes of memory by not fully initializing
a structure located on the stack that gets copied to user memory by the
TUNGETIFF and SIOCGIFHWADDR ioctl()s.
Signed-off-by: Mathias Krause <minipli@googlemail.com>
Signed-off-by: David S. Miller <davem@davem... | 1 | static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
unsigned long arg, int ifreq_len)
{
struct tun_file *tfile = file->private_data;
struct tun_struct *tun;
void __user* argp = (void __user*)arg;
struct sock_fprog fprog;
struct ifreq ifr;
int sndbuf;
int vnet_hdr_sz;
int ret;
if (cmd ==... | 35,869,627,182,032,717,000,000,000,000,000,000,000 | tun.c | 266,233,870,309,545,600,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-6547 | The __tun_chr_ioctl function in drivers/net/tun.c in the Linux kernel before 3.6 does not initialize a certain structure, which allows local users to obtain sensitive information from kernel stack memory via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2012-6547 |
1,127 | linux | e862f1a9b7df4e8196ebec45ac62295138aa3fc2 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e862f1a9b7df4e8196ebec45ac62295138aa3fc2 | atm: fix info leak in getsockopt(SO_ATMPVC)
The ATM code fails to initialize the two padding bytes of struct
sockaddr_atmpvc inserted for alignment. Add an explicit memset(0)
before filling the structure to avoid the info leak.
Signed-off-by: Mathias Krause <minipli@googlemail.com>
Signed-off-by: David S. Miller <dav... | 1 | int vcc_getsockopt(struct socket *sock, int level, int optname,
char __user *optval, int __user *optlen)
{
struct atm_vcc *vcc;
int len;
if (get_user(len, optlen))
return -EFAULT;
if (__SO_LEVEL_MATCH(optname, level) && len != __SO_SIZE(optname))
return -EINVAL;
vcc = ATM_SD(sock);
switch (optname) {
... | 133,848,982,303,383,400,000,000,000,000,000,000,000 | common.c | 247,639,831,891,652,760,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-6546 | The ATM implementation in the Linux kernel before 3.6 does not initialize certain structures, which allows local users to obtain sensitive information from kernel stack memory via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2012-6546 |
1,128 | linux | 9344a972961d1a6d2c04d9008b13617bcb6ec2ef | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/9344a972961d1a6d2c04d9008b13617bcb6ec2ef | Bluetooth: RFCOMM - Fix info leak via getsockname()
The RFCOMM code fails to initialize the trailing padding byte of struct
sockaddr_rc added for alignment. It that for leaks one byte kernel stack
via the getsockname() syscall. Add an explicit memset(0) before filling
the structure to avoid the info leak.
Signed-off-... | 1 | static int rfcomm_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
{
struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
struct sock *sk = sock->sk;
BT_DBG("sock %p, sk %p", sock, sk);
sa->rc_family = AF_BLUETOOTH;
sa->rc_channel = rfcomm_pi(sk)->channel;
if (peer)
bacpy(&... | 94,097,099,797,321,750,000,000,000,000,000,000,000 | sock.c | 37,985,206,412,418,230,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2012-6545 | The Bluetooth RFCOMM implementation in the Linux kernel before 3.6 does not properly initialize certain structures, which allows local users to obtain sensitive information from kernel memory via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2012-6545 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.