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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
37,282 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
struct snd_ctl_elem_value __user *_control)
{
struct snd_ctl_elem_value *control;
struct snd_card *card;
int result;
control = memdup_user(_control, sizeof(*control));
if (IS_ERR(control))
return PTR_ERR(control);
card = file->card;
snd_pow... | 52,667,939,483,033,670,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,283 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | int snd_ctl_enum_info(struct snd_ctl_elem_info *info, unsigned int channels,
unsigned int items, const char *const names[])
{
info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
info->count = channels;
info->value.enumerated.items = items;
if (info->value.enumerated.item >= items)
info->value.enumerated.item = i... | 25,707,084,679,518,970,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,284 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | static int snd_ctl_fasync(int fd, struct file * file, int on)
{
struct snd_ctl_file *ctl;
ctl = file->private_data;
return fasync_helper(fd, file, on, &ctl->fasync);
}
| 283,503,040,197,234,400,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,285 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card,
struct snd_ctl_elem_id *id)
{
struct snd_kcontrol *kctl;
if (snd_BUG_ON(!card || !id))
return NULL;
if (id->numid != 0)
return snd_ctl_find_numid(card, id->numid);
list_for_each_entry(kctl, &card->controls, list) {
if (kctl->id.iface != id-... | 239,918,207,530,980,620,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,286 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numid)
{
struct snd_kcontrol *kctl;
if (snd_BUG_ON(!card || !numid))
return NULL;
list_for_each_entry(kctl, &card->controls, list) {
if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
return kctl;
}
return NULL;
}... | 170,686,233,722,632,900,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,287 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | void snd_ctl_free_one(struct snd_kcontrol *kcontrol)
{
if (kcontrol) {
if (kcontrol->private_free)
kcontrol->private_free(kcontrol);
kfree(kcontrol);
}
}
| 47,413,670,187,955,740,000,000,000,000,000,000,000 | control.c | 255,950,300,769,870,240,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,288 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_ctl_file *ctl;
struct snd_card *card;
struct snd_kctl_ioctl *p;
void __user *argp = (void __user *)arg;
int __user *ip = argp;
int err;
ctl = file->private_data;
card = ctl->card;
if (snd_BUG_ON(!card))
return -EN... | 84,640,859,237,043,990,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,289 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | static struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control,
unsigned int access)
{
struct snd_kcontrol *kctl;
unsigned int idx;
if (snd_BUG_ON(!control || !control->count))
return NULL;
if (control->count > MAX_CONTROL_COUNT)
return NULL;
kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcon... | 200,663,909,066,396,400,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,290 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
void *private_data)
{
struct snd_kcontrol kctl;
unsigned int access;
if (snd_BUG_ON(!ncontrol || !ncontrol->info))
return NULL;
memset(&kctl, 0, sizeof(kctl));
kctl.id.iface = ncontrol->iface;
kctl.id.device = ncontrol->device;
... | 247,489,024,680,502,230,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,291 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | void snd_ctl_notify(struct snd_card *card, unsigned int mask,
struct snd_ctl_elem_id *id)
{
unsigned long flags;
struct snd_ctl_file *ctl;
struct snd_kctl_event *ev;
if (snd_BUG_ON(!card || !id))
return;
read_lock(&card->ctl_files_rwlock);
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
card->mixer_oss_change_coun... | 206,578,866,637,796,400,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,292 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | static int snd_ctl_open(struct inode *inode, struct file *file)
{
unsigned long flags;
struct snd_card *card;
struct snd_ctl_file *ctl;
int err;
err = nonseekable_open(inode, file);
if (err < 0)
return err;
card = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_CONTROL);
if (!card) {
err = -ENODEV;... | 113,056,541,315,075,590,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,293 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | static unsigned int snd_ctl_poll(struct file *file, poll_table * wait)
{
unsigned int mask;
struct snd_ctl_file *ctl;
ctl = file->private_data;
if (!ctl->subscribed)
return 0;
poll_wait(file, &ctl->change_sleep, wait);
mask = 0;
if (!list_empty(&ctl->events))
mask |= POLLIN | POLLRDNORM;
return mask;
}
| 312,381,390,479,175,260,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,294 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | static ssize_t snd_ctl_read(struct file *file, char __user *buffer,
size_t count, loff_t * offset)
{
struct snd_ctl_file *ctl;
int err = 0;
ssize_t result = 0;
ctl = file->private_data;
if (snd_BUG_ON(!ctl || !ctl->card))
return -ENXIO;
if (!ctl->subscribed)
return -EBADFD;
if (count < sizeof(struct ... | 12,879,787,903,874,515,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,295 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
{
return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls);
}
| 252,320,940,771,385,600,000,000,000,000,000,000,000 | control.c | 255,950,300,769,870,240,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,296 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
{
return _snd_ctl_register_ioctl(fcn, &snd_control_compat_ioctls);
}
| 135,785,649,151,486,750,000,000,000,000,000,000,000 | control.c | 255,950,300,769,870,240,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,297 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | static int snd_ctl_release(struct inode *inode, struct file *file)
{
unsigned long flags;
struct snd_card *card;
struct snd_ctl_file *ctl;
struct snd_kcontrol *control;
unsigned int idx;
ctl = file->private_data;
file->private_data = NULL;
card = ctl->card;
write_lock_irqsave(&card->ctl_files_rwlock, flags);
... | 218,436,691,614,056,770,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,298 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
{
struct snd_ctl_elem_id id;
unsigned int idx;
if (snd_BUG_ON(!card || !kcontrol))
return -EINVAL;
list_del(&kcontrol->list);
card->controls_count -= kcontrol->count;
id = kcontrol->id;
for (idx = 0; idx < kcontrol->count; idx++, id.inde... | 102,021,235,907,001,300,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,299 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)
{
struct snd_kcontrol *kctl;
int ret;
down_write(&card->controls_rwsem);
kctl = snd_ctl_find_id(card, id);
if (kctl == NULL) {
up_write(&card->controls_rwsem);
return -ENOENT;
}
ret = snd_ctl_remove(card, kctl);
up_write(&card->contro... | 29,791,782,514,517,698,000,000,000,000,000,000,000 | control.c | 255,950,300,769,870,240,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,300 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | static int snd_ctl_remove_user_ctl(struct snd_ctl_file * file,
struct snd_ctl_elem_id *id)
{
struct snd_card *card = file->card;
struct snd_kcontrol *kctl;
int idx, ret;
down_write(&card->controls_rwsem);
kctl = snd_ctl_find_id(card, id);
if (kctl == NULL) {
ret = -ENOENT;
goto error;
}
if (!(kctl->... | 86,066,481,955,240,550,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,301 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id,
struct snd_ctl_elem_id *dst_id)
{
struct snd_kcontrol *kctl;
down_write(&card->controls_rwsem);
kctl = snd_ctl_find_id(card, src_id);
if (kctl == NULL) {
up_write(&card->controls_rwsem);
return -ENOENT;
}
kctl->id = *dst_id;... | 315,124,132,343,993,540,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,302 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | int snd_ctl_replace(struct snd_card *card, struct snd_kcontrol *kcontrol,
bool add_on_replace)
{
struct snd_ctl_elem_id id;
unsigned int count;
unsigned int idx;
struct snd_kcontrol *old;
int ret;
if (!kcontrol)
return -EINVAL;
if (snd_BUG_ON(!card || !kcontrol->info)) {
ret = -EINVAL;
goto error;
... | 7,724,793,892,670,976,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,303 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | static int snd_ctl_tlv_ioctl(struct snd_ctl_file *file,
struct snd_ctl_tlv __user *_tlv,
int op_flag)
{
struct snd_card *card = file->card;
struct snd_ctl_tlv tlv;
struct snd_kcontrol *kctl;
struct snd_kcontrol_volatile *vd;
unsigned int len;
int err = 0;
... | 187,178,095,323,442,930,000,000,000,000,000,000,000 | control.c | 179,532,723,377,993,540,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,304 | linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ac902c112d90a89e59916f751c2745f4dbdbb4bd | ALSA: control: Handle numid overflow
Each control gets automatically assigned its numids when the control is created.
The allocation is done by incrementing the numid by the amount of allocated
numids per allocation. This means that excessive creation and destruction of
controls (e.g. via SNDRV_CTL_IOCTL_ELEM_ADD/REMO... | 0 | int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
{
return _snd_ctl_unregister_ioctl(fcn, &snd_control_compat_ioctls);
}
| 10,726,660,383,800,330,000,000,000,000,000,000,000 | control.c | 255,950,300,769,870,240,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2014-4656 | Multiple integer overflows in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allow local users to cause a denial of service by leveraging /dev/snd/controlCX access, related to (1) index values in the snd_ctl_add function and (2) numid values in the snd_ctl_remove_numid_conflic... | https://nvd.nist.gov/vuln/detail/CVE-2014-4656 |
37,305 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static bool card_id_ok(struct snd_card *card, const char *id)
{
int i;
if (!snd_info_check_reserved_words(id))
return false;
for (i = 0; i < snd_ecards_limit; i++) {
if (snd_cards[i] && snd_cards[i] != card &&
!strcmp(snd_cards[i]->id, id))
return false;
}
return true;
}
| 89,376,416,475,245,130,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,306 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | card_id_show_attr(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct snd_card *card = container_of(dev, struct snd_card, card_dev);
return snprintf(buf, PAGE_SIZE, "%s\n", card->id);
}
| 444,231,800,211,631,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,307 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | card_id_store_attr(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct snd_card *card = container_of(dev, struct snd_card, card_dev);
char buf1[sizeof(card->id)];
size_t copy = count > sizeof(card->id) - 1 ?
sizeof(card->id) - 1 : count;
size_t idx;
int c;
for (id... | 121,663,136,778,804,650,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,308 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | card_number_show_attr(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct snd_card *card = container_of(dev, struct snd_card, card_dev);
return snprintf(buf, PAGE_SIZE, "%i\n", card->number);
}
| 306,915,086,113,300,100,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,309 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static int check_empty_slot(struct module *module, int slot)
{
return !slots[slot] || !*slots[slot];
}
| 48,686,541,639,987,290,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,310 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static void copy_valid_id_string(struct snd_card *card, const char *src,
const char *nid)
{
char *id = card->id;
while (*nid && !isalnum(*nid))
nid++;
if (isdigit(*nid))
*id++ = isalpha(*src) ? *src : 'D';
while (*nid && (size_t)(id - card->id) < sizeof(card->id) - 1) {
if (isalnum(*nid))
*id++ = *ni... | 238,621,825,743,104,100,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,311 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static int get_slot_from_bitmask(int mask, int (*check)(struct module *, int),
struct module *module)
{
int slot;
for (slot = 0; slot < SNDRV_CARDS; slot++) {
if (slot < 32 && !(mask & (1U << slot)))
continue;
if (!test_bit(slot, snd_cards_lock)) {
if (check(module, slot))
return slot; /* found */... | 75,237,482,086,730,020,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,312 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static inline int init_info_for_card(struct snd_card *card)
{
int err;
struct snd_info_entry *entry;
if ((err = snd_info_card_register(card)) < 0) {
dev_dbg(card->dev, "unable to create card info\n");
return err;
}
if ((entry = snd_info_create_card_entry(card, "id", card->proc_root)) == NULL) {
dev_dbg(card... | 127,837,831,248,273,300,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,313 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static int module_slot_match(struct module *module, int idx)
{
int match = 1;
#ifdef MODULE
const char *s1, *s2;
if (!module || !*module->name || !slots[idx])
return 0;
s1 = module->name;
s2 = slots[idx];
if (*s2 == '!') {
match = 0; /* negative match */
s2++;
}
/* compare module name strings
* hyphen... | 173,451,594,180,023,600,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,314 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static void release_card_device(struct device *dev)
{
snd_card_do_free(dev_to_snd_card(dev));
}
| 258,342,956,182,211,340,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,315 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static const char *retrieve_id_from_card_name(const char *name)
{
const char *spos = name;
while (*name) {
if (isspace(*name) && isalnum(name[1]))
spos = name + 1;
name++;
}
return spos;
}
| 332,843,600,623,325,340,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,316 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | int snd_card_disconnect(struct snd_card *card)
{
struct snd_monitor_file *mfile;
int err;
if (!card)
return -EINVAL;
spin_lock(&card->files_lock);
if (card->shutdown) {
spin_unlock(&card->files_lock);
return 0;
}
card->shutdown = 1;
spin_unlock(&card->files_lock);
/* phase 1: disable fops (user space)... | 119,894,016,107,276,940,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,317 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static int snd_card_do_free(struct snd_card *card)
{
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
if (snd_mixer_oss_notify_callback)
snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
#endif
snd_device_free_all(card);
if (card->private_free)
card->private_free(card);
snd_info_free_entry(card->proc_id);
if... | 313,208,041,782,782,540,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,318 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | int snd_card_file_add(struct snd_card *card, struct file *file)
{
struct snd_monitor_file *mfile;
mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
if (mfile == NULL)
return -ENOMEM;
mfile->file = file;
mfile->disconnected_f_op = NULL;
INIT_LIST_HEAD(&mfile->shutdown_list);
spin_lock(&card->files_lock);
if (card-... | 256,615,325,852,540,240,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,319 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | int snd_card_file_remove(struct snd_card *card, struct file *file)
{
struct snd_monitor_file *mfile, *found = NULL;
spin_lock(&card->files_lock);
list_for_each_entry(mfile, &card->files_list, list) {
if (mfile->file == file) {
list_del(&mfile->list);
spin_lock(&shutdown_lock);
list_del(&mfile->shutdown_l... | 76,939,144,030,952,130,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,320 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | int snd_card_free_when_closed(struct snd_card *card)
{
int ret = snd_card_disconnect(card);
if (ret)
return ret;
put_device(&card->card_dev);
return 0;
}
| 132,612,455,174,149,950,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,321 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static void snd_card_id_read(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{
snd_iprintf(buffer, "%s\n", entry->card->id);
}
| 325,274,551,936,080,540,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,322 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | int __exit snd_card_info_done(void)
{
snd_info_free_entry(snd_card_info_entry);
#ifdef MODULE
snd_info_free_entry(snd_card_module_info_entry);
#endif
return 0;
}
| 39,044,606,987,525,503,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,323 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | int __init snd_card_info_init(void)
{
struct snd_info_entry *entry;
entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
if (! entry)
return -ENOMEM;
entry->c.text.read = snd_card_info_read;
if (snd_info_register(entry) < 0) {
snd_info_free_entry(entry);
return -ENOMEM;
}
snd_card_info_entry ... | 46,201,998,251,003,190,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,324 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static void snd_card_info_read(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{
int idx, count;
struct snd_card *card;
for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
mutex_lock(&snd_card_mutex);
if ((card = snd_cards[idx]) != NULL) {
count++;
snd_iprintf(buffer, "%2i [%-15s]: %... | 231,619,170,005,320,660,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,325 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | void snd_card_info_read_oss(struct snd_info_buffer *buffer)
{
int idx, count;
struct snd_card *card;
for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
mutex_lock(&snd_card_mutex);
if ((card = snd_cards[idx]) != NULL) {
count++;
snd_iprintf(buffer, "%s\n", card->longname);
}
mutex_unlock(&snd_card_mute... | 19,080,003,986,678,455,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,326 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | int snd_card_locked(int card)
{
int locked;
mutex_lock(&snd_card_mutex);
locked = test_bit(card, snd_cards_lock);
mutex_unlock(&snd_card_mutex);
return locked;
}
| 324,298,246,049,025,100,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,327 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static void snd_card_module_info_read(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{
int idx;
struct snd_card *card;
for (idx = 0; idx < SNDRV_CARDS; idx++) {
mutex_lock(&snd_card_mutex);
if ((card = snd_cards[idx]) != NULL)
snd_iprintf(buffer, "%2i %s\n",
idx, card->module... | 120,526,275,611,445,880,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,328 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | int snd_card_register(struct snd_card *card)
{
int err;
if (snd_BUG_ON(!card))
return -EINVAL;
if (!card->registered) {
err = device_add(&card->card_dev);
if (err < 0)
return err;
card->registered = true;
}
if ((err = snd_device_register_all(card)) < 0)
return err;
mutex_lock(&snd_card_mutex);
if... | 48,688,933,282,569,400,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,329 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | void snd_card_set_id(struct snd_card *card, const char *nid)
{
/* check if user specified own card->id */
if (card->id[0] != '\0')
return;
mutex_lock(&snd_card_mutex);
snd_card_set_id_no_lock(card, nid, nid);
mutex_unlock(&snd_card_mutex);
}
| 82,619,704,332,608,620,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,330 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static void snd_card_set_id_no_lock(struct snd_card *card, const char *src,
const char *nid)
{
int len, loops;
bool is_default = false;
char *id;
copy_valid_id_string(card, src, nid);
id = card->id;
again:
/* use "Default" for obviously invalid strings
* ("card" conflicts with proc directories)
*/... | 318,116,390,003,064,240,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,331 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static int snd_disconnect_fasync(int fd, struct file *file, int on)
{
return -ENODEV;
}
| 303,402,518,297,311,400,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,332 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static long snd_disconnect_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
return -ENODEV;
}
| 271,174,515,579,090,230,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,333 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig)
{
return -ENODEV;
}
| 279,431,915,565,188,880,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,334 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma)
{
return -ENODEV;
}
| 311,454,573,525,355,000,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,335 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static unsigned int snd_disconnect_poll(struct file * file, poll_table * wait)
{
return POLLERR | POLLNVAL;
}
| 164,091,985,464,130,540,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,336 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | static int snd_disconnect_release(struct inode *inode, struct file *file)
{
struct snd_monitor_file *df = NULL, *_df;
spin_lock(&shutdown_lock);
list_for_each_entry(_df, &shutdown_files, shutdown_list) {
if (_df->file == file) {
df = _df;
list_del_init(&df->shutdown_list);
break;
}
}
spin_unlock(&shu... | 111,705,321,496,956,260,000,000,000,000,000,000,000 | init.c | 82,975,296,573,960,280,000,000,000,000,000,000,000 | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,337 | linux | 07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/07f4d9d74a04aa7c72c5dae0ef97565f28f17b92 | ALSA: control: Protect user controls against concurrent access
The user-control put and get handlers as well as the tlv do not protect against
concurrent access from multiple threads. Since the state of the control is not
updated atomically it is possible that either two write operations or a write
and a read operatio... | 0 | int snd_power_wait(struct snd_card *card, unsigned int power_state)
{
wait_queue_t wait;
int result = 0;
/* fastpath */
if (snd_power_get_state(card) == power_state)
return 0;
init_waitqueue_entry(&wait, current);
add_wait_queue(&card->power_sleep, &wait);
while (1) {
if (card->shutdown) {
result = -ENOD... | 13,196,837,995,277,102,000,000,000,000,000,000,000 | None | null | [
"CWE-362"
] | CVE-2014-4652 | Race condition in the tlv handler functionality in the snd_ctl_elem_user_tlv function in sound/core/control.c in the ALSA control implementation in the Linux kernel before 3.15.2 allows local users to obtain sensitive information from kernel memory by leveraging /dev/snd/controlCX access. | https://nvd.nist.gov/vuln/detail/CVE-2014-4652 |
37,338 | linux | 206204a1162b995e2185275167b22468c00d6b36 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/206204a1162b995e2185275167b22468c00d6b36 | lz4: ensure length does not wrap
Given some pathologically compressed data, lz4 could possibly decide to
wrap a few internal variables, causing unknown things to happen. Catch
this before the wrapping happens and abort the decompression.
Reported-by: "Don A. Bailey" <donb@securitymouse.com>
Cc: stable <stable@vger.k... | 0 | int lz4_decompress(const unsigned char *src, size_t *src_len,
unsigned char *dest, size_t actual_dest_len)
{
int ret = -1;
int input_len = 0;
input_len = lz4_uncompress(src, dest, actual_dest_len);
if (input_len < 0)
goto exit_0;
*src_len = input_len;
return 0;
exit_0:
return ret;
}
| 130,857,455,659,061,410,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-4611 | Integer overflow in the LZ4 algorithm implementation, as used in Yann Collet LZ4 before r118 and in the lz4_uncompress function in lib/lz4/lz4_decompress.c in the Linux kernel before 3.15.2, on 32-bit platforms might allow context-dependent attackers to cause a denial of service (memory corruption) or possibly have uns... | https://nvd.nist.gov/vuln/detail/CVE-2014-4611 |
37,339 | linux | 206204a1162b995e2185275167b22468c00d6b36 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/206204a1162b995e2185275167b22468c00d6b36 | lz4: ensure length does not wrap
Given some pathologically compressed data, lz4 could possibly decide to
wrap a few internal variables, causing unknown things to happen. Catch
this before the wrapping happens and abort the decompression.
Reported-by: "Don A. Bailey" <donb@securitymouse.com>
Cc: stable <stable@vger.k... | 0 | int lz4_decompress_unknownoutputsize(const unsigned char *src, size_t src_len,
unsigned char *dest, size_t *dest_len)
{
int ret = -1;
int out_len = 0;
out_len = lz4_uncompress_unknownoutputsize(src, dest, src_len,
*dest_len);
if (out_len < 0)
goto exit_0;
*dest_len = out_len;
return 0;
exit_0:
return ... | 316,785,792,773,971,070,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-4611 | Integer overflow in the LZ4 algorithm implementation, as used in Yann Collet LZ4 before r118 and in the lz4_uncompress function in lib/lz4/lz4_decompress.c in the Linux kernel before 3.15.2, on 32-bit platforms might allow context-dependent attackers to cause a denial of service (memory corruption) or possibly have uns... | https://nvd.nist.gov/vuln/detail/CVE-2014-4611 |
37,340 | linux | 206204a1162b995e2185275167b22468c00d6b36 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/206204a1162b995e2185275167b22468c00d6b36 | lz4: ensure length does not wrap
Given some pathologically compressed data, lz4 could possibly decide to
wrap a few internal variables, causing unknown things to happen. Catch
this before the wrapping happens and abort the decompression.
Reported-by: "Don A. Bailey" <donb@securitymouse.com>
Cc: stable <stable@vger.k... | 0 | static int lz4_uncompress_unknownoutputsize(const char *source, char *dest,
int isize, size_t maxoutputsize)
{
const BYTE *ip = (const BYTE *) source;
const BYTE *const iend = ip + isize;
const BYTE *ref;
BYTE *op = (BYTE *) dest;
BYTE * const oend = op + maxoutputsize;
BYTE *cpy;
size_t dec32table[] = {0... | 273,752,330,414,044,350,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-4611 | Integer overflow in the LZ4 algorithm implementation, as used in Yann Collet LZ4 before r118 and in the lz4_uncompress function in lib/lz4/lz4_decompress.c in the Linux kernel before 3.15.2, on 32-bit platforms might allow context-dependent attackers to cause a denial of service (memory corruption) or possibly have uns... | https://nvd.nist.gov/vuln/detail/CVE-2014-4611 |
37,341 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void RenameThread(const char* name)
{
char buf[16];
snprintf(buf, sizeof(buf), "cg@%s", name);
#if defined(PR_SET_NAME)
prctl(PR_SET_NAME, buf, 0, 0, 0);
#elif (defined(__FreeBSD__) || defined(__OpenBSD__))
pthread_set_name_np(pthread_self(), buf);
#elif defined(MAC_OSX)
pthread_setname_np(buf);
#else
(void)buf;... | 132,485,658,894,437,980,000,000,000,000,000,000,000 | None | null | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,342 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void __bin2hex(char *s, const unsigned char *p, size_t len)
{
int i;
static const char hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
for (i = 0; i < (int)len; i++) {
*s++ = hex[p[i] >> 4];
*s++ = hex[p[i] & 0xF];
}
*s++ = '\0';
}
| 148,828,452,935,265,420,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,343 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | static enum send_ret __stratum_send(struct pool *pool, char *s, ssize_t len)
{
SOCKETTYPE sock = pool->sock;
ssize_t ssent = 0;
strcat(s, "\n");
len++;
while (len > 0 ) {
struct timeval timeout = {1, 0};
ssize_t sent;
fd_set wd;
retry:
FD_ZERO(&wd);
FD_SET(sock, &wd);
if (select(sock + 1, NULL, &wd, ... | 207,260,641,011,543,040,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,344 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | static void __suspend_stratum(struct pool *pool)
{
clear_sockbuf(pool);
pool->stratum_active = pool->stratum_notify = false;
if (pool->sock)
CLOSESOCKET(pool->sock);
pool->sock = 0;
}
| 330,156,583,144,898,530,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,345 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void _cgsem_init(cgsem_t *cgsem, const char *file, const char *func, const int line)
{
int flags, fd, i;
if (pipe(cgsem->pipefd) == -1)
quitfrom(1, file, func, line, "Failed pipe errno=%d", errno);
/* Make the pipes FD_CLOEXEC to allow them to close should we call
* execv on restart. */
for (i = 0; i < 2; i++... | 243,625,448,125,287,620,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,346 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void _cgsem_init(cgsem_t *cgsem, const char *file, const char *func, const int line)
{
int ret;
if ((ret = sem_init(cgsem, 0, 0)))
quitfrom(1, file, func, line, "Failed to sem_init ret=%d errno=%d", ret, errno);
}
| 50,582,302,230,279,115,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,347 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | int _cgsem_mswait(cgsem_t *cgsem, int ms, const char *file, const char *func, const int line)
{
struct timeval timeout;
int ret, fd;
fd_set rd;
char buf;
retry:
fd = cgsem->pipefd[0];
FD_ZERO(&rd);
FD_SET(fd, &rd);
ms_to_timeval(&timeout, ms);
ret = select(fd + 1, &rd, NULL, NULL, &timeout);
if (ret > 0) {
... | 261,173,755,782,574,630,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,348 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | int _cgsem_mswait(cgsem_t *cgsem, int ms, const char *file, const char *func, const int line)
{
struct timespec abs_timeout, ts_now;
struct timeval tv_now;
int ret;
cgtime(&tv_now);
timeval_to_spec(&ts_now, &tv_now);
ms_to_timespec(&abs_timeout, ms);
retry:
timeraddspec(&abs_timeout, &ts_now);
ret = sem_timedw... | 201,911,399,169,128,350,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,349 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void _cgsem_post(cgsem_t *cgsem, const char *file, const char *func, const int line)
{
if (unlikely(sem_post(cgsem)))
quitfrom(1, file, func, line, "Failed to sem_post errno=%d cgsem=0x%p", errno, cgsem);
}
| 15,593,333,102,943,877,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,350 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void _cgsem_wait(cgsem_t *cgsem, const char *file, const char *func, const int line)
{
char buf;
int ret;
retry:
ret = read(cgsem->pipefd[0], &buf, 1);
if (unlikely(ret == 0))
applog(LOG_WARNING, "Failed to read errno=%d" IN_FMT_FFL, errno, file, func, line);
else if (unlikely(ret < 0 && interrupted))
goto ret... | 105,859,519,762,701,330,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,351 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void addtime(struct timeval *a, struct timeval *b)
{
timeradd(a, b, b);
}
| 205,378,358,544,052,460,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,352 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | static size_t all_data_cb(const void *ptr, size_t size, size_t nmemb,
void *user_data)
{
struct data_buffer *db = (struct data_buffer *)user_data;
size_t len = size * nmemb;
size_t oldlen, newlen;
void *newmem;
static const unsigned char zero = 0;
oldlen = db->len;
newlen = oldlen + len;
newmem = realloc... | 274,401,035,836,763,440,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,353 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | bool auth_stratum(struct pool *pool)
{
json_t *val = NULL, *res_val, *err_val;
char s[RBUFSIZE], *sret = NULL;
json_error_t err;
bool ret = false;
sprintf(s, "{\"id\": %d, \"method\": \"mining.authorize\", \"params\": [\"%s\", \"%s\"]}",
swork_id++, pool->rpc_user, pool->rpc_pass);
if (!stratum_send(pool, s, ... | 257,222,985,122,472,270,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,354 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | static void block_socket(SOCKETTYPE fd)
{
#ifndef WIN32
int flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
#else
u_long flags = 0;
ioctlsocket(fd, FIONBIO, &flags);
#endif
}
| 219,285,630,386,383,440,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,355 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | bool cg_completion_timeout(void *fn, void *fnarg, int timeout)
{
struct cg_completion *cgc;
pthread_t pthread;
bool ret = false;
cgc = (struct cg_completion *)malloc(sizeof(struct cg_completion));
if (unlikely(!cgc))
return ret;
cgsem_init(&cgc->cgsem);
#ifdef _MSC_VER
cgc->fn = (void(__cdecl *)(void *))fn;
... | 114,427,660,663,838,960,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,356 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgsem_destroy(cgsem_t *cgsem)
{
close(cgsem->pipefd[1]);
close(cgsem->pipefd[0]);
}
| 173,393,086,897,709,400,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,357 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgsem_destroy(cgsem_t *cgsem)
{
sem_destroy(cgsem);
}
| 181,153,236,685,738,350,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,358 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgsem_reset(cgsem_t *cgsem)
{
int ret, fd;
fd_set rd;
char buf;
fd = cgsem->pipefd[0];
FD_ZERO(&rd);
FD_SET(fd, &rd);
do {
struct timeval timeout = {0, 0};
ret = select(fd + 1, &rd, NULL, NULL, &timeout);
if (ret > 0)
ret = read(fd, &buf, 1);
else if (unlikely(ret < 0 && interrupted()))
ret ... | 309,176,491,838,359,280,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,359 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgsleep_ms(int ms)
{
cgtimer_t ts_start;
cgsleep_prepare_r(&ts_start);
cgsleep_ms_r(&ts_start, ms);
}
| 133,830,659,668,054,970,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,360 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgsleep_ms_r(cgtimer_t *ts_start, int ms)
{
struct timespec ts_end;
ms_to_timespec(&ts_end, ms);
timeraddspec(&ts_end, ts_start);
nanosleep_abstime(&ts_end);
}
| 82,843,360,168,048,460,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,361 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | static void cgsleep_spec(struct timespec *ts_diff, const struct timespec *ts_start)
{
struct timespec now;
timeraddspec(ts_diff, ts_start);
cgtimer_time(&now);
timersubspec(ts_diff, &now);
if (unlikely(ts_diff->tv_sec < 0))
return;
nanosleep(ts_diff, NULL);
}
| 288,323,611,583,127,640,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,362 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgsleep_us(int64_t us)
{
cgtimer_t ts_start;
cgsleep_prepare_r(&ts_start);
cgsleep_us_r(&ts_start, us);
}
| 328,342,963,918,938,240,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,363 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgsleep_us_r(cgtimer_t *ts_start, int64_t us)
{
struct timespec ts_end;
us_to_timespec(&ts_end, us);
timeraddspec(&ts_end, ts_start);
nanosleep_abstime(&ts_end);
}
| 311,591,046,160,259,500,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,364 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgsleep_us_r(cgtimer_t *ts_start, int64_t us)
{
LARGE_INTEGER li;
int ms;
li.QuadPart = ts_start->QuadPart + us * 10LL;
ms = us / 1000;
if (!ms)
ms = 1;
liSleep(&li, ms);
}
| 26,821,745,522,164,800,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,365 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgsleep_us_r(cgtimer_t *ts_start, int64_t us)
{
struct timespec ts_diff;
us_to_timespec(&ts_diff, us);
cgsleep_spec(&ts_diff, ts_start);
}
| 99,583,156,558,942,440,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,366 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgtime(struct timeval *tv)
{
lldiv_t lidiv;
decius_time(&lidiv);
tv->tv_sec = lidiv.quot;
tv->tv_usec = lidiv.rem / 10;
}
| 217,956,323,482,728,000,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,367 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgtime(struct timeval *tv)
{
gettimeofday(tv, NULL);
}
| 216,363,767,882,916,400,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,368 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgtimer_sub(cgtimer_t *a, cgtimer_t *b, cgtimer_t *res)
{
res->tv_sec = a->tv_sec - b->tv_sec;
res->tv_nsec = a->tv_nsec - b->tv_nsec;
if (res->tv_nsec < 0) {
res->tv_nsec += 1000000000;
res->tv_sec--;
}
}
| 78,713,941,964,091,950,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,369 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgtimer_sub(cgtimer_t *a, cgtimer_t *b, cgtimer_t *res)
{
res->QuadPart = a->QuadPart - b->QuadPart;
}
| 235,349,115,383,379,940,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,370 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgtimer_time(cgtimer_t *ts_start)
{
clock_gettime(CLOCK_MONOTONIC, ts_start);
}
| 186,694,908,660,153,520,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,371 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgtimer_time(cgtimer_t *ts_start)
{
clock_serv_t cclock;
mach_timespec_t mts;
host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
clock_get_time(cclock, &mts);
mach_port_deallocate(mach_task_self(), cclock);
ts_start->tv_sec = mts.tv_sec;
ts_start->tv_nsec = mts.tv_nsec;
}
| 55,707,323,177,425,470,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,372 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void cgtimer_time(cgtimer_t *ts_start)
{
FILETIME ft;
GetSystemTimeAsFileTime(&ft);
ts_start->LowPart = ft.dwLowDateTime;
ts_start->HighPart = ft.dwHighDateTime;
}
| 96,392,766,171,207,790,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,373 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | int cgtimer_to_ms(cgtimer_t *cgt)
{
return timespec_to_ms(cgt);
}
| 60,051,363,455,061,810,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,374 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | static void clear_sock(struct pool *pool)
{
ssize_t n;
mutex_lock(&pool->stratum_lock);
do {
if (pool->sock)
n = recv(pool->sock, pool->sockbuf, RECVSIZE, 0);
else
n = 0;
} while (n > 0);
mutex_unlock(&pool->stratum_lock);
clear_sockbuf(pool);
}
| 272,243,193,257,376,930,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,375 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | static void clear_sockbuf(struct pool *pool)
{
strcpy(pool->sockbuf, "");
}
| 264,837,883,057,113,150,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,376 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void *completion_thread(void *arg)
{
struct cg_completion *cgc = (struct cg_completion *)arg;
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
cgc->fn(cgc->fnarg);
cgsem_post(&cgc->cgsem);
return NULL;
}
| 321,431,226,798,341,080,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,377 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void copy_time(struct timeval *dest, const struct timeval *src)
{
memcpy(dest, src, sizeof(struct timeval));
}
| 312,216,971,474,036,770,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,378 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | static int curl_debug_cb(__maybe_unused CURL *handle, curl_infotype type,
__maybe_unused char *data, size_t size, void *userdata)
{
struct pool *pool = (struct pool *)userdata;
switch(type) {
case CURLINFO_HEADER_IN:
case CURLINFO_DATA_IN:
case CURLINFO_SSL_DATA_IN:
pool->sgminer_pool_stats.net_bytes_re... | 298,328,443,220,402,800,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,379 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | static void databuf_free(struct data_buffer *db)
{
if (!db)
return;
free(db->buf);
memset(db, 0, sizeof(*db));
}
| 142,879,660,951,451,400,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,380 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | static void decius_time(lldiv_t *lidiv)
{
FILETIME ft;
LARGE_INTEGER li;
GetSystemTimeAsFileTime(&ft);
li.LowPart = ft.dwLowDateTime;
li.HighPart = ft.dwHighDateTime;
li.QuadPart -= EPOCHFILETIME;
/* SystemTime is in decimicroseconds so divide by an unusual number */
*lidiv = lldiv(li.QuadPart, 10000000);
}
| 303,542,090,295,155,400,000,000,000,000,000,000,000 | util.c | 79,021,405,279,685,970,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
37,381 | sgminer | 910c36089940e81fb85c65b8e63dcd2fac71470c | https://github.com/sgminer-dev/sgminer | https://github.com/sgminer-dev/sgminer/commit/910c36089940e81fb85c65b8e63dcd2fac71470c | stratum: parse_notify(): Don't die on malformed bbversion/prev_hash/nbit/ntime.
Might have introduced a memory leak, don't have time to check. :(
Should the other hex2bin()'s be checked?
Thanks to Mick Ayzenberg <mick.dejavusecurity.com> for finding this. | 0 | void dev_error(struct cgpu_info *dev, enum dev_reason reason)
{
dev->device_last_not_well = time(NULL);
dev->device_not_well_reason = reason;
switch (reason) {
case REASON_THREAD_FAIL_INIT:
dev->thread_fail_init_count++;
break;
case REASON_THREAD_ZERO_HASH:
dev->thread_zero_hash_count++;
break;
ca... | 205,121,026,764,766,870,000,000,000,000,000,000,000 | util.c | 122,106,294,667,611,740,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-4503 | The parse_notify function in util.c in sgminer before 4.2.2 and cgminer 3.3.0 through 4.0.1 allows man-in-the-middle attackers to cause a denial of service (application exit) via a crafted (1) bbversion, (2) prev_hash, (3) nbit, or (4) ntime parameter in a mining.notify action stratum message. | https://nvd.nist.gov/vuln/detail/CVE-2014-4503 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.