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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
33,163 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
int group, int from_ancestor_ns)
{
struct sigpending *pending;
struct sigqueue *q;
int override_rlimit;
int ret = 0, result;
assert_spin_locked(&t->sighand->siglock);
result = TRACE_SIGNAL_IGNORED;
if (!prepare_signal(sig, t,
... | 128,385,369,499,722,480,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,164 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void __set_current_blocked(const sigset_t *newset)
{
struct task_struct *tsk = current;
spin_lock_irq(&tsk->sighand->siglock);
__set_task_blocked(tsk, newset);
spin_unlock_irq(&tsk->sighand->siglock);
}
| 237,268,828,653,649,200,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,165 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
{
if (signal_pending(tsk) && !thread_group_empty(tsk)) {
sigset_t newblocked;
/* A set of now blocked but previously unblocked signals. */
sigandnsets(&newblocked, newset, ¤t->blocked);
retarget_shared_pending(tsk, &newblocke... | 79,531,245,873,060,050,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,166 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
{
struct sigqueue *q = NULL;
struct user_struct *user;
/*
* Protect access to @t credentials. This can go away when all
* callers hold rcu read lock.
*/
rcu_read_lock();
user = get_uid(__task_cred(t)->user);
atomic_inc(&user... | 250,532,952,076,031,460,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,167 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static void __sigqueue_free(struct sigqueue *q)
{
if (q->flags & SIGQUEUE_PREALLOC)
return;
atomic_dec(&q->user->sigpending);
free_uid(q->user);
kmem_cache_free(sigqueue_cachep, q);
}
| 193,178,222,201,225,150,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,168 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
{
unsigned long flags;
spin_lock_irqsave(¤t->sighand->siglock, flags);
current->notifier_mask = mask;
current->notifier_data = priv;
current->notifier = notifier;
spin_unlock_irqrestore(¤t->sighand->siglock, flags);
}
| 220,088,282,313,906,600,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,169 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int check_kill_permission(int sig, struct siginfo *info,
struct task_struct *t)
{
struct pid *sid;
int error;
if (!valid_signal(sig))
return -EINVAL;
if (!si_fromuser(info))
return 0;
error = audit_signal_info(sig, t); /* Let audit system see the signal */
if (error)
return error;
if (!same... | 298,062,956,525,949,250,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,170 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
{
struct sigqueue *q, *first = NULL;
/*
* Collect the siginfo appropriate to this signal. Check if
* there is another siginfo for the same signal.
*/
list_for_each_entry(q, &list->list, list) {
if (q->info.si_signo == sig) {
if... | 27,738,703,142,103,692,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,171 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int compat_restore_altstack(const compat_stack_t __user *uss)
{
int err = compat_sys_sigaltstack(uss, NULL);
/* squash all but -EFAULT for now */
return err == -EFAULT ? err : 0;
}
| 210,883,114,102,505,350,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,172 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static void complete_signal(int sig, struct task_struct *p, int group)
{
struct signal_struct *signal = p->signal;
struct task_struct *t;
/*
* Now find a thread we can wake up to take the signal off the queue.
*
* If the main thread wants the signal, it gets first crack.
* Probably the least surprising to t... | 195,269,243,172,697,200,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,173 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
{
int err;
if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
return -EFAULT;
if (from->si_code < 0)
return __copy_to_user(to, from, sizeof(siginfo_t))
? -EFAULT : 0;
/*
* If you change siginfo_t structure, please be sure
* this code is ... | 156,684,708,049,641,520,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,174 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
{
int signr;
/* We only dequeue private signals from ourselves, we don't let
* signalfd steal them
*/
signr = __dequeue_signal(&tsk->pending, mask, info);
if (!signr) {
signr = __dequeue_signal(&tsk->signal->shared_pending,
ma... | 52,228,973,108,500,435,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,175 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static void do_jobctl_trap(void)
{
struct signal_struct *signal = current->signal;
int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
if (current->ptrace & PT_SEIZED) {
if (!signal->group_stop_count &&
!(signal->flags & SIGNAL_STOP_STOPPED))
signr = SIGTRAP;
WARN_ON_ONCE(!signr);
ptrace_do_notify(sig... | 321,373,818,098,750,300,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,176 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | long do_no_restart_syscall(struct restart_block *param)
{
return -EINTR;
}
| 280,170,279,857,511,320,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,177 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | bool do_notify_parent(struct task_struct *tsk, int sig)
{
struct siginfo info;
unsigned long flags;
struct sighand_struct *psig;
bool autoreap = false;
cputime_t utime, stime;
BUG_ON(sig == -1);
/* do_notify_parent_cldstop should have been called instead. */
BUG_ON(task_is_stopped_or_traced(tsk));
BUG_ON... | 217,015,388,657,355,830,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,178 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static void do_notify_parent_cldstop(struct task_struct *tsk,
bool for_ptracer, int why)
{
struct siginfo info;
unsigned long flags;
struct task_struct *parent;
struct sighand_struct *sighand;
cputime_t utime, stime;
if (for_ptracer) {
parent = tsk->parent;
} else {
tsk = tsk->group_leader;
paren... | 314,033,431,377,417,900,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,179 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t *info)
{
/* Not even root can pretend to send signals from the kernel.
* Nor can they impersonate a kill()/tgkill(), which adds source info.
*/
if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
(task_pid_vnr(current) != pid)) {
/* We used t... | 130,433,072,147,435,580,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,180 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
{
/* This is only valid for single tasks */
if (pid <= 0 || tgid <= 0)
return -EINVAL;
/* Not even root can pretend to send signals from the kernel.
* Nor can they impersonate a kill()/tgkill(), which adds source info.
*/
if (((... | 92,240,093,995,510,170,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,181 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
bool group)
{
unsigned long flags;
int ret = -ESRCH;
if (lock_task_sighand(p, &flags)) {
ret = send_signal(sig, info, p, group);
unlock_task_sighand(p, &flags);
}
return ret;
}
| 230,995,204,949,913,800,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,182 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
{
struct task_struct *p;
int error = -ESRCH;
rcu_read_lock();
p = find_task_by_vpid(pid);
if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
error = check_kill_permission(sig, info, p);
/*
* The null signal is a permissions and process... | 258,916,160,330,133,300,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,183 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
{
struct task_struct *t = current;
struct k_sigaction *k;
sigset_t mask;
if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
return -EINVAL;
k = &t->sighand->action[sig-1];
spin_lock_irq(¤t->sighand->siglock);
... | 41,472,703,728,891,577,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,184 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int do_sigpending(void *set, unsigned long sigsetsize)
{
if (sigsetsize > sizeof(sigset_t))
return -EINVAL;
spin_lock_irq(¤t->sighand->siglock);
sigorsets(set, ¤t->pending.signal,
¤t->signal->shared_pending.signal);
spin_unlock_irq(¤t->sighand->siglock);
/* Outside the lock b... | 158,686,500,112,837,950,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,185 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void exit_signals(struct task_struct *tsk)
{
int group_stop = 0;
sigset_t unblocked;
/*
* @tsk is about to have PF_EXITING set - lock out users which
* expect stable threadgroup.
*/
threadgroup_change_begin(tsk);
if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
tsk->flags |= PF_EXITING;
... | 183,457,729,498,925,230,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,186 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void flush_itimer_signals(void)
{
struct task_struct *tsk = current;
unsigned long flags;
spin_lock_irqsave(&tsk->sighand->siglock, flags);
__flush_itimer_signals(&tsk->pending);
__flush_itimer_signals(&tsk->signal->shared_pending);
spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
}
| 73,731,187,215,753,760,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,187 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | flush_signal_handlers(struct task_struct *t, int force_default)
{
int i;
struct k_sigaction *ka = &t->sighand->action[0];
for (i = _NSIG ; i != 0 ; i--) {
if (force_default || ka->sa.sa_handler != SIG_IGN)
ka->sa.sa_handler = SIG_DFL;
ka->sa.sa_flags = 0;
#ifdef __ARCH_HAS_SA_RESTORER
ka->sa.sa_restorer = N... | 26,859,041,668,832,530,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,188 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void flush_sigqueue(struct sigpending *queue)
{
struct sigqueue *q;
sigemptyset(&queue->signal);
while (!list_empty(&queue->list)) {
q = list_entry(queue->list.next, struct sigqueue , list);
list_del_init(&q->list);
__sigqueue_free(q);
}
}
| 251,377,299,169,495,000,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,189 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | force_sigsegv(int sig, struct task_struct *p)
{
if (sig == SIGSEGV) {
unsigned long flags;
spin_lock_irqsave(&p->sighand->siglock, flags);
p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
spin_unlock_irqrestore(&p->sighand->siglock, flags);
}
force_sig(SIGSEGV, p);
return 0;
}
| 331,205,520,992,840,500,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,190 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
struct pt_regs *regs, void *cookie)
{
struct sighand_struct *sighand = current->sighand;
struct signal_struct *signal = current->signal;
int signr;
if (unlikely(current->task_works))
task_work_run();
if (unlikely(uprobe_deny_signal(... | 258,949,504,057,665,950,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,191 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
int ret;
rcu_read_lock();
ret = check_kill_permission(sig, info, p);
rcu_read_unlock();
if (!ret && sig)
ret = do_send_sig_info(sig, info, p, true);
return ret;
}
| 104,532,665,187,692,740,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,192 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
{
unsigned long ready;
long i;
switch (_NSIG_WORDS) {
default:
for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
ready |= signal->sig[i] &~ blocked->sig[i];
break;
case 4: ready = signal->sig[3] &~ blocked->sig[3];
ready |= signal->s... | 81,285,972,094,519,570,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,193 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void ignore_signals(struct task_struct *t)
{
int i;
for (i = 0; i < _NSIG; ++i)
t->sighand->action[i].sa.sa_handler = SIG_IGN;
flush_signals(t);
}
| 40,291,041,698,848,844,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,194 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static inline int is_si_special(const struct siginfo *info)
{
return info <= SEND_SIG_FORCED;
}
| 12,494,067,690,069,856,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,195 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int kill_as_cred_perm(const struct cred *cred,
struct task_struct *target)
{
const struct cred *pcred = __task_cred(target);
if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) &&
!uid_eq(cred->uid, pcred->suid) && !uid_eq(cred->uid, pcred->uid))
return 0;
return 1;
}
| 86,296,559,440,047,570,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,196 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int kill_ok_by_cred(struct task_struct *t)
{
const struct cred *cred = current_cred();
const struct cred *tcred = __task_cred(t);
if (uid_eq(cred->euid, tcred->suid) ||
uid_eq(cred->euid, tcred->uid) ||
uid_eq(cred->uid, tcred->suid) ||
uid_eq(cred->uid, tcred->uid))
return 1;
if (ns_ca... | 15,308,330,173,222,056,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,197 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int kill_pgrp(struct pid *pid, int sig, int priv)
{
int ret;
read_lock(&tasklist_lock);
ret = __kill_pgrp_info(sig, __si_special(priv), pid);
read_unlock(&tasklist_lock);
return ret;
}
| 250,787,135,511,152,200,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,198 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int kill_pid(struct pid *pid, int sig, int priv)
{
return kill_pid_info(sig, __si_special(priv), pid);
}
| 11,078,269,201,285,420,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,199 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
const struct cred *cred, u32 secid)
{
int ret = -EINVAL;
struct task_struct *p;
unsigned long flags;
if (!valid_signal(sig))
return ret;
rcu_read_lock();
p = pid_task(pid, PIDTYPE_PID);
if (!p) {
ret = -ESRCH;
goto out_unlock;
... | 173,965,803,937,957,600,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,200 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
{
int error;
rcu_read_lock();
error = kill_pid_info(sig, info, find_vpid(pid));
rcu_read_unlock();
return error;
}
| 127,151,686,305,682,450,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,201 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static inline int legacy_queue(struct sigpending *signals, int sig)
{
return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
}
| 284,010,843,244,860,460,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,202 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static inline int may_ptrace_stop(void)
{
if (!likely(current->ptrace))
return 0;
/*
* Are we in the middle of do_coredump?
* If so and our tracer is also part of the coredump stopping
* is a deadlock situation, and pointless because our tracer
* is dead so don't allow us to stop.
* If SIGKILL was already... | 37,595,249,559,786,310,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,203 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int next_signal(struct sigpending *pending, sigset_t *mask)
{
unsigned long i, *s, *m, x;
int sig = 0;
s = pending->signal.sig;
m = mask->sig;
/*
* Handle the first word specially: it contains the
* synchronous signals that need to be dequeued first.
*/
x = *s &~ *m;
if (x) {
if (x & SYNCHRONOUS_MASK)
... | 258,500,487,065,900,800,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,204 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static void print_fatal_signal(int signr)
{
struct pt_regs *regs = signal_pt_regs();
printk(KERN_INFO "%s/%d: potentially unexpected fatal signal %d.\n",
current->comm, task_pid_nr(current), signr);
#if defined(__i386__) && !defined(__arch_um__)
printk(KERN_INFO "code at %08lx: ", regs->ip);
{
int i;
for (i ... | 202,455,825,540,619,700,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,205 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void ptrace_notify(int exit_code)
{
BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
if (unlikely(current->task_works))
task_work_run();
spin_lock_irq(¤t->sighand->siglock);
ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
spin_unlock_irq(¤t->sighand->siglock);
}
| 286,951,541,406,400,760,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,206 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int ptrace_signal(int signr, siginfo_t *info)
{
ptrace_signal_deliver();
/*
* We do not check sig_kernel_stop(signr) but set this marker
* unconditionally because we do not know whether debugger will
* change signr. This flag has no meaning unless we are going
* to stop after return from ptrace_stop().... | 220,132,358,131,193,000,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,207 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static void ptrace_trap_notify(struct task_struct *t)
{
WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
assert_spin_locked(&t->sighand->siglock);
task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
}
| 190,334,144,291,909,730,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,208 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void recalc_sigpending(void)
{
if (!recalc_sigpending_tsk(current) && !freezing(current))
clear_thread_flag(TIF_SIGPENDING);
}
| 80,482,508,034,022,560,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,209 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void recalc_sigpending_and_wake(struct task_struct *t)
{
if (recalc_sigpending_tsk(t))
signal_wake_up(t, 0);
}
| 179,097,992,429,793,900,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,210 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int recalc_sigpending_tsk(struct task_struct *t)
{
if ((t->jobctl & JOBCTL_PENDING_MASK) ||
PENDING(&t->pending, &t->blocked) ||
PENDING(&t->signal->shared_pending, &t->blocked)) {
set_tsk_thread_flag(t, TIF_SIGPENDING);
return 1;
}
/*
* We must never clear the flag in another thread, or in cu... | 83,373,756,655,711,430,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,211 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int restore_altstack(const stack_t __user *uss)
{
int err = do_sigaltstack(uss, NULL, current_user_stack_pointer());
/* squash all but EFAULT for now */
return err == -EFAULT ? err : 0;
}
| 76,353,904,816,309,650,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,212 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
{
sigset_t retarget;
struct task_struct *t;
sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
if (sigisemptyset(&retarget))
return;
t = tsk;
while_each_thread(tsk, t) {
if (t->flags & PF_EXITING)
continue;
i... | 209,567,960,834,682,440,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,213 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | send_sig(int sig, struct task_struct *p, int priv)
{
return send_sig_info(sig, __si_special(priv), p);
}
| 199,081,714,559,674,050,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,214 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
/*
* Make sure legacy kernel users don't send in bad values
* (normal paths check this in check_kill_permission).
*/
if (!valid_signal(sig))
return -EINVAL;
return do_send_sig_info(sig, info, p, false);
}
| 202,622,760,784,767,560,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,215 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
int group)
{
int from_ancestor_ns = 0;
#ifdef CONFIG_PID_NS
from_ancestor_ns = si_fromuser(info) &&
!task_pid_nr_ns(current, task_active_pid_ns(t));
#endif
return __send_signal(sig, info, t, group, from_ancestor_ns);
}
| 168,003,556,309,873,980,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,216 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
{
int sig = q->info.si_signo;
struct sigpending *pending;
unsigned long flags;
int ret, result;
BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
ret = -1;
if (!likely(lock_task_sighand(t, &flags)))
goto ret;
ret = 1; /* the signal is ignored *... | 289,012,393,753,396,950,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,217 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void set_current_blocked(sigset_t *newset)
{
sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
__set_current_blocked(newset);
}
| 314,464,312,149,621,900,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,218 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static inline bool si_fromuser(const struct siginfo *info)
{
return info == SEND_SIG_NOINFO ||
(!is_si_special(info) && SI_FROMUSER(info));
}
| 293,795,268,952,106,800,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,219 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static void __user *sig_handler(struct task_struct *t, int sig)
{
return t->sighand->action[sig - 1].sa.sa_handler;
}
| 17,576,026,383,642,480,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,220 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int sig_handler_ignored(void __user *handler, int sig)
{
/* Is it explicitly or implicitly ignored? */
return handler == SIG_IGN ||
(handler == SIG_DFL && sig_kernel_ignore(sig));
}
| 289,662,783,852,649,800,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,221 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int sig_task_ignored(struct task_struct *t, int sig, bool force)
{
void __user *handler;
handler = sig_handler(t, sig);
if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
handler == SIG_DFL && !force)
return 1;
return sig_handler_ignored(handler, sig);
}
| 125,810,256,256,911,420,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,222 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static int sigkill_pending(struct task_struct *tsk)
{
return sigismember(&tsk->pending.signal, SIGKILL) ||
sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
}
| 271,404,765,642,867,130,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,223 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void signal_delivered(int sig, siginfo_t *info, struct k_sigaction *ka,
struct pt_regs *regs, int stepping)
{
sigset_t blocked;
/* A signal was successfully delivered, and the
saved sigmask was stored on the signal frame,
and will be restored by sigreturn. So we can
simply clear the restore sigmask f... | 335,875,331,617,413,960,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,224 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void signal_wake_up_state(struct task_struct *t, unsigned int state)
{
set_tsk_thread_flag(t, TIF_SIGPENDING);
/*
* TASK_WAKEKILL also means wake it up in the stopped/traced/killable
* case. We don't check t->state here because there is a race with it
* executing another processor and just now entering stopped ... | 266,834,793,127,473,600,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,225 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void __init signals_init(void)
{
sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
}
| 223,997,839,575,078,900,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,226 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
{
struct task_struct *tsk = current;
sigset_t newset;
/* Lockless, only current can change ->blocked, never from irq */
if (oldset)
*oldset = tsk->blocked;
switch (how) {
case SIG_BLOCK:
sigorsets(&newset, &tsk->blocked, set);
break;
case SIG_UNBL... | 213,086,530,907,657,330,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,227 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | struct sigqueue *sigqueue_alloc(void)
{
struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
if (q)
q->flags |= SIGQUEUE_PREALLOC;
return q;
}
| 312,075,655,016,874,580,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,228 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void sigqueue_free(struct sigqueue *q)
{
unsigned long flags;
spinlock_t *lock = ¤t->sighand->siglock;
BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
/*
* We must hold ->siglock while testing q->list
* to serialize with collect_signal() or with
* __exit_signal()->flush_sigqueue().
*/
spin_lock_irqsave(loc... | 109,651,572,255,070,470,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,229 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int sigsuspend(sigset_t *set)
{
current->saved_sigmask = current->blocked;
set_current_blocked(set);
current->state = TASK_INTERRUPTIBLE;
schedule();
set_restore_sigmask();
return -ERESTARTNOHAND;
}
| 236,283,463,492,674,500,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,230 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
{
return send_signal(sig, info, t, 0);
}
| 42,574,163,690,244,630,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,231 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | void task_clear_jobctl_trapping(struct task_struct *task)
{
if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
task->jobctl &= ~JOBCTL_TRAPPING;
wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
}
}
| 145,598,361,100,031,550,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,232 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static bool task_participate_group_stop(struct task_struct *task)
{
struct signal_struct *sig = task->signal;
bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
if (!consume)
return false;
if (!WARN_ON... | 339,888,633,414,960,240,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,233 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | bool task_set_jobctl_pending(struct task_struct *task, unsigned int mask)
{
BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)... | 309,763,633,881,842,850,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,234 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | unblock_all_signals(void)
{
unsigned long flags;
spin_lock_irqsave(¤t->sighand->siglock, flags);
current->notifier = NULL;
current->notifier_data = NULL;
recalc_sigpending();
spin_unlock_irqrestore(¤t->sighand->siglock, flags);
}
| 15,700,204,271,652,636,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,235 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | int unhandled_signal(struct task_struct *tsk, int sig)
{
void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
if (is_global_init(tsk))
return 1;
if (handler != SIG_IGN && handler != SIG_DFL)
return 0;
/* if ptraced, let the tracer determine */
return !tsk->ptrace;
}
| 49,785,547,049,592,090,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,236 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
{
if (current_user_ns() == task_cred_xxx(t, user_ns))
return;
if (SI_FROMKERNEL(info))
return;
rcu_read_lock();
info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
make_kuid(current_user_ns(), info->si_uid));
... | 196,588,336,884,352,300,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,237 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
{
return;
}
| 40,879,899,596,921,577,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,238 | linux | b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f | kernel/signal.c: stop info leak via the tkill and the tgkill syscalls
This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.
This is visible in the siginfo_t->_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.
The place of the infoleak:
int ... | 0 | static inline int wants_signal(int sig, struct task_struct *p)
{
if (sigismember(&p->blocked, sig))
return 0;
if (p->flags & PF_EXITING)
return 0;
if (sig == SIGKILL)
return 1;
if (task_is_stopped_or_traced(p))
return 0;
return task_curr(p) || !signal_pending(p);
}
| 128,970,250,823,925,830,000,000,000,000,000,000,000 | signal.c | 43,790,563,659,993,175,000,000,000,000,000,000,000 | [
"CWE-399"
] | CVE-2013-2141 | The do_tkill function in kernel/signal.c in the Linux kernel before 3.8.9 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via a crafted application that makes a (1) tkill or (2) tgkill system call. | https://nvd.nist.gov/vuln/detail/CVE-2013-2141 |
33,239 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | __do_block_io_op(struct xen_blkif *blkif)
{
union blkif_back_rings *blk_rings = &blkif->blk_rings;
struct blkif_request req;
struct pending_req *pending_req;
RING_IDX rc, rp;
int more_to_do = 0;
rc = blk_rings->common.req_cons;
rp = blk_rings->common.sring->req_prod;
rmb(); /* Ensure we see queued requests up ... | 27,895,595,184,634,950,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,240 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static void __end_block_io_op(struct pending_req *pending_req, int error)
{
/* An error fails the entire request. */
if ((pending_req->operation == BLKIF_OP_FLUSH_DISKCACHE) &&
(error == -EOPNOTSUPP)) {
pr_debug(DRV_PFX "flush diskcache op failed, not supported\n");
xen_blkbk_flush_diskcache(XBT_NIL, pending... | 145,427,404,674,056,400,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,241 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static int add_persistent_gnt(struct xen_blkif *blkif,
struct persistent_gnt *persistent_gnt)
{
struct rb_node **new = NULL, *parent = NULL;
struct persistent_gnt *this;
if (blkif->persistent_gnt_c >= xen_blkif_max_pgrants) {
if (!blkif->vbd.overflow_max_grants)
blkif->vbd.overflow_max_grants = 1;
... | 36,396,893,799,773,498,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,242 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static struct pending_req *alloc_req(struct xen_blkif *blkif)
{
struct pending_req *req = NULL;
unsigned long flags;
spin_lock_irqsave(&blkif->pending_free_lock, flags);
if (!list_empty(&blkif->pending_free)) {
req = list_entry(blkif->pending_free.next, struct pending_req,
free_list);
list_del(&req->free_... | 301,978,682,966,179,730,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,243 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static void blkif_notify_work(struct xen_blkif *blkif)
{
blkif->waiting_reqs = 1;
wake_up(&blkif->wq);
}
| 57,515,771,673,032,600,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,244 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static int dispatch_other_io(struct xen_blkif *blkif,
struct blkif_request *req,
struct pending_req *pending_req)
{
free_req(blkif, pending_req);
make_response(blkif, req->u.other.id, req->operation,
BLKIF_RSP_EOPNOTSUPP);
return -EIO;
}
| 83,415,563,016,500,920,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,245 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static int dispatch_rw_block_io(struct xen_blkif *blkif,
struct blkif_request *req,
struct pending_req *pending_req)
{
struct phys_req preq;
struct seg_buf *seg = pending_req->seg;
unsigned int nseg;
struct bio *bio = NULL;
struct bio **biolist = pending_req->biolist;
int i, nbio = 0;
int operation;
str... | 286,474,280,266,083,060,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,246 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | do_block_io_op(struct xen_blkif *blkif)
{
union blkif_back_rings *blk_rings = &blkif->blk_rings;
int more_to_do;
do {
more_to_do = __do_block_io_op(blkif);
if (more_to_do)
break;
RING_FINAL_CHECK_FOR_REQUESTS(&blk_rings->common, more_to_do);
} while (more_to_do);
return more_to_do;
}
| 7,352,234,745,290,501,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,247 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static void end_block_io_op(struct bio *bio, int error)
{
__end_block_io_op(bio->bi_private, error);
bio_put(bio);
}
| 329,167,220,758,443,980,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,248 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static void free_persistent_gnts(struct xen_blkif *blkif, struct rb_root *root,
unsigned int num)
{
struct gnttab_unmap_grant_ref unmap[BLKIF_MAX_SEGMENTS_PER_REQUEST];
struct page *pages[BLKIF_MAX_SEGMENTS_PER_REQUEST];
struct persistent_gnt *persistent_gnt;
struct rb_node *n;
int... | 336,588,487,727,941,940,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,249 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static void free_req(struct xen_blkif *blkif, struct pending_req *req)
{
unsigned long flags;
int was_empty;
spin_lock_irqsave(&blkif->pending_free_lock, flags);
was_empty = list_empty(&blkif->pending_free);
list_add(&req->free_list, &blkif->pending_free);
spin_unlock_irqrestore(&blkif->pending_free_lock, flags)... | 232,018,454,281,345,480,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,250 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static inline int get_free_page(struct xen_blkif *blkif, struct page **page)
{
unsigned long flags;
spin_lock_irqsave(&blkif->free_pages_lock, flags);
if (list_empty(&blkif->free_pages)) {
BUG_ON(blkif->free_pages_num != 0);
spin_unlock_irqrestore(&blkif->free_pages_lock, flags);
return alloc_xenballooned_pag... | 125,900,817,270,758,680,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,251 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static struct persistent_gnt *get_persistent_gnt(struct xen_blkif *blkif,
grant_ref_t gref)
{
struct persistent_gnt *data;
struct rb_node *node = NULL;
node = blkif->persistent_gnts.rb_node;
while (node) {
data = container_of(node, struct persistent_gnt, node);
if (gref < data->gnt)
node = node->rb_... | 88,225,631,981,573,060,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,252 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static void print_stats(struct xen_blkif *blkif)
{
pr_info("xen-blkback (%s): oo %3llu | rd %4llu | wr %4llu | f %4llu"
" | ds %4llu | pg: %4u/%4d\n",
current->comm, blkif->st_oo_req,
blkif->st_rd_req, blkif->st_wr_req,
blkif->st_f_req, blkif->st_ds_req,
blkif->persistent_gnt_c,
xen_blkif_max... | 92,368,810,020,608,060,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,253 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static void purge_persistent_gnt(struct xen_blkif *blkif)
{
struct persistent_gnt *persistent_gnt;
struct rb_node *n;
unsigned int num_clean, total;
bool scan_used = false;
struct rb_root *root;
if (blkif->persistent_gnt_c < xen_blkif_max_pgrants ||
(blkif->persistent_gnt_c == xen_blkif_max_pgrants &&
... | 320,078,549,310,581,160,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,254 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static inline void put_free_pages(struct xen_blkif *blkif, struct page **page,
int num)
{
unsigned long flags;
int i;
spin_lock_irqsave(&blkif->free_pages_lock, flags);
for (i = 0; i < num; i++)
list_add(&page[i]->lru, &blkif->free_pages);
blkif->free_pages_num += num;
spin_un... | 322,443,793,114,158,340,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,255 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static void put_persistent_gnt(struct xen_blkif *blkif,
struct persistent_gnt *persistent_gnt)
{
if(!test_bit(PERSISTENT_GNT_ACTIVE, persistent_gnt->flags))
pr_alert_ratelimited(DRV_PFX " freeing a grant already unused");
set_bit(PERSISTENT_GNT_WAS_ACTIVE, persistent_gnt->fla... | 316,746,623,188,599,900,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,256 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static inline void shrink_free_pagepool(struct xen_blkif *blkif, int num)
{
/* Remove requested pages in batches of NUM_BATCH_FREE_PAGES */
struct page *page[NUM_BATCH_FREE_PAGES];
unsigned int num_pages = 0;
unsigned long flags;
spin_lock_irqsave(&blkif->free_pages_lock, flags);
while (blkif->free_pages_num > n... | 69,721,260,812,476,330,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,257 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static void unmap_purged_grants(struct work_struct *work)
{
struct gnttab_unmap_grant_ref unmap[BLKIF_MAX_SEGMENTS_PER_REQUEST];
struct page *pages[BLKIF_MAX_SEGMENTS_PER_REQUEST];
struct persistent_gnt *persistent_gnt;
int ret, segs_to_unmap = 0;
struct xen_blkif *blkif = container_of(work, typeof(*blkif), persis... | 146,759,478,633,309,430,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,258 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static void xen_blk_drain_io(struct xen_blkif *blkif)
{
atomic_set(&blkif->drain, 1);
do {
/* The initial value is one, and one refcnt taken at the
* start of the xen_blkif_schedule thread. */
if (atomic_read(&blkif->refcnt) <= 2)
break;
wait_for_completion_interruptible_timeout(
&blkif->drain_complet... | 40,361,819,348,721,947,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,259 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static int xen_blkbk_map(struct xen_blkif *blkif,
struct grant_page *pages[],
int num, bool ro)
{
struct gnttab_map_grant_ref map[BLKIF_MAX_SEGMENTS_PER_REQUEST];
struct page *pages_to_gnt[BLKIF_MAX_SEGMENTS_PER_REQUEST];
struct persistent_gnt *persistent_gnt = NULL;
phys_addr_t addr = 0;
int i, seg_idx, n... | 159,204,236,601,967,350,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,260 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static int xen_blkbk_map_seg(struct pending_req *pending_req)
{
int rc;
rc = xen_blkbk_map(pending_req->blkif, pending_req->segments,
pending_req->nr_pages,
(pending_req->operation != BLKIF_OP_READ));
return rc;
}
| 62,423,962,029,680,760,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,261 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static void xen_blkbk_unmap(struct xen_blkif *blkif,
struct grant_page *pages[],
int num)
{
struct gnttab_unmap_grant_ref unmap[BLKIF_MAX_SEGMENTS_PER_REQUEST];
struct page *unmap_pages[BLKIF_MAX_SEGMENTS_PER_REQUEST];
unsigned int i, invcount = 0;
int ret;
... | 43,362,831,905,889,500,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
33,262 | linux | 604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/604c499cbbcc3d5fe5fb8d53306aa0fae1990109 | xen/blkback: Check device permissions before allowing OP_DISCARD
We need to make sure that the device is not RO or that
the request is not past the number of sectors we want to
issue the DISCARD operation for.
This fixes CVE-2013-2140.
Cc: stable@vger.kernel.org
Acked-by: Jan Beulich <JBeulich@suse.com>
Acked-by: Ia... | 0 | static void xen_vbd_resize(struct xen_blkif *blkif)
{
struct xen_vbd *vbd = &blkif->vbd;
struct xenbus_transaction xbt;
int err;
struct xenbus_device *dev = xen_blkbk_xenbus(blkif->be);
unsigned long long new_size = vbd_sz(vbd);
pr_info(DRV_PFX "VBD Resize: Domid: %d, Device: (%d, %d)\n",
blkif->domid, MAJOR(v... | 67,395,115,950,724,150,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2013-2140 | The dispatch_discard_io function in drivers/block/xen-blkback/blkback.c in the Xen blkback implementation in the Linux kernel before 3.10.5 allows guest OS users to cause a denial of service (data loss) via filesystem write operations on a read-only disk that supports the (1) BLKIF_OP_DISCARD (aka discard or TRIM) or (... | https://nvd.nist.gov/vuln/detail/CVE-2013-2140 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.