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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
39,734 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static ssize_t mem_read(struct file * file, char __user * buf,
size_t count, loff_t *ppos)
{
struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
char *page;
unsigned long src = *ppos;
int ret = -ESRCH;
struct mm_struct *mm;
if (!task)
goto out_no_task;
if (check_mem_permission(task))
... | 72,145,221,142,236,850,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,735 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static ssize_t mem_write(struct file * file, const char __user *buf,
size_t count, loff_t *ppos)
{
int copied;
char *page;
struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
unsigned long dst = *ppos;
copied = -ESRCH;
if (!task)
goto out_no_task;
if (check_mem_permission(task))
got... | 136,461,019,443,521,440,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,736 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static int mounts_open_common(struct inode *inode, struct file *file,
const struct seq_operations *op)
{
struct task_struct *task = get_proc_task(inode);
struct nsproxy *nsp;
struct mnt_namespace *ns = NULL;
struct path root;
struct proc_mounts *p;
int ret = -EINVAL;
if (task) {
rcu_read_lock();
ns... | 162,937,516,409,848,150,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,737 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static unsigned mounts_poll(struct file *file, poll_table *wait)
{
struct proc_mounts *p = file->private_data;
struct mnt_namespace *ns = p->ns;
unsigned res = POLLIN | POLLRDNORM;
poll_wait(file, &ns->poll, wait);
spin_lock(&vfsmount_lock);
if (p->event != ns->event) {
p->event = ns->event;
res |= POLLERR ... | 321,293,816,393,490,940,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,738 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static int pid_delete_dentry(struct dentry * dentry)
{
/* Is the task we represent dead?
* If so, then don't put the dentry on the lru list,
* kill it immediately.
*/
return !proc_pid(dentry->d_inode)->tasks[PIDTYPE_PID].first;
}
| 65,971,987,990,187,170,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,739 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
struct inode *inode = dentry->d_inode;
struct task_struct *task;
const struct cred *cred;
generic_fillattr(inode, stat);
rcu_read_lock();
stat->uid = 0;
stat->gid = 0;
task = pid_task(proc_pid(inode), PIDTYPE_PID);
if (... | 7,698,193,125,903,442,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,740 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static int pid_revalidate(struct dentry *dentry, struct nameidata *nd)
{
struct inode *inode = dentry->d_inode;
struct task_struct *task = get_proc_task(inode);
const struct cred *cred;
if (task) {
if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
task_dumpable(task)) {
rcu_read_lock();
cred = __ta... | 138,513,461,364,366,480,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,741 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static int proc_fd_permission(struct inode *inode, int mask)
{
int rv;
rv = generic_permission(inode, mask, NULL);
if (rv == 0)
return 0;
if (task_pid(current) == proc_pid(inode))
rv = 0;
return rv;
}
| 169,571,687,711,332,430,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,742 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static struct dentry *proc_fdinfo_instantiate(struct inode *dir,
struct dentry *dentry, struct task_struct *task, const void *ptr)
{
unsigned fd = *(unsigned *)ptr;
struct inode *inode;
struct proc_inode *ei;
struct dentry *error = ERR_PTR(-ENOENT);
inode = proc_pid_make_inode(dir->i_sb, task);
if (!inode)
... | 255,842,859,181,726,540,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,743 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
size_t count, loff_t *ppos)
{
struct inode * inode = file->f_path.dentry->d_inode;
char *page, *tmp;
ssize_t length;
uid_t loginuid;
if (!capable(CAP_AUDIT_CONTROL))
return -EPERM;
if (current != pid_task(proc_pid(inode), P... | 340,125,265,005,662,400,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,744 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static int proc_oom_score(struct task_struct *task, char *buffer)
{
unsigned long points;
struct timespec uptime;
do_posix_clock_monotonic_gettime(&uptime);
read_lock(&tasklist_lock);
points = badness(task->group_leader, uptime.tv_sec);
read_unlock(&tasklist_lock);
return sprintf(buffer, "%lu\n", points);
}
| 243,213,504,955,397,600,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,745 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
size_t count, loff_t *ppos)
{
struct inode * inode = file->f_path.dentry->d_inode;
char *page;
ssize_t length;
struct task_struct *task = get_proc_task(inode);
length = -ESRCH;
if (!task)
goto out_no_task;
if (count > PAGE_... | 19,588,093,313,853,294,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,746 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static int proc_pid_auxv(struct task_struct *task, char *buffer)
{
int res = 0;
struct mm_struct *mm = get_task_mm(task);
if (mm) {
unsigned int nwords = 0;
do {
nwords += 2;
} while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */
res = nwords * sizeof(mm->saved_auxv[0]);
if (res > PAGE_SIZE)
res = ... | 249,203,899,719,334,740,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,747 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static struct dentry *proc_pid_instantiate(struct inode *dir,
struct dentry * dentry,
struct task_struct *task, const void *ptr)
{
struct dentry *error = ERR_PTR(-ENOENT);
struct inode *inode;
inode = proc_pid_make_inode(dir->i_sb, task);
if (!inode)
goto out;
inode->i_mode = S_IFDIR|S_IRUGO|S_... | 16,454,800,116,263,431,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,748 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
{
struct dentry *result = ERR_PTR(-ENOENT);
struct task_struct *task;
unsigned tgid;
struct pid_namespace *ns;
result = proc_base_lookup(dir, dentry);
if (!IS_ERR(result) || PTR_ERR(result) != -ENOENT)
goto out;
t... | 299,350,979,918,718,840,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,749 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task)
{
struct inode * inode;
struct proc_inode *ei;
const struct cred *cred;
/* We need a new inode */
inode = new_inode(sb);
if (!inode)
goto out;
/* Common stuff */
ei = PROC_I(inode);
inode->i_mtime = inode->i_atime ... | 240,505,966,299,142,240,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,750 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns,
struct pid *pid, struct task_struct *task)
{
seq_printf(m, "%08x\n", task->personality);
return 0;
}
| 306,001,670,679,482,280,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,751 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
{
unsigned int nr = filp->f_pos - FIRST_PROCESS_ENTRY;
struct task_struct *reaper = get_proc_task(filp->f_path.dentry->d_inode);
struct tgid_iter iter;
struct pid_namespace *ns;
if (!reaper)
goto out_no_task;
for (; nr < ARRAY_SIZE(pro... | 135,325,141,157,315,250,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,752 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns,
struct pid *pid, struct task_struct *task)
{
struct stack_trace trace;
unsigned long *entries;
int i;
entries = kmalloc(MAX_STACK_TRACE_DEPTH * sizeof(*entries), GFP_KERNEL);
if (!entries)
return -ENOMEM;
trace.nr_entries = 0;
trace... | 27,146,176,467,284,995,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,753 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static struct dentry *proc_pident_instantiate(struct inode *dir,
struct dentry *dentry, struct task_struct *task, const void *ptr)
{
const struct pid_entry *p = ptr;
struct inode *inode;
struct proc_inode *ei;
struct dentry *error = ERR_PTR(-ENOENT);
inode = proc_pid_make_inode(dir->i_sb, task);
if (!inode)
g... | 196,300,540,415,190,600,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,754 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static int proc_root_link(struct inode *inode, struct path *path)
{
struct task_struct *task = get_proc_task(inode);
int result = -ENOENT;
if (task) {
result = get_fs_path(task, path, 1);
put_task_struct(task);
}
return result;
}
| 136,913,823,215,237,120,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,755 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static int proc_setattr(struct dentry *dentry, struct iattr *attr)
{
int error;
struct inode *inode = dentry->d_inode;
if (attr->ia_valid & ATTR_MODE)
return -EPERM;
error = inode_change_ok(inode, attr);
if (!error)
error = inode_setattr(inode, attr);
return error;
}
| 118,770,976,092,623,630,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,756 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static struct dentry *proc_task_instantiate(struct inode *dir,
struct dentry *dentry, struct task_struct *task, const void *ptr)
{
struct dentry *error = ERR_PTR(-ENOENT);
struct inode *inode;
inode = proc_pid_make_inode(dir->i_sb, task);
if (!inode)
goto out;
inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
inode->i... | 143,022,313,215,040,940,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,757 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | void removed_exe_file_vma(struct mm_struct *mm)
{
mm->num_exe_file_vmas--;
if ((mm->num_exe_file_vmas == 0) && mm->exe_file){
fput(mm->exe_file);
mm->exe_file = NULL;
}
}
| 325,971,055,428,467,240,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,758 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | static int sched_open(struct inode *inode, struct file *filp)
{
int ret;
ret = single_open(filp, sched_show, NULL);
if (!ret) {
struct seq_file *m = filp->private_data;
m->private = inode;
}
return ret;
}
| 88,305,517,428,929,100,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,759 | linux | 86acdca1b63e6890540fa19495cfc708beff3d8b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/86acdca1b63e6890540fa19495cfc708beff3d8b | fix autofs/afs/etc. magic mountpoint breakage
We end up trying to kfree() nd.last.name on open("/mnt/tmp", O_CREAT)
if /mnt/tmp is an autofs direct mount. The reason is that nd.last_type
is bogus here; we want LAST_BIND for everything of that kind and we
get LAST_NORM left over from finding parent directory.
So make... | 0 | void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file)
{
if (new_exe_file)
get_file(new_exe_file);
if (mm->exe_file)
fput(mm->exe_file);
mm->exe_file = new_exe_file;
mm->num_exe_file_vmas = 0;
}
| 304,136,023,581,293,000,000,000,000,000,000,000,000 | base.c | 97,077,772,234,708,240,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0203 | The __do_follow_link function in fs/namei.c in the Linux kernel before 2.6.33 does not properly handle the last pathname component during use of certain filesystems, which allows local users to cause a denial of service (incorrect free operations and system crash) via an open system call. | https://nvd.nist.gov/vuln/detail/CVE-2014-0203 |
39,816 | php-src | 35ceea928b12373a3b1e3eecdc32ed323223a40d | https://github.com/php/php-src | https://github.com/php/php-src/commit/35ceea928b12373a3b1e3eecdc32ed323223a40d | Fix bug #67060: use default mode of 660 | 0 | static int fpm_unix_conf_wp(struct fpm_worker_pool_s *wp) /* {{{ */
{
struct passwd *pwd;
int is_root = !geteuid();
if (is_root) {
if (wp->config->user && *wp->config->user) {
if (strlen(wp->config->user) == strspn(wp->config->user, "0123456789")) {
wp->set_uid = strtoul(wp->config->user, 0, 10);
} else... | 124,957,664,367,858,170,000,000,000,000,000,000,000 | None | null | [
"CWE-264"
] | CVE-2014-0185 | sapi/fpm/fpm/fpm_unix.c in the FastCGI Process Manager (FPM) in PHP before 5.4.28 and 5.5.x before 5.5.12 uses 0666 permissions for the UNIX socket, which allows local users to gain privileges via a crafted FastCGI client. | https://nvd.nist.gov/vuln/detail/CVE-2014-0185 |
39,817 | php-src | 35ceea928b12373a3b1e3eecdc32ed323223a40d | https://github.com/php/php-src | https://github.com/php/php-src/commit/35ceea928b12373a3b1e3eecdc32ed323223a40d | Fix bug #67060: use default mode of 660 | 0 | int fpm_unix_init_child(struct fpm_worker_pool_s *wp) /* {{{ */
{
int is_root = !geteuid();
int made_chroot = 0;
if (wp->config->rlimit_files) {
struct rlimit r;
r.rlim_max = r.rlim_cur = (rlim_t) wp->config->rlimit_files;
if (0 > setrlimit(RLIMIT_NOFILE, &r)) {
zlog(ZLOG_SYSERROR, "[pool %s] failed to s... | 257,381,809,373,205,000,000,000,000,000,000,000,000 | None | null | [
"CWE-264"
] | CVE-2014-0185 | sapi/fpm/fpm/fpm_unix.c in the FastCGI Process Manager (FPM) in PHP before 5.4.28 and 5.5.x before 5.5.12 uses 0666 permissions for the UNIX socket, which allows local users to gain privileges via a crafted FastCGI client. | https://nvd.nist.gov/vuln/detail/CVE-2014-0185 |
39,818 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int ___pskb_trim(struct sk_buff *skb, unsigned int len)
{
struct sk_buff **fragp;
struct sk_buff *frag;
int offset = skb_headlen(skb);
int nfrags = skb_shinfo(skb)->nr_frags;
int i;
int err;
if (skb_cloned(skb) &&
unlikely((err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC))))
return err;
i = 0;
if (offset... | 121,132,404,142,158,070,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,819 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
int flags, int node)
{
struct kmem_cache *cache;
struct skb_shared_info *shinfo;
struct sk_buff *skb;
u8 *data;
bool pfmemalloc;
cache = (flags & SKB_ALLOC_FCLONE)
? skbuff_fclone_cache : skbuff_head_cache;
if (sk_memalloc_socks() && (flag... | 19,155,952,421,770,856,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,820 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | struct sk_buff *__alloc_skb_head(gfp_t gfp_mask, int node)
{
struct sk_buff *skb;
/* Get the HEAD */
skb = kmem_cache_alloc_node(skbuff_head_cache,
gfp_mask & ~__GFP_DMA, node);
if (!skb)
goto out;
/*
* Only clear those fields we need to clear, not those that we will
* actually initialise below. He... | 204,061,204,536,448,970,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,821 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void __copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
{
new->tstamp = old->tstamp;
new->dev = old->dev;
new->transport_header = old->transport_header;
new->network_header = old->network_header;
new->mac_header = old->mac_header;
new->inner_protocol = old->inner_protocol;
new->inner_tra... | 57,618,015,336,187,630,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,822 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void __kfree_skb(struct sk_buff *skb)
{
skb_release_all(skb);
kfree_skbmem(skb);
}
| 52,542,168,796,511,490,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,823 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void *__kmalloc_reserve(size_t size, gfp_t flags, int node,
unsigned long ip, bool *pfmemalloc)
{
void *obj;
bool ret_pfmemalloc = false;
/*
* Try a regular allocation, when that fails and we're not entitled
* to the reserves, fail.
*/
obj = kmalloc_node_track_caller(size,
flags | __GFP... | 334,745,525,596,962,000,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,824 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void *__netdev_alloc_frag(unsigned int fragsz, gfp_t gfp_mask)
{
struct netdev_alloc_cache *nc;
void *data = NULL;
int order;
unsigned long flags;
local_irq_save(flags);
nc = &__get_cpu_var(netdev_alloc_cache);
if (unlikely(!nc->frag.page)) {
refill:
for (order = NETDEV_FRAG_PAGE_MAX_ORDER; ;) {
gfp... | 230,935,329,090,214,340,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,825 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
unsigned int length, gfp_t gfp_mask)
{
struct sk_buff *skb = NULL;
unsigned int fragsz = SKB_DATA_ALIGN(length + NET_SKB_PAD) +
SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
if (fragsz <= PAGE_SIZE && !(gfp_mask & (__GFP_WAIT | GFP_DMA))) ... | 66,653,579,144,083,430,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,826 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | struct sk_buff *__pskb_copy(struct sk_buff *skb, int headroom, gfp_t gfp_mask)
{
unsigned int size = skb_headlen(skb) + headroom;
struct sk_buff *n = __alloc_skb(size, gfp_mask,
skb_alloc_rx_flag(skb), NUMA_NO_NODE);
if (!n)
goto out;
/* Set the data pointer */
skb_reserve(n, headroom);
/* Set the tail p... | 307,809,520,607,948,000,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,827 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta)
{
/* If skb has not enough free space at tail, get new one
* plus 128 bytes for future expansions. If we have enough
* room at tail, reallocate without expansion only if skb is cloned.
*/
int i, k, eat = (skb->tail + delta) - skb->end;
if (eat > ... | 264,319,290,866,454,680,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,828 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | __wsum __skb_checksum(const struct sk_buff *skb, int offset, int len,
__wsum csum, const struct skb_checksum_ops *ops)
{
int start = skb_headlen(skb);
int i, copy = start - offset;
struct sk_buff *frag_iter;
int pos = 0;
/* Checksum header. */
if (copy > 0) {
if (copy > len)
copy = len;
csum = ops... | 256,176,438,350,819,700,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,829 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static struct sk_buff *__skb_clone(struct sk_buff *n, struct sk_buff *skb)
{
#define C(x) n->x = skb->x
n->next = n->prev = NULL;
n->sk = NULL;
__copy_skb_header(n, skb);
C(len);
C(data_len);
C(mac_len);
n->hdr_len = skb->nohdr ? skb_headroom(skb) : skb->hdr_len;
n->cloned = 1;
n->nohdr = 0;
n->destructor =... | 56,150,904,723,451,820,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,830 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static bool __skb_splice_bits(struct sk_buff *skb, struct pipe_inode_info *pipe,
unsigned int *offset, unsigned int *len,
struct splice_pipe_desc *spd, struct sock *sk)
{
int seg;
/* map the linear part :
* If skb->head_frag is set, this 'linear' part is backed by a
* fragment, and if the head ... | 200,643,066,182,346,700,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,831 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | __skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
{
int start = skb_headlen(skb);
int i, copy = start - offset;
struct sk_buff *frag_iter;
int elt = 0;
if (copy > 0) {
if (copy > len)
copy = len;
sg_set_buf(sg, skb->data + offset, copy);
elt++;
if ((len -= copy) == 0)
... | 166,082,186,773,187,000,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,832 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void __skb_warn_lro_forwarding(const struct sk_buff *skb)
{
net_warn_ratelimited("%s: received packets cannot be forwarded while LRO is enabled\n",
skb->dev->name);
}
| 301,923,740,450,162,570,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,833 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static bool __splice_segment(struct page *page, unsigned int poff,
unsigned int plen, unsigned int *off,
unsigned int *len,
struct splice_pipe_desc *spd, bool linear,
struct sock *sk,
struct pipe_inode_info *pipe)
{
if (!*len)
return true;
/* skip this segment if already pro... | 207,074,196,770,526,100,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,834 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | struct sk_buff *build_skb(void *data, unsigned int frag_size)
{
struct skb_shared_info *shinfo;
struct sk_buff *skb;
unsigned int size = frag_size ? : ksize(data);
skb = kmem_cache_alloc(skbuff_head_cache, GFP_ATOMIC);
if (!skb)
return NULL;
size -= SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
memset(skb... | 108,126,858,658,457,200,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,835 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void consume_skb(struct sk_buff *skb)
{
if (unlikely(!skb))
return;
if (likely(atomic_read(&skb->users) == 1))
smp_rmb();
else if (likely(!atomic_dec_and_test(&skb->users)))
return;
trace_consume_skb(skb);
__kfree_skb(skb);
}
| 62,567,555,393,815,230,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,836 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
{
__copy_skb_header(new, old);
skb_shinfo(new)->gso_size = skb_shinfo(old)->gso_size;
skb_shinfo(new)->gso_segs = skb_shinfo(old)->gso_segs;
skb_shinfo(new)->gso_type = skb_shinfo(old)->gso_type;
}
| 94,725,191,178,860,350,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,837 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void kfree_skb_list(struct sk_buff *segs)
{
while (segs) {
struct sk_buff *next = segs->next;
kfree_skb(segs);
segs = next;
}
}
| 185,590,901,773,501,980,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,838 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void kfree_skbmem(struct sk_buff *skb)
{
struct sk_buff *other;
atomic_t *fclone_ref;
switch (skb->fclone) {
case SKB_FCLONE_UNAVAILABLE:
kmem_cache_free(skbuff_head_cache, skb);
break;
case SKB_FCLONE_ORIG:
fclone_ref = (atomic_t *) (skb + 2);
if (atomic_dec_and_test(fclone_ref))
kmem_cache_fr... | 3,531,185,047,103,366,600,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,839 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static struct page *linear_to_page(struct page *page, unsigned int *len,
unsigned int *offset,
struct sock *sk)
{
struct page_frag *pfrag = sk_page_frag(sk);
if (!sk_page_frag_refill(sk, pfrag))
return NULL;
*len = min_t(unsigned int, *len, pfrag->size - pfrag->offset);
memcpy(page_address(pfrag-... | 292,851,607,981,884,080,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,840 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail,
gfp_t gfp_mask)
{
int i;
u8 *data;
int size = nhead + skb_end_offset(skb) + ntail;
long off;
BUG_ON(nhead < 0);
if (skb_shared(skb))
BUG();
size = SKB_DATA_ALIGN(size);
if (skb_pfmemalloc(skb))
gfp_mask |= __GFP_MEMALLOC;
data = kma... | 303,271,942,202,810,080,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,841 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | unsigned char *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)
{
if (tail != skb) {
skb->data_len += len;
skb->len += len;
}
return skb_put(tail, len);
}
| 217,915,782,646,873,500,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,842 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_abort_seq_read(struct skb_seq_state *st)
{
if (st->frag_data)
kunmap_atomic(st->frag_data);
}
| 22,553,257,636,057,667,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,843 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, int off,
int size, unsigned int truesize)
{
skb_fill_page_desc(skb, i, page, off, size);
skb->len += size;
skb->data_len += size;
skb->truesize += truesize;
}
| 182,257,671,333,930,800,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,844 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static inline int skb_alloc_rx_flag(const struct sk_buff *skb)
{
if (skb_pfmemalloc(skb))
return SKB_ALLOC_RX;
return 0;
}
| 286,821,494,448,502,950,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,845 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
int (*getfrag)(void *from, char *to, int offset,
int len, int odd, struct sk_buff *skb),
void *from, int length)
{
int frg_cnt = skb_shinfo(skb)->nr_frags;
int copy;
int offset = 0;
int ret;
struct page_frag *pfrag = ¤t->task_frag;
... | 8,026,505,682,209,167,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,846 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | __wsum skb_checksum(const struct sk_buff *skb, int offset,
int len, __wsum csum)
{
const struct skb_checksum_ops ops = {
.update = csum_partial_ext,
.combine = csum_block_add_ext,
};
return __skb_checksum(skb, offset, len, csum, &ops);
}
| 246,373,725,186,365,800,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,847 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int skb_checksum_setup(struct sk_buff *skb, bool recalculate)
{
int err;
switch (skb->protocol) {
case htons(ETH_P_IP):
err = skb_checksum_setup_ip(skb, recalculate);
break;
case htons(ETH_P_IPV6):
err = skb_checksum_setup_ipv6(skb, recalculate);
break;
default:
err = -EPROTO;
break;
}
return err... | 194,360,428,110,353,700,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,848 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static int skb_checksum_setup_ipv6(struct sk_buff *skb, bool recalculate)
{
int err;
u8 nexthdr;
unsigned int off;
unsigned int len;
bool fragment;
bool done;
fragment = false;
done = false;
off = sizeof(struct ipv6hdr);
err = skb_maybe_pull_tail(skb, off, MAX_IPV6_HDR_LEN);
if (err < 0)
goto out;
nex... | 283,916,782,183,731,300,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,849 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
{
struct sk_buff *n;
if (skb_orphan_frags(skb, gfp_mask))
return NULL;
n = skb + 1;
if (skb->fclone == SKB_FCLONE_ORIG &&
n->fclone == SKB_FCLONE_UNAVAILABLE) {
atomic_t *fclone_ref = (atomic_t *) (n + 1);
n->fclone = SKB_FCLONE_CLONE;
at... | 11,875,265,837,002,123,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,850 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void skb_clone_fraglist(struct sk_buff *skb)
{
struct sk_buff *list;
skb_walk_frags(skb, list)
skb_get(list);
}
| 221,283,947,382,817,740,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,851 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_coalesce_rx_frag(struct sk_buff *skb, int i, int size,
unsigned int truesize)
{
skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
skb_frag_size_add(frag, size);
skb->len += size;
skb->data_len += size;
skb->truesize += truesize;
}
| 334,878,416,682,359,970,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,852 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_complete_wifi_ack(struct sk_buff *skb, bool acked)
{
struct sock *sk = skb->sk;
struct sock_exterr_skb *serr;
int err;
skb->wifi_acked_valid = 1;
skb->wifi_acked = acked;
serr = SKB_EXT_ERR(skb);
memset(serr, 0, sizeof(*serr));
serr->ee.ee_errno = ENOMSG;
serr->ee.ee_origin = SO_EE_ORIGIN_TXSTATUS;
... | 202,552,206,184,652,750,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,853 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t gfp_mask)
{
int headerlen = skb_headroom(skb);
unsigned int size = skb_end_offset(skb) + skb->data_len;
struct sk_buff *n = __alloc_skb(size, gfp_mask,
skb_alloc_rx_flag(skb), NUMA_NO_NODE);
if (!n)
return NULL;
/* Set the data pointer */
skb_rese... | 5,025,715,505,657,042,500,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,854 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to)
{
__wsum csum;
long csstart;
if (skb->ip_summed == CHECKSUM_PARTIAL)
csstart = skb_checksum_start_offset(skb);
else
csstart = skb_headlen(skb);
BUG_ON(csstart > skb_headlen(skb));
skb_copy_from_linear_data(skb, to, csstart);
csum = 0;
if (css... | 171,525,241,579,043,800,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,855 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len)
{
int start = skb_headlen(skb);
struct sk_buff *frag_iter;
int i, copy;
if (offset > (int)skb->len - len)
goto fault;
/* Copy header. */
if ((copy = start - offset) > 0) {
if (copy > len)
copy = len;
skb_copy_from_linear_data_o... | 68,657,268,479,950,880,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,856 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
int newheadroom, int newtailroom,
gfp_t gfp_mask)
{
/*
* Allocate the copy buffer
*/
struct sk_buff *n = __alloc_skb(newheadroom + skb->len + newtailroom,
gfp_mask, skb_alloc_rx_flag(skb),
NUMA_NO_NODE);
int oldheadroom = skb_headroom(s... | 259,232,761,671,319,000,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,857 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask)
{
int i;
int num_frags = skb_shinfo(skb)->nr_frags;
struct page *page, *head = NULL;
struct ubuf_info *uarg = skb_shinfo(skb)->destructor_arg;
for (i = 0; i < num_frags; i++) {
u8 *vaddr;
skb_frag_t *f = &skb_shinfo(skb)->frags[i];
page = alloc_page(g... | 223,262,859,837,666,300,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,858 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer)
{
int copyflag;
int elt;
struct sk_buff *skb1, **skb_p;
/* If skb is cloned or its head is paged, reallocate
* head pulling out all the pages (pages are considered not writable
* at the moment even if they are anonymous).
*/
if ((... | 119,427,443,251,471,870,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,859 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | struct sk_buff *skb_dequeue(struct sk_buff_head *list)
{
unsigned long flags;
struct sk_buff *result;
spin_lock_irqsave(&list->lock, flags);
result = __skb_dequeue(list);
spin_unlock_irqrestore(&list->lock, flags);
return result;
}
| 287,962,238,955,759,530,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,860 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list)
{
unsigned long flags;
struct sk_buff *result;
spin_lock_irqsave(&list->lock, flags);
result = __skb_dequeue_tail(list);
spin_unlock_irqrestore(&list->lock, flags);
return result;
}
| 135,691,010,076,501,880,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,861 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static inline void skb_drop_fraglist(struct sk_buff *skb)
{
skb_drop_list(&skb_shinfo(skb)->frag_list);
}
| 331,241,979,009,888,300,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,862 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void skb_drop_list(struct sk_buff **listp)
{
kfree_skb_list(*listp);
*listp = NULL;
}
| 247,497,508,676,346,300,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,863 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | unsigned int skb_find_text(struct sk_buff *skb, unsigned int from,
unsigned int to, struct ts_config *config,
struct ts_state *state)
{
unsigned int ret;
config->get_next_block = skb_ts_get_next_block;
config->finish = skb_ts_finish;
skb_prepare_seq_read(skb, from, to, TS_SKB_CB(state));
ret = texts... | 75,039,118,882,751,760,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,864 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void skb_free_head(struct sk_buff *skb)
{
if (skb->head_frag)
put_page(virt_to_head_page(skb->head));
else
kfree(skb->head);
}
| 304,626,385,828,318,340,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,865 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb)
{
struct skb_shared_info *pinfo, *skbinfo = skb_shinfo(skb);
unsigned int offset = skb_gro_offset(skb);
unsigned int headlen = skb_headlen(skb);
struct sk_buff *nskb, *lp, *p = *head;
unsigned int len = skb_gro_len(skb);
unsigned int delta_truesize;
... | 84,005,601,588,556,860,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,866 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | unsigned int skb_gso_transport_seglen(const struct sk_buff *skb)
{
const struct skb_shared_info *shinfo = skb_shinfo(skb);
unsigned int hdr_len;
if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)))
hdr_len = tcp_hdrlen(skb);
else
hdr_len = sizeof(struct udphdr);
return hdr_len + shinfo->gso_size;
}... | 288,998,214,429,278,630,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,867 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void skb_headers_offset_update(struct sk_buff *skb, int off)
{
/* Only adjust this if it actually is csum_start rather than csum */
if (skb->ip_summed == CHECKSUM_PARTIAL)
skb->csum_start += off;
/* {transport,network,mac}_header and tail are relative to skb->head */
skb->transport_header += off;
skb->net... | 164,131,877,150,655,600,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,868 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void __init skb_init(void)
{
skbuff_head_cache = kmem_cache_create("skbuff_head_cache",
sizeof(struct sk_buff),
0,
SLAB_HWCACHE_ALIGN|SLAB_PANIC,
NULL);
skbuff_fclone_cache = kmem_cache_create("skbuff_fclone_cache",
(2*sizeof(struct sk_buff)) +
sizeof(atomic_t),... | 99,893,752,397,173,860,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,869 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list)
{
unsigned long flags;
spin_lock_irqsave(&list->lock, flags);
__skb_insert(newsk, old->prev, old, list);
spin_unlock_irqrestore(&list->lock, flags);
}
| 308,542,803,688,424,940,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,870 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static int skb_maybe_pull_tail(struct sk_buff *skb, unsigned int len,
unsigned int max)
{
if (skb_headlen(skb) >= len)
return 0;
/* If we need to pullup then pullup to the max, so we
* won't need to do it again.
*/
if (max > skb->len)
max = skb->len;
if (__pskb_pull_tail(skb, max - skb_headlen(s... | 292,894,376,128,898,700,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,871 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src)
{
skb_release_all(dst);
return __skb_clone(dst, src);
}
| 117,427,310,992,180,800,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,872 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void skb_over_panic(struct sk_buff *skb, unsigned int sz, void *addr)
{
skb_panic(skb, sz, addr, __func__);
}
| 175,842,792,528,044,360,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,873 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int skb_pad(struct sk_buff *skb, int pad)
{
int err;
int ntail;
/* If the skbuff is non linear tailroom is always zero.. */
if (!skb_cloned(skb) && skb_tailroom(skb) >= pad) {
memset(skb->data+skb->len, 0, pad);
return 0;
}
ntail = skb->data_len + pad - (skb->end - skb->tail);
if (likely(skb_cloned(skb) ||... | 62,000,194,596,455,950,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,874 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void skb_panic(struct sk_buff *skb, unsigned int sz, void *addr,
const char msg[])
{
pr_emerg("%s: text:%p len:%d put:%d head:%p data:%p tail:%#lx end:%#lx dev:%s\n",
msg, addr, skb->len, sz, skb->head, skb->data,
(unsigned long)skb->tail, (unsigned long)skb->end,
skb->dev ? skb->dev->name : "<... | 34,526,935,361,649,960,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,875 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_prepare_seq_read(struct sk_buff *skb, unsigned int from,
unsigned int to, struct skb_seq_state *st)
{
st->lower_offset = from;
st->upper_offset = to;
st->root_skb = st->cur_skb = skb;
st->frag_idx = st->stepped_offset = 0;
st->frag_data = NULL;
}
| 40,126,498,207,897,906,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,876 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
{
return skb_pull_inline(skb, len);
}
| 30,699,968,616,391,450,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,877 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len)
{
BUG_ON(len > skb->len);
skb->len -= len;
BUG_ON(skb->len < skb->data_len);
skb_postpull_rcsum(skb, skb->data, len);
return skb->data += len;
}
| 335,874,999,731,914,260,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,878 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
{
unsigned char *tmp = skb_tail_pointer(skb);
SKB_LINEAR_ASSERT(skb);
skb->tail += len;
skb->len += len;
if (unlikely(skb->tail > skb->end))
skb_over_panic(skb, len, __builtin_return_address(0));
return tmp;
}
| 157,314,468,207,664,730,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,879 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk)
{
unsigned long flags;
spin_lock_irqsave(&list->lock, flags);
__skb_queue_head(list, newsk);
spin_unlock_irqrestore(&list->lock, flags);
}
| 121,466,115,612,312,200,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,880 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_queue_purge(struct sk_buff_head *list)
{
struct sk_buff *skb;
while ((skb = skb_dequeue(list)) != NULL)
kfree_skb(skb);
}
| 180,494,486,760,854,120,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,881 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)
{
unsigned long flags;
spin_lock_irqsave(&list->lock, flags);
__skb_queue_tail(list, newsk);
spin_unlock_irqrestore(&list->lock, flags);
}
| 156,560,231,357,887,230,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,882 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | struct sk_buff *skb_realloc_headroom(struct sk_buff *skb, unsigned int headroom)
{
struct sk_buff *skb2;
int delta = headroom - skb_headroom(skb);
if (delta <= 0)
skb2 = pskb_copy(skb, GFP_ATOMIC);
else {
skb2 = skb_clone(skb, GFP_ATOMIC);
if (skb2 && pskb_expand_head(skb2, SKB_DATA_ALIGN(delta), 0,
... | 210,285,691,121,275,420,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,883 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void skb_release_all(struct sk_buff *skb)
{
skb_release_head_state(skb);
if (likely(skb->head))
skb_release_data(skb);
}
| 70,944,700,339,717,340,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,884 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void skb_release_data(struct sk_buff *skb)
{
if (!skb->cloned ||
!atomic_sub_return(skb->nohdr ? (1 << SKB_DATAREF_SHIFT) + 1 : 1,
&skb_shinfo(skb)->dataref)) {
if (skb_shinfo(skb)->nr_frags) {
int i;
for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
skb_frag_unref(skb, i);
}
/*
... | 318,446,722,503,998,800,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,885 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void skb_release_head_state(struct sk_buff *skb)
{
skb_dst_drop(skb);
#ifdef CONFIG_XFRM
secpath_put(skb->sp);
#endif
if (skb->destructor) {
WARN_ON(in_irq());
skb->destructor(skb);
}
#if IS_ENABLED(CONFIG_NF_CONNTRACK)
nf_conntrack_put(skb->nfct);
#endif
#ifdef CONFIG_BRIDGE_NETFILTER
nf_bridge_put(sk... | 139,151,428,365,450,180,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,886 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_scrub_packet(struct sk_buff *skb, bool xnet)
{
if (xnet)
skb_orphan(skb);
skb->tstamp.tv64 = 0;
skb->pkt_type = PACKET_HOST;
skb->skb_iif = 0;
skb->local_df = 0;
skb_dst_drop(skb);
skb->mark = 0;
secpath_reset(skb);
nf_reset(skb);
nf_reset_trace(skb);
}
| 186,014,949,904,228,020,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,887 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | unsigned int skb_seq_read(unsigned int consumed, const u8 **data,
struct skb_seq_state *st)
{
unsigned int block_limit, abs_offset = consumed + st->lower_offset;
skb_frag_t *frag;
if (unlikely(abs_offset >= st->upper_offset)) {
if (st->frag_data) {
kunmap_atomic(st->frag_data);
st->frag_data = NULL;
... | 247,958,614,597,788,400,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,888 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int skb_shift(struct sk_buff *tgt, struct sk_buff *skb, int shiftlen)
{
int from, to, merge, todo;
struct skb_frag_struct *fragfrom, *fragto;
BUG_ON(shiftlen > skb->len);
BUG_ON(skb_headlen(skb)); /* Would corrupt stream */
todo = shiftlen;
from = 0;
to = skb_shinfo(tgt)->nr_frags;
fragfrom = &skb_shinfo(skb)... | 325,154,705,504,702,040,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,889 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int skb_splice_bits(struct sk_buff *skb, unsigned int offset,
struct pipe_inode_info *pipe, unsigned int tlen,
unsigned int flags)
{
struct partial_page partial[MAX_SKB_FRAGS];
struct page *pages[MAX_SKB_FRAGS];
struct splice_pipe_desc spd = {
.pages = pages,
.partial = partial,
.nr_pages_max = MAX... | 37,611,218,061,016,160,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.