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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
38,683 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | add_options(opt)
option_t *opt;
{
struct option_list *list;
list = malloc(sizeof(*list));
if (list == 0)
novm("option list entry");
list->options = opt;
list->next = extra_options;
extra_options = list;
}
| 145,005,605,221,919,570,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,684 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | callfile(argv)
char **argv;
{
char *fname, *arg, *p;
int l, ok;
arg = *argv;
ok = 1;
if (arg[0] == '/' || arg[0] == 0)
ok = 0;
else {
for (p = arg; *p != 0; ) {
if (p[0] == '.' && p[1] == '.' && (p[2] == '/' || p[2] == 0)) {
ok = 0;
break;
}
while (*p != '/' && *p != 0)... | 53,480,223,036,934,500,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,685 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | check_options()
{
if (logfile_fd >= 0 && logfile_fd != log_to_fd)
close(logfile_fd);
}
| 211,630,898,269,825,300,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,686 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | find_option(name)
const char *name;
{
option_t *opt;
struct option_list *list;
int i, dowild;
for (dowild = 0; dowild <= 1; ++dowild) {
for (opt = general_options; opt->name != NULL; ++opt)
if (match_option(name, opt, dowild))
return opt;
for (opt = auth_options; opt->name != NULL; ++opt)
if (mat... | 276,196,743,170,107,080,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,687 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | int_option(str, valp)
char *str;
int *valp;
{
u_int32_t v;
if (!number_option(str, &v, 0))
return 0;
*valp = (int) v;
return 1;
}
| 324,810,759,829,910,840,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,688 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | loadplugin(argv)
char **argv;
{
char *arg = *argv;
void *handle;
const char *err;
void (*init) __P((void));
char *path = arg;
const char *vers;
if (strchr(arg, '/') == 0) {
const char *base = _PATH_PLUGIN;
int l = strlen(base) + strlen(arg) + 2;
path = malloc(l);
if (path == 0)
... | 64,107,258,828,867,565,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,689 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | match_option(name, opt, dowild)
char *name;
option_t *opt;
int dowild;
{
int (*match) __P((char *, char **, int));
if (dowild != (opt->type == o_wild))
return 0;
if (!dowild)
return strcmp(name, opt->name) == 0;
match = (int (*) __P((char *, char **, int))) opt->addr;
return (*match)(name, NULL, 0... | 114,446,354,260,074,430,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,690 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | n_arguments(opt)
option_t *opt;
{
return (opt->type == o_bool || opt->type == o_special_noarg
|| (opt->flags & OPT_NOARG))? 0: 1;
}
| 208,723,045,463,831,440,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,691 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | number_option(str, valp, base)
char *str;
u_int32_t *valp;
int base;
{
char *ptr;
*valp = strtoul(str, &ptr, base);
if (ptr == str) {
option_error("invalid numeric parameter '%s' for %s option",
str, current_option);
return 0;
}
return 1;
}
| 290,462,461,273,323,050,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,692 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | options_for_tty()
{
char *dev, *path, *p;
int ret;
size_t pl;
dev = devnam;
if ((p = strstr(dev, "/dev/")) != NULL)
dev = p + 5;
if (dev[0] == 0 || strcmp(dev, "tty") == 0)
return 1; /* don't look for /etc/ppp/options.tty */
pl = strlen(_PATH_TTYOPT) + strlen(dev) + 1;
path = malloc(... | 233,392,643,084,752,750,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,693 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | options_from_file(filename, must_exist, check_prot, priv)
char *filename;
int must_exist;
int check_prot;
int priv;
{
FILE *f;
int i, newline, ret, err;
option_t *opt;
int oldpriv, n;
char *oldsource;
uid_t euid;
char *argv[MAXARGS];
char args[MAXARGS][MAXWORDLEN];
ch... | 291,525,439,595,065,980,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,694 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | options_from_list(w, priv)
struct wordlist *w;
int priv;
{
char *argv[MAXARGS];
option_t *opt;
int i, n, ret = 0;
struct wordlist *w0;
privileged_option = priv;
option_source = "secrets file";
option_priority = OPRIO_SECFILE;
while (w != NULL) {
opt = find_option(w->word);
if... | 201,141,447,337,290,750,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,695 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | options_from_user()
{
char *user, *path, *file;
int ret;
struct passwd *pw;
size_t pl;
pw = getpwuid(getuid());
if (pw == NULL || (user = pw->pw_dir) == NULL || user[0] == 0)
return 1;
file = _PATH_USEROPT;
pl = strlen(user) + strlen(file) + 2;
path = malloc(pl);
if (path == NU... | 148,864,294,945,563,030,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,696 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | override_value(option, priority, source)
const char *option;
int priority;
const char *source;
{
option_t *opt;
opt = find_option(option);
if (opt == NULL)
return 0;
while (opt->flags & OPT_PRIOSUB)
--opt;
if ((opt->flags & OPT_PRIO) && priority < opt->priority)
return 0;
opt->priority = priori... | 267,074,195,890,658,740,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,697 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | parse_args(argc, argv)
int argc;
char **argv;
{
char *arg;
option_t *opt;
int n;
privileged_option = privileged;
option_source = "command line";
option_priority = OPRIO_CMDLINE;
while (argc > 0) {
arg = *argv++;
--argc;
opt = find_option(arg);
if (opt == NULL) {
option_erro... | 148,648,550,315,274,480,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,698 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | print_option(opt, mainopt, printer, arg)
option_t *opt, *mainopt;
printer_func printer;
void *arg;
{
int i, v;
char *p;
if (opt->flags & OPT_NOPRINT)
return;
switch (opt->type) {
case o_bool:
v = opt->flags & OPT_VALUE;
if (*(bool *)opt->addr != v)
/* this can happen legitimately, e.g. lock
... | 234,563,601,174,433,140,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,699 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | print_option_list(opt, printer, arg)
option_t *opt;
printer_func printer;
void *arg;
{
while (opt->name != NULL) {
if (opt->priority != OPRIO_DEFAULT
&& opt->winner != (short int) -1)
print_option(opt + opt->winner, opt, printer, arg);
do {
++opt;
} while (opt->flags & OPT_PRIOSUB);
}
}
| 297,618,949,588,363,130,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,700 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | print_options(printer, arg)
printer_func printer;
void *arg;
{
struct option_list *list;
int i;
printer(arg, "pppd options in effect:\n");
print_option_list(general_options, printer, arg);
print_option_list(auth_options, printer, arg);
for (list = extra_options; list != NULL; list = list->next)
print_o... | 246,284,152,052,658,950,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,701 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | process_option(opt, cmd, argv)
option_t *opt;
char *cmd;
char **argv;
{
u_int32_t v;
int iv, a;
char *sv;
int (*parser) __P((char **));
int (*wildp) __P((char *, char **, int));
char *optopt = (opt->type == o_wild)? "": " option";
int prio = option_priority;
option_t *mainopt... | 316,327,236,054,042,620,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,702 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | readfile(argv)
char **argv;
{
return options_from_file(*argv, 1, 1, privileged_option);
}
| 71,233,049,170,646,300,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,703 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | setactivefilter(argv)
char **argv;
{
pcap_t *pc;
int ret = 1;
pc = pcap_open_dead(DLT_PPP_PPPD, 65535);
if (pcap_compile(pc, &active_filter, *argv, 1, netmask) == -1) {
option_error("error in active-filter expression: %s\n",
pcap_geterr(pc));
ret = 0;
}
pcap_close(pc);
return ... | 40,377,091,105,314,495,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,704 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | setdomain(argv)
char **argv;
{
gethostname(hostname, MAXNAMELEN);
if (**argv != 0) {
if (**argv != '.')
strncat(hostname, ".", MAXNAMELEN - strlen(hostname));
domain = hostname + strlen(hostname);
strncat(hostname, *argv, MAXNAMELEN - strlen(hostname));
}
hostname[MAXNAMELEN-1] = 0;
retu... | 121,381,306,535,987,700,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,705 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | setmodir(argv)
char **argv;
{
if(*argv == NULL)
return 0;
if(!strcmp(*argv,"in")) {
maxoctets_dir = PPP_OCTETS_DIRECTION_IN;
} else if (!strcmp(*argv,"out")) {
maxoctets_dir = PPP_OCTETS_DIRECTION_OUT;
} else if (!strcmp(*argv,"max")) {
maxoctets_dir = PPP_OCTETS_DIRECTION_M... | 186,771,920,723,842,460,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,706 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | setpassfilter(argv)
char **argv;
{
pcap_t *pc;
int ret = 1;
pc = pcap_open_dead(DLT_PPP_PPPD, 65535);
if (pcap_compile(pc, &pass_filter, *argv, 1, netmask) == -1) {
option_error("error in pass-filter expression: %s\n",
pcap_geterr(pc));
ret = 0;
}
pcap_close(pc);
return ret;
}... | 313,587,349,845,951,760,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,707 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | showversion(argv)
char **argv;
{
if (phase == PHASE_INITIALIZE) {
fprintf(stderr, "pppd version %s\n", VERSION);
exit(0);
}
return 0;
}
| 276,926,453,620,169,680,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,708 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | user_setenv(argv)
char **argv;
{
char *arg = argv[0];
char *eqp;
struct userenv *uep, **insp;
if ((eqp = strchr(arg, '=')) == NULL) {
option_error("missing = in name=value: %s", arg);
return 0;
}
if (eqp == arg) {
option_error("missing variable name: %s", arg);
return 0;
}
for (... | 265,147,464,961,805,350,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,709 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | user_setprint(opt, printer, arg)
option_t *opt;
printer_func printer;
void *arg;
{
struct userenv *uep, *uepnext;
uepnext = userenv_list;
while (uepnext != NULL && !uepnext->ue_isset)
uepnext = uepnext->ue_next;
while ((uep = uepnext) != NULL) {
uepnext = uep->ue_next;
while (uepnext != ... | 31,360,998,582,139,290,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,710 | ppp | 7658e8257183f062dc01f87969c140707c7e52cb | https://github.com/paulusmack/ppp | https://github.com/paulusmack/ppp/commit/7658e8257183f062dc01f87969c140707c7e52cb | pppd: Eliminate potential integer overflow in option parsing
When we are reading in a word from an options file, we maintain a count
of the length we have seen so far in 'len', which is an int. When len
exceeds MAXWORDLEN - 1 (i.e. 1023) we cease storing characters in the
buffer but we continue to increment len. Sin... | 0 | user_unsetenv(argv)
char **argv;
{
struct userenv *uep, **insp;
char *arg = argv[0];
if (strchr(arg, '=') != NULL) {
option_error("unexpected = in name: %s", arg);
return 0;
}
if (arg == '\0') {
option_error("missing variable name for unset");
return 0;
}
for (uep = userenv_list; ue... | 105,242,871,164,143,780,000,000,000,000,000,000,000 | options.c | 308,269,249,332,257,800,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-3158 | Integer overflow in the getword function in options.c in pppd in Paul's PPP Package (ppp) before 2.4.7 allows attackers to "access privileged options" via a long word in an options file, which triggers a heap-based buffer overflow that "[corrupts] security-relevant variables." | https://nvd.nist.gov/vuln/detail/CVE-2014-3158 |
38,711 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,
size_t, len)
{
if (!futex_cmpxchg_enabled)
return -ENOSYS;
/*
* The kernel knows only one size for now:
*/
if (unlikely(len != sizeof(*head)))
return -EINVAL;
current->robust_list = head;
return 0;
}
| 327,444,485,595,225,970,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,712 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | SYSCALL_DEFINE3(get_robust_list, int, pid,
struct robust_list_head __user * __user *, head_ptr,
size_t __user *, len_ptr)
{
struct robust_list_head __user *head;
unsigned long ret;
struct task_struct *p;
if (!futex_cmpxchg_enabled)
return -ENOSYS;
rcu_read_lock();
ret = -ESRCH;
if (!pid)
p = current;
... | 245,325,650,619,783,800,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,713 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | SYSCALL_DEFINE6(futex, u32 __user *, uaddr, int, op, u32, val,
struct timespec __user *, utime, u32 __user *, uaddr2,
u32, val3)
{
struct timespec ts;
ktime_t t, *tp = NULL;
u32 val2 = 0;
int cmd = op & FUTEX_CMD_MASK;
if (utime && (cmd == FUTEX_WAIT || cmd == FUTEX_LOCK_PI ||
cmd == FUTEX_WAIT_BITSET... | 91,196,335,112,507,920,000,000,000,000,000,000,000 | futex.c | 161,006,216,331,975,570,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,714 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static void __unqueue_futex(struct futex_q *q)
{
struct futex_hash_bucket *hb;
if (WARN_ON_SMP(!q->lock_ptr || !spin_is_locked(q->lock_ptr))
|| WARN_ON(plist_node_empty(&q->list)))
return;
hb = container_of(q->lock_ptr, struct futex_hash_bucket, lock);
plist_del(&q->list, &hb->chain);
hb_waiters_dec(hb);
... | 133,515,357,548,570,620,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,715 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static struct futex_pi_state * alloc_pi_state(void)
{
struct futex_pi_state *pi_state = current->pi_state_cache;
WARN_ON(!pi_state);
current->pi_state_cache = NULL;
return pi_state;
}
| 252,347,753,041,249,040,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,716 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int cmpxchg_futex_value_locked(u32 *curval, u32 __user *uaddr,
u32 uval, u32 newval)
{
int ret;
pagefault_disable();
ret = futex_atomic_cmpxchg_inatomic(curval, uaddr, uval, newval);
pagefault_enable();
return ret;
}
| 89,170,876,823,410,710,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,717 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
u32 __user *uaddr2, u32 val2, u32 val3)
{
int cmd = op & FUTEX_CMD_MASK;
unsigned int flags = 0;
if (!(op & FUTEX_PRIVATE_FLAG))
flags |= FLAGS_SHARED;
if (op & FUTEX_CLOCK_REALTIME) {
flags |= FLAGS_CLOCKRT;
if (cmd != FUTEX_WAIT_BITSET ... | 214,934,534,338,375,060,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,718 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | double_lock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
{
if (hb1 <= hb2) {
spin_lock(&hb1->lock);
if (hb1 < hb2)
spin_lock_nested(&hb2->lock, SINGLE_DEPTH_NESTING);
} else { /* hb1 > hb2 */
spin_lock(&hb2->lock);
spin_lock_nested(&hb1->lock, SINGLE_DEPTH_NESTING);
}
}
| 8,473,719,177,391,891,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,719 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | double_unlock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
{
spin_unlock(&hb1->lock);
if (hb1 != hb2)
spin_unlock(&hb2->lock);
}
| 185,011,634,045,747,230,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,720 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static void drop_futex_key_refs(union futex_key *key)
{
if (!key->both.ptr) {
/* If we're here then we tried to put a key we failed to get */
WARN_ON_ONCE(1);
return;
}
switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
case FUT_OFF_INODE:
iput(key->shared.inode);
break;
case FUT_OFF_MMSHARE... | 35,172,471,904,731,187,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,721 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | void exit_pi_state_list(struct task_struct *curr)
{
struct list_head *next, *head = &curr->pi_state_list;
struct futex_pi_state *pi_state;
struct futex_hash_bucket *hb;
union futex_key key = FUTEX_KEY_INIT;
if (!futex_cmpxchg_enabled)
return;
/*
* We are a ZOMBIE and nobody can enqueue itself on
* pi_state... | 267,733,876,410,441,330,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,722 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | void exit_robust_list(struct task_struct *curr)
{
struct robust_list_head __user *head = curr->robust_list;
struct robust_list __user *entry, *next_entry, *pending;
unsigned int limit = ROBUST_LIST_LIMIT, pi, pip;
unsigned int uninitialized_var(next_pi);
unsigned long futex_offset;
int rc;
if (!futex_cmpxchg_en... | 107,532,997,108,262,100,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,723 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int fault_in_user_writeable(u32 __user *uaddr)
{
struct mm_struct *mm = current->mm;
int ret;
down_read(&mm->mmap_sem);
ret = fixup_user_fault(current, mm, (unsigned long)uaddr,
FAULT_FLAG_WRITE);
up_read(&mm->mmap_sem);
return ret < 0 ? ret : 0;
}
| 196,005,436,889,259,750,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,724 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static inline int fetch_robust_entry(struct robust_list __user **entry,
struct robust_list __user * __user *head,
unsigned int *pi)
{
unsigned long uentry;
if (get_user(uentry, (unsigned long __user *)head))
return -EFAULT;
*entry = (void __user *)(uentry & ~1UL);
*pi = uentry & 1;
return 0;... | 184,524,742,186,363,830,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,725 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int fixup_owner(u32 __user *uaddr, struct futex_q *q, int locked)
{
struct task_struct *owner;
int ret = 0;
if (locked) {
/*
* Got the lock. We might not be the anticipated owner if we
* did a lock-steal - fix up the PI-state in that case:
*/
if (q->pi_state->owner != current)
ret = fixup_pi_... | 86,665,294,848,519,230,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,726 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int fixup_pi_state_owner(u32 __user *uaddr, struct futex_q *q,
struct task_struct *newowner)
{
u32 newtid = task_pid_vnr(newowner) | FUTEX_WAITERS;
struct futex_pi_state *pi_state = q->pi_state;
struct task_struct *oldowner = pi_state->owner;
u32 uval, uninitialized_var(curval), newval;
int ret;
/* Ow... | 329,967,037,868,242,950,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,727 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static void free_pi_state(struct futex_pi_state *pi_state)
{
if (!atomic_dec_and_test(&pi_state->refcount))
return;
/*
* If pi_state->owner is NULL, the owner is most probably dying
* and has cleaned up the pi_state already
*/
if (pi_state->owner) {
raw_spin_lock_irq(&pi_state->owner->pi_lock);
list_del... | 160,614,443,693,736,280,000,000,000,000,000,000,000 | futex.c | 161,006,216,331,975,570,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,728 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static inline void futex_get_mm(union futex_key *key)
{
atomic_inc(&key->private.mm->mm_count);
/*
* Ensure futex_get_mm() implies a full barrier such that
* get_futex_key() implies a full barrier. This is relied upon
* as full barrier (B), see the ordering comment above.
*/
smp_mb__after_atomic_inc();
}
| 16,939,289,511,786,812,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,729 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int __init futex_init(void)
{
unsigned int futex_shift;
unsigned long i;
#if CONFIG_BASE_SMALL
futex_hashsize = 16;
#else
futex_hashsize = roundup_pow_of_two(256 * num_possible_cpus());
#endif
futex_queues = alloc_large_system_hash("futex", sizeof(*futex_queues),
futex_hashsize, 0,
... | 203,701,508,844,673,640,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,730 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int futex_lock_pi(u32 __user *uaddr, unsigned int flags, int detect,
ktime_t *time, int trylock)
{
struct hrtimer_sleeper timeout, *to = NULL;
struct futex_hash_bucket *hb;
struct futex_q q = futex_q_init;
int res, ret;
if (refill_pi_state_cache())
return -ENOMEM;
if (time) {
to = &timeout;
hrt... | 99,072,957,365,105,640,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,731 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int futex_lock_pi_atomic(u32 __user *uaddr, struct futex_hash_bucket *hb,
union futex_key *key,
struct futex_pi_state **ps,
struct task_struct *task, int set_waiters)
{
int lock_taken, ret, force_take = 0;
u32 uval, newval, curval, vpid = task_pid_vnr(task);
retry:
ret = lock_taken = 0;
/*
* ... | 269,040,780,171,290,900,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,732 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int futex_proxy_trylock_atomic(u32 __user *pifutex,
struct futex_hash_bucket *hb1,
struct futex_hash_bucket *hb2,
union futex_key *key1, union futex_key *key2,
struct futex_pi_state **ps, int set_waiters)
{
struct futex_q *top_waiter = NULL;
u32 curval;
int ret, vpid;
if (get_futex_value... | 204,609,488,065,622,770,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,733 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static struct futex_q *futex_top_waiter(struct futex_hash_bucket *hb,
union futex_key *key)
{
struct futex_q *this;
plist_for_each_entry(this, &hb->chain, list) {
if (match_futex(&this->key, key))
return this;
}
return NULL;
}
| 302,632,924,804,240,850,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,734 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int futex_unlock_pi(u32 __user *uaddr, unsigned int flags)
{
struct futex_hash_bucket *hb;
struct futex_q *this, *next;
union futex_key key = FUTEX_KEY_INIT;
u32 uval, vpid = task_pid_vnr(current);
int ret;
retry:
if (get_user(uval, uaddr))
return -EFAULT;
/*
* We release only a lock we actually own:... | 212,556,207,672,617,000,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,735 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int futex_wait(u32 __user *uaddr, unsigned int flags, u32 val,
ktime_t *abs_time, u32 bitset)
{
struct hrtimer_sleeper timeout, *to = NULL;
struct restart_block *restart;
struct futex_hash_bucket *hb;
struct futex_q q = futex_q_init;
int ret;
if (!bitset)
return -EINVAL;
q.bitset = bitset;
if... | 118,340,321,294,416,280,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,736 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static void futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q,
struct hrtimer_sleeper *timeout)
{
/*
* The task state is guaranteed to be set before another task can
* wake it. set_current_state() is implemented using set_mb() and
* queue_me() calls spin_unlock() upon completion, both seria... | 25,575,391,638,907,445,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,737 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static long futex_wait_restart(struct restart_block *restart)
{
u32 __user *uaddr = restart->futex.uaddr;
ktime_t t, *tp = NULL;
if (restart->futex.flags & FLAGS_HAS_TIMEOUT) {
t.tv64 = restart->futex.time;
tp = &t;
}
restart->fn = do_no_restart_syscall;
return (long)futex_wait(uaddr, restart->futex.flags,
... | 35,319,962,833,898,457,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,738 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int futex_wait_setup(u32 __user *uaddr, u32 val, unsigned int flags,
struct futex_q *q, struct futex_hash_bucket **hb)
{
u32 uval;
int ret;
/*
* Access the page AFTER the hash-bucket is locked.
* Order is important:
*
* Userspace waiter: val = var; if (cond(val)) futex_wait(&var, val);
* ... | 188,941,929,171,538,300,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,739 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | futex_wake_op(u32 __user *uaddr1, unsigned int flags, u32 __user *uaddr2,
int nr_wake, int nr_wake2, int op)
{
union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
struct futex_hash_bucket *hb1, *hb2;
struct futex_q *this, *next;
int ret, op_ret;
retry:
ret = get_futex_key(uaddr1, flags & FLAGS_SH... | 37,427,385,509,722,150,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,740 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | get_futex_key(u32 __user *uaddr, int fshared, union futex_key *key, int rw)
{
unsigned long address = (unsigned long)uaddr;
struct mm_struct *mm = current->mm;
struct page *page, *page_head;
int err, ro = 0;
/*
* The futex address must be "naturally" aligned.
*/
key->both.offset = address % PAGE_SIZE;
if (u... | 213,438,030,487,812,500,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,741 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static void get_futex_key_refs(union futex_key *key)
{
if (!key->both.ptr)
return;
switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
case FUT_OFF_INODE:
ihold(key->shared.inode); /* implies MB (B) */
break;
case FUT_OFF_MMSHARED:
futex_get_mm(key); /* implies MB (B) */
break;
}
}
| 274,295,810,261,950,670,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,742 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int get_futex_value_locked(u32 *dest, u32 __user *from)
{
int ret;
pagefault_disable();
ret = __copy_from_user_inatomic(dest, from, sizeof(u32));
pagefault_enable();
return ret ? -EFAULT : 0;
}
| 80,259,670,348,628,530,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,743 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | int handle_early_requeue_pi_wakeup(struct futex_hash_bucket *hb,
struct futex_q *q, union futex_key *key2,
struct hrtimer_sleeper *timeout)
{
int ret = 0;
/*
* With the hb lock held, we avoid races while we process the wakeup.
* We only need to hold hb (and not hb2) to ensure atomicity as the
* w... | 71,458,938,905,388,960,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,744 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | int handle_futex_death(u32 __user *uaddr, struct task_struct *curr, int pi)
{
u32 uval, uninitialized_var(nval), mval;
retry:
if (get_user(uval, uaddr))
return -1;
if ((uval & FUTEX_TID_MASK) == task_pid_vnr(curr)) {
/*
* Ok, this dying thread is truly holding a futex
* of interest. Set the OWNER_DIED bi... | 194,789,717,426,443,740,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,745 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static inline void hb_waiters_dec(struct futex_hash_bucket *hb)
{
#ifdef CONFIG_SMP
atomic_dec(&hb->waiters);
#endif
}
| 295,803,486,926,040,800,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,746 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static inline void hb_waiters_inc(struct futex_hash_bucket *hb)
{
#ifdef CONFIG_SMP
atomic_inc(&hb->waiters);
/*
* Full barrier (A), see the ordering comment above.
*/
smp_mb__after_atomic_inc();
#endif
}
| 45,636,850,835,796,310,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,747 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | lookup_pi_state(u32 uval, struct futex_hash_bucket *hb,
union futex_key *key, struct futex_pi_state **ps,
struct task_struct *task)
{
struct futex_pi_state *pi_state = NULL;
struct futex_q *this, *next;
struct task_struct *p;
pid_t pid = uval & FUTEX_TID_MASK;
plist_for_each_entry_safe(this, next, &hb->chain,... | 79,292,263,797,697,360,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,748 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static inline void put_futex_key(union futex_key *key)
{
drop_futex_key_refs(key);
}
| 56,026,969,882,729,420,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,749 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int refill_pi_state_cache(void)
{
struct futex_pi_state *pi_state;
if (likely(current->pi_state_cache))
return 0;
pi_state = kzalloc(sizeof(*pi_state), GFP_KERNEL);
if (!pi_state)
return -ENOMEM;
INIT_LIST_HEAD(&pi_state->list);
/* pi_mutex gets initialized later */
pi_state->owner = NULL;
atomic... | 158,293,665,671,689,580,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,750 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | void requeue_futex(struct futex_q *q, struct futex_hash_bucket *hb1,
struct futex_hash_bucket *hb2, union futex_key *key2)
{
/*
* If key1 and key2 hash to the same bucket, no need to
* requeue.
*/
if (likely(&hb1->chain != &hb2->chain)) {
plist_del(&q->list, &hb1->chain);
hb_waiters_dec(hb1);
plist_... | 197,316,355,753,390,770,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,751 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | void requeue_pi_wake_futex(struct futex_q *q, union futex_key *key,
struct futex_hash_bucket *hb)
{
get_futex_key_refs(key);
q->key = *key;
__unqueue_futex(q);
WARN_ON(!q->rt_waiter);
q->rt_waiter = NULL;
q->lock_ptr = &hb->lock;
wake_up_state(q->task, TASK_NORMAL);
}
| 286,609,502,175,659,350,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,752 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int unlock_futex_pi(u32 __user *uaddr, u32 uval)
{
u32 uninitialized_var(oldval);
/*
* There is no waiter, so we unlock the futex. The owner died
* bit has not to be preserved here. We are the owner:
*/
if (cmpxchg_futex_value_locked(&oldval, uaddr, uval, 0))
return -EFAULT;
if (oldval != uval)
re... | 268,797,850,664,258,940,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,753 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int unqueue_me(struct futex_q *q)
{
spinlock_t *lock_ptr;
int ret = 0;
/* In the common case we don't take the spinlock, which is nice. */
retry:
lock_ptr = q->lock_ptr;
barrier();
if (lock_ptr != NULL) {
spin_lock(lock_ptr);
/*
* q->lock_ptr can change between reading it and
* spin_lock(), caus... | 15,717,074,691,672,335,000,000,000,000,000,000,000 | futex.c | 133,577,935,360,128,750,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,754 | linux | e9c243a5a6de0be8e584c604d353412584b592f8 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8 | futex-prevent-requeue-pi-on-same-futex.patch futex: Forbid uaddr == uaddr2 in futex_requeue(..., requeue_pi=1)
If uaddr == uaddr2, then we have broken the rule of only requeueing from
a non-pi futex to a pi futex with this call. If we attempt this, then
dangling pointers may be left for rt_waiter resulting in an expl... | 0 | static int wake_futex_pi(u32 __user *uaddr, u32 uval, struct futex_q *this)
{
struct task_struct *new_owner;
struct futex_pi_state *pi_state = this->pi_state;
u32 uninitialized_var(curval), newval;
if (!pi_state)
return -EINVAL;
/*
* If current does not own the pi_state then the futex is
* inconsistent and... | 242,466,238,405,502,900,000,000,000,000,000,000,000 | futex.c | 213,479,601,755,205,720,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3153 | The futex_requeue function in kernel/futex.c in the Linux kernel through 3.14.5 does not ensure that calls have two different futex addresses, which allows local users to gain privileges via a crafted FUTEX_REQUEUE command that facilitates unsafe waiter modification. | https://nvd.nist.gov/vuln/detail/CVE-2014-3153 |
38,755 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | noinline u64 __bpf_call_base(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5)
{
return 0;
}
| 34,365,800,269,885,670,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,756 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | static u64 __get_raw_cpu_id(u64 ctx, u64 A, u64 X, u64 r4, u64 r5)
{
return raw_smp_processor_id();
}
| 111,496,387,830,942,360,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,757 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | static struct sk_filter *__sk_migrate_filter(struct sk_filter *fp,
struct sock *sk)
{
struct sock_filter *old_prog;
struct sk_filter *old_fp;
int i, err, new_len, old_len = fp->len;
/* We are free to overwrite insns et al right here as it
* won't be used at this point in time anymore internally
* aft... | 329,231,585,994,558,740,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,758 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | static struct sk_filter *__sk_migrate_realloc(struct sk_filter *fp,
struct sock *sk,
unsigned int len)
{
struct sk_filter *fp_new;
if (sk == NULL)
return krealloc(fp, len, GFP_KERNEL);
fp_new = sock_kmalloc(sk, len, GFP_KERNEL);
if (fp_new) {
memcpy(fp_new, fp, sizeof(struct sk_filter));... | 221,398,893,766,181,050,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,759 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | unsigned int __sk_run_filter(void *ctx, const struct sock_filter_int *insn)
{
u64 stack[MAX_BPF_STACK / sizeof(u64)];
u64 regs[MAX_BPF_REG], tmp;
void *ptr;
int off;
#define K insn->imm
#define A regs[insn->a_reg]
#define X regs[insn->x_reg]
#define R0 regs[0]
#define CONT ({insn++; goto select_insn; })
#defi... | 292,700,386,820,068,160,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,760 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | static u64 __skb_get_pay_offset(u64 ctx, u64 A, u64 X, u64 r4, u64 r5)
{
struct sk_buff *skb = (struct sk_buff *)(long) ctx;
return __skb_get_poff(skb);
}
| 33,338,192,012,242,946,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,761 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | void *bpf_internal_load_pointer_neg_helper(const struct sk_buff *skb, int k, unsigned int size)
{
u8 *ptr = NULL;
if (k >= SKF_NET_OFF)
ptr = skb_network_header(skb) + k - SKF_NET_OFF;
else if (k >= SKF_LL_OFF)
ptr = skb_mac_header(skb) + k - SKF_LL_OFF;
if (ptr >= skb->head && ptr + size <= skb_tail_pointer(... | 23,993,893,804,079,733,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,762 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | static int check_load_and_stores(struct sock_filter *filter, int flen)
{
u16 *masks, memvalid = 0; /* one bit per cell, 16 cells */
int pc, ret = 0;
BUILD_BUG_ON(BPF_MEMWORDS > 16);
masks = kmalloc(flen * sizeof(*masks), GFP_KERNEL);
if (!masks)
return -ENOMEM;
memset(masks, 0xff, flen * sizeof(*masks));
for... | 275,233,640,958,028,570,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,763 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | static bool convert_bpf_extensions(struct sock_filter *fp,
struct sock_filter_int **insnp)
{
struct sock_filter_int *insn = *insnp;
switch (fp->k) {
case SKF_AD_OFF + SKF_AD_PROTOCOL:
BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, protocol) != 2);
insn->code = BPF_LDX | BPF_MEM | BPF_H;
insn->a_reg = A_REG... | 91,945,770,927,222,460,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,764 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | static inline void *load_pointer(const struct sk_buff *skb, int k,
unsigned int size, void *buffer)
{
if (k >= 0)
return skb_header_pointer(skb, k, size, buffer);
return bpf_internal_load_pointer_neg_helper(skb, k, size);
}
| 117,929,406,260,920,240,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,765 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | int sk_chk_filter(struct sock_filter *filter, unsigned int flen)
{
/*
* Valid instructions are initialized to non-0.
* Invalid instructions are initialized to 0.
*/
static const u8 codes[] = {
[BPF_ALU|BPF_ADD|BPF_K] = BPF_S_ALU_ADD_K,
[BPF_ALU|BPF_ADD|BPF_X] = BPF_S_ALU_ADD_X,
[BPF_ALU|BPF_SUB|BPF_K] ... | 70,850,694,927,229,060,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,766 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | int sk_convert_filter(struct sock_filter *prog, int len,
struct sock_filter_int *new_prog, int *new_len)
{
int new_flen = 0, pass = 0, target, i;
struct sock_filter_int *new_insn;
struct sock_filter *fp;
int *addrs = NULL;
u8 bpf_src;
BUILD_BUG_ON(BPF_MEMWORDS * sizeof(u32) > MAX_BPF_STACK);
BUILD_BUG_O... | 24,424,157,073,095,586,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,767 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | void sk_decode_filter(struct sock_filter *filt, struct sock_filter *to)
{
static const u16 decodes[] = {
[BPF_S_ALU_ADD_K] = BPF_ALU|BPF_ADD|BPF_K,
[BPF_S_ALU_ADD_X] = BPF_ALU|BPF_ADD|BPF_X,
[BPF_S_ALU_SUB_K] = BPF_ALU|BPF_SUB|BPF_K,
[BPF_S_ALU_SUB_X] = BPF_ALU|BPF_SUB|BPF_X,
[BPF_S_ALU_MUL_K] = BPF_ALU|BPF_... | 160,341,747,439,365,810,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,768 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | int sk_detach_filter(struct sock *sk)
{
int ret = -ENOENT;
struct sk_filter *filter;
if (sock_flag(sk, SOCK_FILTER_LOCKED))
return -EPERM;
filter = rcu_dereference_protected(sk->sk_filter,
sock_owned_by_user(sk));
if (filter) {
RCU_INIT_POINTER(sk->sk_filter, NULL);
sk_filter_uncharge(sk, filter);
... | 223,484,999,532,189,900,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,769 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | void sk_filter_charge(struct sock *sk, struct sk_filter *fp)
{
atomic_inc(&fp->refcnt);
atomic_add(sk_filter_size(fp->len), &sk->sk_omem_alloc);
}
| 300,899,629,467,793,670,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,770 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | static void sk_filter_release(struct sk_filter *fp)
{
if (atomic_dec_and_test(&fp->refcnt))
call_rcu(&fp->rcu, sk_filter_release_rcu);
}
| 220,861,702,422,004,340,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,771 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | static void sk_filter_release_rcu(struct rcu_head *rcu)
{
struct sk_filter *fp = container_of(rcu, struct sk_filter, rcu);
sk_release_orig_filter(fp);
bpf_jit_free(fp);
}
| 278,888,514,099,239,400,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,772 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp)
{
atomic_sub(sk_filter_size(fp->len), &sk->sk_omem_alloc);
sk_filter_release(fp);
}
| 159,446,240,183,691,690,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,773 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | static void sk_release_orig_filter(struct sk_filter *fp)
{
struct sock_fprog_kern *fprog = fp->orig_prog;
if (fprog) {
kfree(fprog->filter);
kfree(fprog);
}
}
| 76,906,511,975,985,765,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,774 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | static int sk_store_orig_filter(struct sk_filter *fp,
const struct sock_fprog *fprog)
{
unsigned int fsize = sk_filter_proglen(fprog);
struct sock_fprog_kern *fkprog;
fp->orig_prog = kmalloc(sizeof(*fkprog), GFP_KERNEL);
if (!fp->orig_prog)
return -ENOMEM;
fkprog = fp->orig_prog;
fkprog->len = fprog->len;... | 84,853,961,658,816,335,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,775 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | int sk_unattached_filter_create(struct sk_filter **pfp,
struct sock_fprog *fprog)
{
unsigned int fsize = sk_filter_proglen(fprog);
struct sk_filter *fp;
/* Make sure new filter is there and in the right amounts. */
if (fprog->filter == NULL)
return -EINVAL;
fp = kmalloc(sk_filter_size(fprog->len), GFP_KERN... | 61,247,103,327,066,540,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,776 | linux | 05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/05ab8f2647e4221cbdb3856dd7d32bd5407316b3 | filter: prevent nla extensions to peek beyond the end of the message
The BPF_S_ANC_NLATTR and BPF_S_ANC_NLATTR_NEST extensions fail to check
for a minimal message length before testing the supplied offset to be
within the bounds of the message. This allows the subtraction of the nla
header to underflow and therefore -... | 0 | void sk_unattached_filter_destroy(struct sk_filter *fp)
{
sk_filter_release(fp);
}
| 72,232,060,337,691,500,000,000,000,000,000,000,000 | filter.c | 293,672,119,478,249,640,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-3144 | The (1) BPF_S_ANC_NLATTR and (2) BPF_S_ANC_NLATTR_NEST extension implementations in the sk_run_filter function in net/core/filter.c in the Linux kernel through 3.14.3 do not check whether a certain length value is sufficiently large, which allows local users to cause a denial of service (integer underflow and system cr... | https://nvd.nist.gov/vuln/detail/CVE-2014-3144 |
38,777 | linux | 57e68e9cd65b4b8eb4045a1e0d0746458502554c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/57e68e9cd65b4b8eb4045a1e0d0746458502554c | mm: try_to_unmap_cluster() should lock_page() before mlocking
A BUG_ON(!PageLocked) was triggered in mlock_vma_page() by Sasha Levin
fuzzing with trinity. The call site try_to_unmap_cluster() does not lock
the pages other than its check_page parameter (which is already locked).
The BUG_ON in mlock_vma_page() is not ... | 0 | SYSCALL_DEFINE0(munlockall)
{
int ret;
down_write(¤t->mm->mmap_sem);
ret = do_mlockall(0);
up_write(¤t->mm->mmap_sem);
return ret;
}
| 279,857,388,787,228,800,000,000,000,000,000,000,000 | mlock.c | 150,601,957,285,814,880,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3122 | The try_to_unmap_cluster function in mm/rmap.c in the Linux kernel before 3.14.3 does not properly consider which pages must be locked, which allows local users to cause a denial of service (system crash) by triggering a memory-usage pattern that requires removal of page-table mappings. | https://nvd.nist.gov/vuln/detail/CVE-2014-3122 |
38,778 | linux | 57e68e9cd65b4b8eb4045a1e0d0746458502554c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/57e68e9cd65b4b8eb4045a1e0d0746458502554c | mm: try_to_unmap_cluster() should lock_page() before mlocking
A BUG_ON(!PageLocked) was triggered in mlock_vma_page() by Sasha Levin
fuzzing with trinity. The call site try_to_unmap_cluster() does not lock
the pages other than its check_page parameter (which is already locked).
The BUG_ON in mlock_vma_page() is not ... | 0 | SYSCALL_DEFINE2(mlock, unsigned long, start, size_t, len)
{
unsigned long locked;
unsigned long lock_limit;
int error = -ENOMEM;
if (!can_do_mlock())
return -EPERM;
lru_add_drain_all(); /* flush pagevec */
len = PAGE_ALIGN(len + (start & ~PAGE_MASK));
start &= PAGE_MASK;
lock_limit = rlimit(RLIMIT_MEMLOCK... | 71,357,460,990,543,110,000,000,000,000,000,000,000 | mlock.c | 150,601,957,285,814,880,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3122 | The try_to_unmap_cluster function in mm/rmap.c in the Linux kernel before 3.14.3 does not properly consider which pages must be locked, which allows local users to cause a denial of service (system crash) by triggering a memory-usage pattern that requires removal of page-table mappings. | https://nvd.nist.gov/vuln/detail/CVE-2014-3122 |
38,779 | linux | 57e68e9cd65b4b8eb4045a1e0d0746458502554c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/57e68e9cd65b4b8eb4045a1e0d0746458502554c | mm: try_to_unmap_cluster() should lock_page() before mlocking
A BUG_ON(!PageLocked) was triggered in mlock_vma_page() by Sasha Levin
fuzzing with trinity. The call site try_to_unmap_cluster() does not lock
the pages other than its check_page parameter (which is already locked).
The BUG_ON in mlock_vma_page() is not ... | 0 | SYSCALL_DEFINE2(munlock, unsigned long, start, size_t, len)
{
int ret;
len = PAGE_ALIGN(len + (start & ~PAGE_MASK));
start &= PAGE_MASK;
down_write(¤t->mm->mmap_sem);
ret = do_mlock(start, len, 0);
up_write(¤t->mm->mmap_sem);
return ret;
}
| 181,481,569,301,360,200,000,000,000,000,000,000,000 | mlock.c | 150,601,957,285,814,880,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3122 | The try_to_unmap_cluster function in mm/rmap.c in the Linux kernel before 3.14.3 does not properly consider which pages must be locked, which allows local users to cause a denial of service (system crash) by triggering a memory-usage pattern that requires removal of page-table mappings. | https://nvd.nist.gov/vuln/detail/CVE-2014-3122 |
38,780 | linux | 57e68e9cd65b4b8eb4045a1e0d0746458502554c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/57e68e9cd65b4b8eb4045a1e0d0746458502554c | mm: try_to_unmap_cluster() should lock_page() before mlocking
A BUG_ON(!PageLocked) was triggered in mlock_vma_page() by Sasha Levin
fuzzing with trinity. The call site try_to_unmap_cluster() does not lock
the pages other than its check_page parameter (which is already locked).
The BUG_ON in mlock_vma_page() is not ... | 0 | static int __mlock_posix_error_return(long retval)
{
if (retval == -EFAULT)
retval = -ENOMEM;
else if (retval == -ENOMEM)
retval = -EAGAIN;
return retval;
}
| 269,725,105,553,296,000,000,000,000,000,000,000,000 | mlock.c | 296,885,345,766,349,730,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3122 | The try_to_unmap_cluster function in mm/rmap.c in the Linux kernel before 3.14.3 does not properly consider which pages must be locked, which allows local users to cause a denial of service (system crash) by triggering a memory-usage pattern that requires removal of page-table mappings. | https://nvd.nist.gov/vuln/detail/CVE-2014-3122 |
38,781 | linux | 57e68e9cd65b4b8eb4045a1e0d0746458502554c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/57e68e9cd65b4b8eb4045a1e0d0746458502554c | mm: try_to_unmap_cluster() should lock_page() before mlocking
A BUG_ON(!PageLocked) was triggered in mlock_vma_page() by Sasha Levin
fuzzing with trinity. The call site try_to_unmap_cluster() does not lock
the pages other than its check_page parameter (which is already locked).
The BUG_ON in mlock_vma_page() is not ... | 0 | long __mlock_vma_pages_range(struct vm_area_struct *vma,
unsigned long start, unsigned long end, int *nonblocking)
{
struct mm_struct *mm = vma->vm_mm;
unsigned long nr_pages = (end - start) / PAGE_SIZE;
int gup_flags;
VM_BUG_ON(start & ~PAGE_MASK);
VM_BUG_ON(end & ~PAGE_MASK);
VM_BUG_ON(start < vma->vm_star... | 22,060,805,597,848,124,000,000,000,000,000,000,000 | mlock.c | 150,601,957,285,814,880,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3122 | The try_to_unmap_cluster function in mm/rmap.c in the Linux kernel before 3.14.3 does not properly consider which pages must be locked, which allows local users to cause a denial of service (system crash) by triggering a memory-usage pattern that requires removal of page-table mappings. | https://nvd.nist.gov/vuln/detail/CVE-2014-3122 |
38,782 | linux | 57e68e9cd65b4b8eb4045a1e0d0746458502554c | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/57e68e9cd65b4b8eb4045a1e0d0746458502554c | mm: try_to_unmap_cluster() should lock_page() before mlocking
A BUG_ON(!PageLocked) was triggered in mlock_vma_page() by Sasha Levin
fuzzing with trinity. The call site try_to_unmap_cluster() does not lock
the pages other than its check_page parameter (which is already locked).
The BUG_ON in mlock_vma_page() is not ... | 0 | static bool __munlock_isolate_lru_page(struct page *page, bool getpage)
{
if (PageLRU(page)) {
struct lruvec *lruvec;
lruvec = mem_cgroup_page_lruvec(page, page_zone(page));
if (getpage)
get_page(page);
ClearPageLRU(page);
del_page_from_lru_list(page, lruvec, page_lru(page));
return true;
}
return f... | 96,828,457,147,560,920,000,000,000,000,000,000,000 | mlock.c | 150,601,957,285,814,880,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2014-3122 | The try_to_unmap_cluster function in mm/rmap.c in the Linux kernel before 3.14.3 does not properly consider which pages must be locked, which allows local users to cause a denial of service (system crash) by triggering a memory-usage pattern that requires removal of page-table mappings. | https://nvd.nist.gov/vuln/detail/CVE-2014-3122 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.