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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
31,108 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int mp_remove_one_port(struct uart_driver *drv, struct sb_uart_port *port)
{
struct sb_uart_state *state = drv->state + port->line;
if (state->port != port)
printk(KERN_ALERT "Removing wrong port: %p != %p\n",
state->port, port);
MP_MUTEX_LOCK(mp_mutex);
tty_unregister_device(drv->tty_driver, port->... | 120,232,236,028,395,060,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,109 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void mp_send_xchar(struct tty_struct *tty, char ch)
{
struct sb_uart_state *state = tty->driver_data;
struct sb_uart_port *port = state->port;
unsigned long flags;
if (port->ops->send_xchar)
port->ops->send_xchar(port, ch);
else {
port->x_char = ch;
if (ch) {
spin_lock_irqsave(&port->lock, flags);... | 4,667,713,700,178,597,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,110 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int mp_set_info(struct sb_uart_state *state, struct serial_struct *newinfo)
{
struct serial_struct new_serial;
struct sb_uart_port *port = state->port;
unsigned long new_port;
unsigned int change_irq, change_port, closing_wait;
unsigned int old_custom_divisor;
unsigned int old_flags, new_flags;
int retval... | 64,165,476,332,538,520,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,111 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void mp_set_termios(struct tty_struct *tty, struct MP_TERMIOS *old_termios)
{
struct sb_uart_state *state = tty->driver_data;
unsigned long flags;
unsigned int cflag = tty->termios.c_cflag;
#define RELEVANT_IFLAG(iflag) ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
if ((cflag ^ old_termios->c_cflag) == 0... | 271,132,538,799,777,000,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,112 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void mp_shutdown(struct sb_uart_state *state)
{
struct sb_uart_info *info = state->info;
struct sb_uart_port *port = state->port;
if (info->tty)
set_bit(TTY_IO_ERROR, &info->tty->flags);
if (info->flags & UIF_INITIALIZED) {
info->flags &= ~UIF_INITIALIZED;
if (!info->tty || (info->tty->termios.c_cfl... | 98,310,318,429,299,660,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,113 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void mp_start(struct tty_struct *tty)
{
__mp_start(tty);
}
| 50,161,775,406,079,540,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,114 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int mp_startup(struct sb_uart_state *state, int init_hw)
{
struct sb_uart_info *info = state->info;
struct sb_uart_port *port = state->port;
unsigned long page;
int retval = 0;
if (info->flags & UIF_INITIALIZED)
return 0;
if (info->tty)
set_bit(TTY_IO_ERROR, &info->tty->flags);
if (port->type == PO... | 192,434,748,925,967,200,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,115 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void mp_stop(struct tty_struct *tty)
{
struct sb_uart_state *state = tty->driver_data;
struct sb_uart_port *port = state->port;
unsigned long flags;
spin_lock_irqsave(&port->lock, flags);
port->ops->stop_tx(port);
spin_unlock_irqrestore(&port->lock, flags);
}
| 118,618,221,679,417,700,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,116 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void mp_tasklet_action(unsigned long data)
{
struct sb_uart_state *state = (struct sb_uart_state *)data;
struct tty_struct *tty;
printk("tasklet is called!\n");
tty = state->info->tty;
tty_wakeup(tty);
}
| 329,111,165,761,045,780,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,117 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void mp_throttle(struct tty_struct *tty)
{
struct sb_uart_state *state = tty->driver_data;
if (I_IXOFF(tty))
mp_send_xchar(tty, STOP_CHAR(tty));
if (tty->termios.c_cflag & CRTSCTS)
uart_clear_mctrl(state->port, TIOCM_RTS);
}
| 143,361,300,488,100,670,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,118 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int mp_tiocmget(struct tty_struct *tty)
{
struct sb_uart_state *state = tty->driver_data;
struct sb_uart_port *port = state->port;
int result = -EIO;
MP_STATE_LOCK(state);
if (!(tty->flags & (1 << TTY_IO_ERROR))) {
result = port->mctrl;
spin_lock_irq(&port->lock);
result |= port->ops->get_mctrl(port)... | 143,220,648,820,543,160,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,119 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int mp_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)
{
struct sb_uart_state *state = tty->driver_data;
struct sb_uart_port *port = state->port;
int ret = -EIO;
MP_STATE_LOCK(state);
if (!(tty->flags & (1 << TTY_IO_ERROR))) {
mp_update_mctrl(port, set, clear);
ret = 0;
}
MP_S... | 201,997,836,613,580,070,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,120 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void mp_unconfigure_port(struct uart_driver *drv, struct sb_uart_state *state)
{
struct sb_uart_port *port = state->port;
struct sb_uart_info *info = state->info;
if (info && info->tty)
tty_hangup(info->tty);
MP_STATE_LOCK(state);
state->info = NULL;
if (port->type != PORT_UNKNOWN)
port->ops->relea... | 252,631,785,800,666,880,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,121 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | void mp_unregister_driver(struct uart_driver *drv)
{
struct tty_driver *normal = NULL;
normal = drv->tty_driver;
if (!normal)
{
return;
}
tty_unregister_driver(normal);
put_tty_driver(normal);
drv->tty_driver = NULL;
if (drv->state)
{
kfree(drv->state);
}... | 232,827,615,737,491,340,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,122 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void mp_unthrottle(struct tty_struct *tty)
{
struct sb_uart_state *state = tty->driver_data;
struct sb_uart_port *port = state->port;
if (I_IXOFF(tty)) {
if (port->x_char)
port->x_char = 0;
else
mp_send_xchar(tty, START_CHAR(tty));
}
if (tty->termios.c_cflag & CRTSCTS)
uart_set_mctrl(port, TIO... | 49,330,281,228,001,520,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,123 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static inline void mp_update_mctrl(struct sb_uart_port *port, unsigned int set, unsigned int clear)
{
unsigned int old;
old = port->mctrl;
port->mctrl = (old & ~clear) | set;
if (old != port->mctrl)
port->ops->set_mctrl(port, port->mctrl);
}
| 315,305,718,615,219,870,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,124 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void mp_update_termios(struct sb_uart_state *state)
{
struct tty_struct *tty = state->info->tty;
struct sb_uart_port *port = state->port;
if (!(tty->flags & (1 << TTY_IO_ERROR))) {
mp_change_speed(state, NULL);
if (tty->termios.c_cflag & CBAUD)
uart_set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
}
}
| 13,314,824,312,465,992,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,125 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int mp_wait_modem_status(struct sb_uart_state *state, unsigned long arg)
{
struct sb_uart_port *port = state->port;
DECLARE_WAITQUEUE(wait, current);
struct sb_uart_icount cprev, cnow;
int ret;
spin_lock_irq(&port->lock);
memcpy(&cprev, &port->icount, sizeof(struct sb_uart_icount));
port->ops->enable_ms... | 238,081,621,721,032,760,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,126 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void mp_wait_until_sent(struct tty_struct *tty, int timeout)
{
struct sb_uart_state *state = tty->driver_data;
struct sb_uart_port *port = state->port;
unsigned long char_time, expire;
if (port->type == PORT_UNKNOWN || port->fifosize == 0)
return;
char_time = (port->timeout - HZ/50) / port->fifosize;
c... | 16,129,388,505,185,132,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,127 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int mp_write(struct tty_struct *tty, const unsigned char *buf, int count)
{
struct sb_uart_state *state = tty->driver_data;
struct sb_uart_port *port;
struct circ_buf *circ;
int c, ret = 0;
if (!state || !state->info) {
return -EL3HLT;
}
port = state->port;
circ = &state->info->xmit;
if (!circ->buf... | 56,388,172,839,657,870,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,128 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int mp_write_room(struct tty_struct *tty)
{
struct sb_uart_state *state = tty->driver_data;
return uart_circ_chars_free(&state->info->xmit);
}
| 28,415,461,428,344,565,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,129 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void multi_break_ctl(struct sb_uart_port *port, int break_state)
{
struct mp_port *mtpt = (struct mp_port *)port;
unsigned long flags;
spin_lock_irqsave(&mtpt->port.lock, flags);
if (break_state == -1)
mtpt->lcr |= UART_LCR_SBC;
else
mtpt->lcr &= ~UART_LCR_SBC;
serial_out(mtpt, UART_LCR, mtpt->lcr);
... | 286,247,438,168,801,860,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,130 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void multi_config_port(struct sb_uart_port *port, int flags)
{
struct mp_port *mtpt = (struct mp_port *)port;
int probeflags = PROBE_ANY;
if (flags & UART_CONFIG_TYPE)
autoconfig(mtpt, probeflags);
if (mtpt->port.type != PORT_UNKNOWN && flags & UART_CONFIG_IRQ)
autoconfig_irq(mtpt);
if (mtpt->port.typ... | 100,950,485,987,911,650,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,131 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void multi_enable_ms(struct sb_uart_port *port)
{
struct mp_port *mtpt = (struct mp_port *)port;
mtpt->ier |= UART_IER_MSI;
serial_out(mtpt, UART_IER, mtpt->ier);
}
| 257,022,026,939,016,700,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,132 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void __exit multi_exit(void)
{
int i;
for (i = 0; i < NR_PORTS; i++)
mp_remove_one_port(&multi_reg, &multi_ports[i].port);
mp_unregister_driver(&multi_reg);
}
| 256,345,706,136,356,750,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,133 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static unsigned int multi_get_divisor(struct sb_uart_port *port, unsigned int baud)
{
unsigned int quot;
if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
baud == (port->uartclk/4))
quot = 0x8001;
else if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
baud == (port->uartclk/8))
quot = 0x8002;
else
quot = sb_uart_g... | 98,219,879,961,057,310,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,134 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static unsigned int multi_get_mctrl(struct sb_uart_port *port)
{
struct mp_port *mtpt = (struct mp_port *)port;
unsigned char status;
unsigned int ret;
status = serial_in(mtpt, UART_MSR);
ret = 0;
if (status & UART_MSR_DCD)
ret |= TIOCM_CAR;
if (status & UART_MSR_RI)
ret |= TIOCM_RNG;
if (status & UART_MS... | 43,129,376,654,895,590,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,135 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static inline void multi_handle_port(struct mp_port *mtpt)
{
unsigned int status = serial_inp(mtpt, UART_LSR);
if ((status & UART_LSR_DR) || (status & UART_LSR_SPECIAL))
receive_chars(mtpt, &status);
check_modem_status(mtpt);
if (status & UART_LSR_THRE)
{
if ((mtpt->port.type == PORT_16C105X)
|| (mtpt->po... | 333,131,081,456,271,580,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,136 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int __init multi_init(void)
{
int ret, i;
struct pci_dev *dev = NULL;
if(fcr_count==0)
{
for(i=0;i<256;i++)
{
fcr_arr[i] = 0x01;
}
}
if(deep_count==0)
{
for(i=0;i<256;i++)
{
deep[i] = 1;
}
}
if(rtr_count==0)
{
for(i=0;i<256;i++)
{
... | 11,921,350,654,344,440,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,137 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void __init multi_init_ports(void)
{
struct mp_port *mtpt;
static int first = 1;
int i,j,k;
unsigned char osc;
unsigned char b_ret = 0;
static struct mp_device_t *sbdev;
if (!first)
return;
first = 0;
mtpt = multi_ports;
for (k=0;k<NR_BOARD;k++)
{
sbdev = &mp_devs[k];
for (i = 0; i < sbdev... | 178,232,690,095,627,830,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,138 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static irqreturn_t multi_interrupt(int irq, void *dev_id)
{
struct irq_info *iinfo = dev_id;
struct list_head *lhead, *end = NULL;
int pass_counter = 0;
spin_lock(&iinfo->lock);
lhead = iinfo->head;
do {
struct mp_port *mtpt;
unsigned int iir;
mtpt = list_entry(lhead, struct mp_port, list);
iir = s... | 314,152,705,111,699,150,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,139 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void multi_pm(struct sb_uart_port *port, unsigned int state, unsigned int oldstate)
{
struct mp_port *mtpt = (struct mp_port *)port;
if (state) {
if (mtpt->capabilities & UART_STARTECH) {
serial_outp(mtpt, UART_LCR, 0xBF);
serial_outp(mtpt, UART_EFR, UART_EFR_ECB);
serial_outp(mtpt, UART_LCR, 0);
... | 269,182,641,639,425,850,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,140 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void __init multi_register_ports(struct uart_driver *drv)
{
int i;
multi_init_ports();
for (i = 0; i < NR_PORTS; i++) {
struct mp_port *mtpt = &multi_ports[i];
mtpt->port.line = i;
mtpt->port.ops = &multi_pops;
init_timer(&mtpt->timer);
mtpt->timer.function = multi_timeout;
mp_add_one_port(drv,... | 295,970,491,379,814,100,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,141 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void multi_release_port(struct sb_uart_port *port)
{
}
| 147,028,099,641,090,220,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,142 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int multi_request_port(struct sb_uart_port *port)
{
return 0;
}
| 194,365,103,569,446,560,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,143 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void multi_set_mctrl(struct sb_uart_port *port, unsigned int mctrl)
{
struct mp_port *mtpt = (struct mp_port *)port;
unsigned char mcr = 0;
mctrl &= 0xff;
if (mctrl & TIOCM_RTS)
mcr |= UART_MCR_RTS;
if (mctrl & TIOCM_DTR)
mcr |= UART_MCR_DTR;
if (mctrl & TIOCM_OUT1)
mcr |= UART_MCR_OUT1;
if (mctrl... | 134,620,147,501,160,380,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,144 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void multi_set_termios(struct sb_uart_port *port, struct MP_TERMIOS *termios, struct MP_TERMIOS *old)
{
struct mp_port *mtpt = (struct mp_port *)port;
unsigned char cval, fcr = 0;
unsigned long flags;
unsigned int baud, quot;
switch (termios->c_cflag & CSIZE) {
case CS5:
cval = 0x00;
break;
case ... | 311,816,016,857,681,900,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,145 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void multi_shutdown(struct sb_uart_port *port)
{
struct mp_port *mtpt = (struct mp_port *)port;
unsigned long flags;
mtpt->ier = 0;
serial_outp(mtpt, UART_IER, 0);
spin_lock_irqsave(&mtpt->port.lock, flags);
mtpt->port.mctrl &= ~TIOCM_OUT2;
multi_set_mctrl(&mtpt->port, mtpt->port.mctrl);
spin_unlock_... | 175,517,663,764,616,300,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,146 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void multi_start_tx(struct sb_uart_port *port)
{
struct mp_port *mtpt = (struct mp_port *)port;
if (!(mtpt->ier & UART_IER_THRI)) {
mtpt->ier |= UART_IER_THRI;
serial_out(mtpt, UART_IER, mtpt->ier);
}
}
| 262,880,618,050,077,800,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,147 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void multi_stop_rx(struct sb_uart_port *port)
{
struct mp_port *mtpt = (struct mp_port *)port;
mtpt->ier &= ~UART_IER_RLSI;
mtpt->port.read_status_mask &= ~UART_LSR_DR;
serial_out(mtpt, UART_IER, mtpt->ier);
}
| 316,473,349,109,475,770,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,148 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void multi_stop_tx(struct sb_uart_port *port)
{
struct mp_port *mtpt = (struct mp_port *)port;
if (mtpt->ier & UART_IER_THRI) {
mtpt->ier &= ~UART_IER_THRI;
serial_out(mtpt, UART_IER, mtpt->ier);
}
tasklet_schedule(&port->info->tlet);
}
| 324,437,524,817,612,800,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,149 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static void multi_timeout(unsigned long data)
{
struct mp_port *mtpt = (struct mp_port *)data;
spin_lock(&mtpt->port.lock);
multi_handle_port(mtpt);
spin_unlock(&mtpt->port.lock);
mod_timer(&mtpt->timer, jiffies+1 );
}
| 158,961,727,770,467,500,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,150 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static unsigned int multi_tx_empty(struct sb_uart_port *port)
{
struct mp_port *mtpt = (struct mp_port *)port;
unsigned long flags;
unsigned int ret;
spin_lock_irqsave(&mtpt->port.lock, flags);
ret = serial_in(mtpt, UART_LSR) & UART_LSR_TEMT ? TIOCSER_TEMT : 0;
spin_unlock_irqrestore(&mtpt->port.lock, flags);
... | 162,835,077,901,011,650,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,151 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static const char *multi_type(struct sb_uart_port *port)
{
int type = port->type;
if (type >= ARRAY_SIZE(uart_config))
type = 0;
return uart_config[type].name;
}
| 126,279,070,966,884,850,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,152 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int multi_verify_port(struct sb_uart_port *port, struct serial_struct *ser)
{
if (ser->irq >= NR_IRQS || ser->irq < 0 ||
ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
ser->type == PORT_STARTECH)
return -EINVAL;
return 0;
}
| 23,993,121,144,838,293,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,153 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static _INLINE_ unsigned int read_option_register(struct mp_port *mtpt, int offset)
{
return inb(mtpt->option_base_addr + offset);
}
| 129,090,519,286,749,660,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,154 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static _INLINE_ void receive_chars(struct mp_port *mtpt, int *status )
{
struct tty_struct *tty = mtpt->port.info->tty;
unsigned char lsr = *status;
int max_count = 256;
unsigned char ch;
char flag;
do {
if ((lsr & UART_LSR_PE) && (mtpt->port.mdmode & MDMODE_ENABLE))
{
ch = serial_inp(mtpt, UART_RX);
}... | 20,107,234,163,537,494,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,155 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int sb1053a_get_interface(struct mp_port *mtpt, int port_num)
{
unsigned long option_base_addr = mtpt->option_base_addr;
unsigned int interface = 0;
switch (port_num)
{
case 0:
case 1:
/* set GPO[1:0] = 00 */
outb(0x00, option_base_addr + MP_OPTR_GPODR);
break;
case 2:
case 3:
/* set GP... | 71,578,465,209,394,670,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,156 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int sb1054_set_register(struct sb_uart_port *port, int page, int reg, int value)
{
int lcr = 0;
int mcr = 0;
int ret = 0;
if( page <= 0)
{
printk(" page 0 can not use this fuction\n");
return -1;
}
switch(page)
{
case 1:
lcr = SB105X_GET_LCR(port);
SB105X_PUT_LCR(port, lcr | SB105X_LCR_DLA... | 331,798,875,225,535,130,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,157 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static _INLINE_ unsigned int serial_in(struct mp_port *mtpt, int offset)
{
return inb(mtpt->port.iobase + offset);
}
| 267,477,032,895,073,450,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,158 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int serial_link_irq_chain(struct mp_port *mtpt)
{
struct irq_info *i = irq_lists + mtpt->port.irq;
int ret, irq_flags = mtpt->port.flags & UPF_SHARE_IRQ ? IRQF_SHARED : 0;
spin_lock_irq(&i->lock);
if (i->head) {
list_add(&mtpt->list, i->head);
spin_unlock_irq(&i->lock);
ret = 0;
} else {
INIT_LIST... | 96,772,779,459,440,460,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,159 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int set_auto_rts(struct sb_uart_port *port, int status)
{
int atr_status = 0;
#if 0
int efr_status = 0;
efr_status = sb1054_get_register(port, PAGE_3, SB105X_EFR);
if(status == ENABLE)
efr_status |= SB105X_EFR_ARTS;
else
efr_status &= ~SB105X_EFR_ARTS;
sb1054_set_register(port,PAGE_3,SB105X_EFR,efr_s... | 211,048,684,464,135,830,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,160 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int set_deep_fifo(struct sb_uart_port *port, int status)
{
int afr_status = 0;
afr_status = sb1054_get_register(port, PAGE_4, SB105X_AFR);
if(status == ENABLE)
{
afr_status |= SB105X_AFR_AFEN;
}
else
{
afr_status &= ~SB105X_AFR_AFEN;
}
sb1054_set_register(port,PAGE_4,SB105X_AFR,afr_status);
sb1... | 156,450,241,696,734,130,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,161 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int set_multidrop_addr(struct sb_uart_port *port, unsigned int addr)
{
sb1054_set_register(port, PAGE_3, SB105X_XOFF2, addr);
return 0;
}
| 130,784,027,377,050,680,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,162 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static int set_multidrop_mode(struct sb_uart_port *port, unsigned int mode)
{
int mdr = SB105XA_MDR_NPS;
if (mode & MDMODE_ENABLE)
{
mdr |= SB105XA_MDR_MDE;
}
if (1) //(mode & MDMODE_AUTO)
{
int efr = 0;
mdr |= SB105XA_MDR_AME;
efr = sb1054_get_register(port, PAGE_3, SB105X_EFR);
efr |= SB105X_EFR_SCD... | 328,492,724,355,081,950,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,163 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static _INLINE_ void transmit_chars(struct mp_port *mtpt)
{
struct circ_buf *xmit = &mtpt->port.info->xmit;
int count;
if (mtpt->port.x_char) {
serial_outp(mtpt, UART_TX, mtpt->port.x_char);
mtpt->port.icount.tx++;
mtpt->port.x_char = 0;
return;
}
if (uart_circ_empty(xmit) || uart_tx_stopped(&mtpt->port))... | 1,759,575,073,135,756,300,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,164 | linux | a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a8b33654b1e3b0c74d4a1fed041c9aae50b3c427 | Staging: sb105x: info leak in mp_get_count()
The icount.reserved[] array isn't initialized so it leaks stack
information to userspace.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Li... | 0 | static struct sb_uart_state *uart_get(struct uart_driver *drv, int line)
{
struct sb_uart_state *state;
MP_MUTEX_LOCK(mp_mutex);
state = drv->state + line;
if (mutex_lock_interruptible(&state->mutex)) {
state = ERR_PTR(-ERESTARTSYS);
goto out;
}
state->count++;
if (!state->port) {
state->count--;
MP_STA... | 240,680,334,935,154,000,000,000,000,000,000,000,000 | None | null | [
"CWE-200"
] | CVE-2013-4516 | The mp_get_count function in drivers/staging/sb105x/sb_pci_mp.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel stack memory via a TIOCGICOUNT ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4516 |
31,165 | linux | 8d1e72250c847fa96498ec029891de4dc638a5ba | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8d1e72250c847fa96498ec029891de4dc638a5ba | Staging: bcm: info leak in ioctl
The DevInfo.u32Reserved[] array isn't initialized so it leaks kernel
information to user space.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus To... | 0 | static int bcm_char_open(struct inode *inode, struct file *filp)
{
struct bcm_mini_adapter *Adapter = NULL;
struct bcm_tarang_data *pTarang = NULL;
Adapter = GET_BCM_ADAPTER(gblpnetdev);
pTarang = kzalloc(sizeof(struct bcm_tarang_data), GFP_KERNEL);
if (!pTarang)
return -ENOMEM;
pTarang->Adapter = Adapter;
p... | 76,788,431,290,758,730,000,000,000,000,000,000,000 | Bcmchar.c | 323,504,708,855,947,280,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-4515 | The bcm_char_ioctl function in drivers/staging/bcm/Bcmchar.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via an IOCTL_BCM_GET_DEVICE_DRIVER_INFO ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4515 |
31,166 | linux | 8d1e72250c847fa96498ec029891de4dc638a5ba | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8d1e72250c847fa96498ec029891de4dc638a5ba | Staging: bcm: info leak in ioctl
The DevInfo.u32Reserved[] array isn't initialized so it leaks kernel
information to user space.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus To... | 0 | static ssize_t bcm_char_read(struct file *filp, char __user *buf, size_t size,
loff_t *f_pos)
{
struct bcm_tarang_data *pTarang = filp->private_data;
struct bcm_mini_adapter *Adapter = pTarang->Adapter;
struct sk_buff *Packet = NULL;
ssize_t PktLen = 0;
int wait_ret_val = 0;
unsigned long ret = 0;
wait_... | 102,182,103,804,204,310,000,000,000,000,000,000,000 | Bcmchar.c | 323,504,708,855,947,280,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-4515 | The bcm_char_ioctl function in drivers/staging/bcm/Bcmchar.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via an IOCTL_BCM_GET_DEVICE_DRIVER_INFO ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4515 |
31,167 | linux | 8d1e72250c847fa96498ec029891de4dc638a5ba | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8d1e72250c847fa96498ec029891de4dc638a5ba | Staging: bcm: info leak in ioctl
The DevInfo.u32Reserved[] array isn't initialized so it leaks kernel
information to user space.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus To... | 0 | static int bcm_char_release(struct inode *inode, struct file *filp)
{
struct bcm_tarang_data *pTarang, *tmp, *ptmp;
struct bcm_mini_adapter *Adapter = NULL;
struct sk_buff *pkt, *npkt;
pTarang = (struct bcm_tarang_data *)filp->private_data;
if (pTarang == NULL) {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,... | 112,867,088,208,128,800,000,000,000,000,000,000,000 | Bcmchar.c | 323,504,708,855,947,280,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-4515 | The bcm_char_ioctl function in drivers/staging/bcm/Bcmchar.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via an IOCTL_BCM_GET_DEVICE_DRIVER_INFO ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4515 |
31,168 | linux | 8d1e72250c847fa96498ec029891de4dc638a5ba | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8d1e72250c847fa96498ec029891de4dc638a5ba | Staging: bcm: info leak in ioctl
The DevInfo.u32Reserved[] array isn't initialized so it leaks kernel
information to user space.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus To... | 0 | int register_control_device_interface(struct bcm_mini_adapter *Adapter)
{
if (Adapter->major > 0)
return Adapter->major;
Adapter->major = register_chrdev(0, DEV_NAME, &bcm_fops);
if (Adapter->major < 0) {
pr_err(DRV_NAME ": could not created character device\n");
return Adapter->major;
}
Adapter->pstCreat... | 224,908,380,340,429,700,000,000,000,000,000,000,000 | Bcmchar.c | 323,504,708,855,947,280,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-4515 | The bcm_char_ioctl function in drivers/staging/bcm/Bcmchar.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via an IOCTL_BCM_GET_DEVICE_DRIVER_INFO ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4515 |
31,169 | linux | 8d1e72250c847fa96498ec029891de4dc638a5ba | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8d1e72250c847fa96498ec029891de4dc638a5ba | Staging: bcm: info leak in ioctl
The DevInfo.u32Reserved[] array isn't initialized so it leaks kernel
information to user space.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus To... | 0 | void unregister_control_device_interface(struct bcm_mini_adapter *Adapter)
{
if (Adapter->major > 0) {
device_destroy(bcm_class, MKDEV(Adapter->major, 0));
unregister_chrdev(Adapter->major, DEV_NAME);
}
}
| 48,947,166,508,135,520,000,000,000,000,000,000,000 | Bcmchar.c | 323,504,708,855,947,280,000,000,000,000,000,000,000 | [
"CWE-200"
] | CVE-2013-4515 | The bcm_char_ioctl function in drivers/staging/bcm/Bcmchar.c in the Linux kernel before 3.12 does not initialize a certain data structure, which allows local users to obtain sensitive information from kernel memory via an IOCTL_BCM_GET_DEVICE_DRIVER_INFO ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2013-4515 |
31,170 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int cfg_driver_identity(struct uilreq *urq, struct wl_private *lp)
{
int result = 0;
/*------------------------------------------------------------------------*/
DBG_FUNC("wvlan_driver_identity");
DBG_ENTER(DbgInfo);
/* Make sure that user buffer can handle the driver identity structure. */
if (urq->len < siz... | 311,790,378,576,896,500,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,171 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int cfg_driver_info(struct uilreq *urq, struct wl_private *lp)
{
int result = 0;
/*------------------------------------------------------------------------*/
DBG_FUNC("cfg_driver_info");
DBG_ENTER(DbgInfo);
/* Make sure that user buffer can handle the driver information buffer */
if (urq->len < sizeof(lp->dri... | 52,208,744,735,322,300,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,172 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int wvlan_get_netname(struct net_device *dev,
struct iw_request_info *info,
union iwreq_data *wrqu,
char *extra)
{
struct wl_private *lp = wl_priv(dev);
unsigned long flags;
int ret = 0;
int status = -1;
wvName_t *pName;
/*-------------------------------------------------... | 11,031,645,781,492,014,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,173 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int wvlan_get_porttype(struct net_device *dev,
struct iw_request_info *info,
union iwreq_data *wrqu,
char *extra)
{
struct wl_private *lp = wl_priv(dev);
unsigned long flags;
int ret = 0;
int status = -1;
hcf_16 *pPortType;
__u32 *pData = (__u32 *)extra;
/*-----------------------... | 302,818,679,979,249,000,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,174 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int wvlan_get_station_nickname(struct net_device *dev,
struct iw_request_info *info,
union iwreq_data *wrqu,
char *extra)
{
struct wl_private *lp = wl_priv(dev);
unsigned long flags;
int ret = 0;
int status = -1;
wvName_t *pName;
/*----------------------------------------... | 151,111,242,493,129,960,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,175 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int wvlan_rts(struct rtsreq *rrq, __u32 io_base)
{
int ioctl_ret = 0;
/*------------------------------------------------------------------------*/
DBG_FUNC("wvlan_rts");
DBG_ENTER(DbgInfo);
DBG_PRINT("io_base: 0x%08x\n", io_base);
switch (rrq->typ) {
case WL_IOCTL_RTS_READ:
DBG_TRACE(DbgInfo, "IOCTL: WVLA... | 325,155,243,105,003,400,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,176 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int wvlan_set_netname(struct net_device *dev,
struct iw_request_info *info,
union iwreq_data *wrqu,
char *extra)
{
struct wl_private *lp = wl_priv(dev);
unsigned long flags;
int ret = 0;
/*------------------------------------------------------------------------*/
DBG_FUNC("wvlan_set_netna... | 162,205,244,003,191,240,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,177 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int wvlan_set_porttype(struct net_device *dev,
struct iw_request_info *info,
union iwreq_data *wrqu,
char *extra)
{
struct wl_private *lp = wl_priv(dev);
unsigned long flags;
int ret = 0;
hcf_16 portType;
/*------------------------------------------------------------------------*/
D... | 113,720,671,387,671,640,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,178 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int wvlan_uil_block(struct uilreq *urq, struct wl_private *lp)
{
int result = 0;
/*------------------------------------------------------------------------*/
DBG_FUNC("wvlan_uil_block");
DBG_ENTER(DbgInfo);
if (urq->hcfCtx == &(lp->hcfCtx)) {
if (capable(CAP_NET_ADMIN)) {
lp->flags |= WVLAN2_UIL_BUSY;
n... | 323,201,984,117,927,600,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,179 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int wvlan_uil_connect(struct uilreq *urq, struct wl_private *lp)
{
int result = 0;
/*------------------------------------------------------------------------*/
DBG_FUNC("wvlan_uil_connect");
DBG_ENTER(DbgInfo);
if (!(lp->flags & WVLAN2_UIL_CONNECTED)) {
lp->flags |= WVLAN2_UIL_CONNECTED;
urq->hcfCtx = &(lp... | 20,511,494,623,221,748,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,180 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int wvlan_uil_disconnect(struct uilreq *urq, struct wl_private *lp)
{
int result = 0;
/*------------------------------------------------------------------------*/
DBG_FUNC("wvlan_uil_disconnect");
DBG_ENTER(DbgInfo);
if (urq->hcfCtx == &(lp->hcfCtx)) {
if (lp->flags & WVLAN2_UIL_CONNECTED) {
lp->flags &= ... | 70,205,949,986,714,300,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,181 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int wvlan_uil_get_info(struct uilreq *urq, struct wl_private *lp)
{
int result = 0;
int i;
/*------------------------------------------------------------------------*/
DBG_FUNC("wvlan_uil_get_info");
DBG_ENTER(DbgInfo);
if (urq->hcfCtx == &(lp->hcfCtx)) {
if ((urq->data != NULL) && (urq->len != 0)) {
ltv_t... | 64,944,830,359,553,800,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,182 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int wvlan_uil_send_diag_msg(struct uilreq *urq, struct wl_private *lp)
{
int result = 0;
DESC_STRCT Descp[1];
/*------------------------------------------------------------------------*/
DBG_FUNC("wvlan_uil_send_diag_msg");
DBG_ENTER(DbgInfo);
if (urq->hcfCtx == &(lp->hcfCtx)) {
if (capable(CAP_NET_... | 266,245,312,541,969,200,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,183 | linux | b5e2f339865fb443107e5b10603e53bbc92dc054 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b5e2f339865fb443107e5b10603e53bbc92dc054 | staging: wlags49_h2: buffer overflow setting station name
We need to check the length parameter before doing the memcpy(). I've
actually changed it to strlcpy() as well so that it's NUL terminated.
You need CAP_NET_ADMIN to trigger these so it's not the end of the
world.
Reported-by: Nico Golde <nico@ngolde.de>
Rep... | 0 | int wvlan_uil_unblock(struct uilreq *urq, struct wl_private *lp)
{
int result = 0;
/*------------------------------------------------------------------------*/
DBG_FUNC("wvlan_uil_unblock");
DBG_ENTER(DbgInfo);
if (urq->hcfCtx == &(lp->hcfCtx)) {
if (capable(CAP_NET_ADMIN)) {
if (lp->flags & WVLAN2_UIL_BUS... | 146,688,665,975,269,610,000,000,000,000,000,000,000 | wl_priv.c | 60,757,582,669,243,510,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4514 | Multiple buffer overflows in drivers/staging/wlags49_h2/wl_priv.c in the Linux kernel before 3.12 allow local users to cause a denial of service or possibly have unspecified other impact by leveraging the CAP_NET_ADMIN capability and providing a long station-name string, related to the (1) wvlan_uil_put_info and (2) wv... | https://nvd.nist.gov/vuln/detail/CVE-2013-4514 |
31,184 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | static struct oz_serial_ctx *oz_cdev_claim_ctx(struct oz_pd *pd)
{
struct oz_serial_ctx *ctx;
spin_lock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
ctx = (struct oz_serial_ctx *)pd->app_ctx[OZ_APPID_SERIAL-1];
if (ctx)
atomic_inc(&ctx->ref_count);
spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
return ctx;
}
| 38,850,157,370,285,715,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,185 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | int oz_cdev_deregister(void)
{
cdev_del(&g_cdev.cdev);
unregister_chrdev_region(g_cdev.devnum, 1);
if (g_oz_class) {
device_destroy(g_oz_class, g_cdev.devnum);
class_destroy(g_oz_class);
}
return 0;
}
| 86,163,094,199,602,560,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,186 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | int oz_cdev_init(void)
{
oz_app_enable(OZ_APPID_SERIAL, 1);
return 0;
}
| 145,036,766,813,558,140,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,187 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | static long oz_cdev_ioctl(struct file *filp, unsigned int cmd,
unsigned long arg)
{
int rc = 0;
if (_IOC_TYPE(cmd) != OZ_IOCTL_MAGIC)
return -ENOTTY;
if (_IOC_NR(cmd) > OZ_IOCTL_MAX)
return -ENOTTY;
if (_IOC_DIR(cmd) & _IOC_READ)
rc = !access_ok(VERIFY_WRITE, (void __user *)arg,
_IOC_SIZE(cmd));
els... | 298,065,917,952,577,800,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,188 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | static int oz_cdev_open(struct inode *inode, struct file *filp)
{
struct oz_cdev *dev = container_of(inode->i_cdev, struct oz_cdev, cdev);
oz_dbg(ON, "major = %d minor = %d\n", imajor(inode), iminor(inode));
filp->private_data = dev;
return 0;
}
| 160,334,888,351,418,540,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,189 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | static unsigned int oz_cdev_poll(struct file *filp, poll_table *wait)
{
unsigned int ret = 0;
struct oz_cdev *dev = filp->private_data;
oz_dbg(ON, "Poll called wait = %p\n", wait);
spin_lock_bh(&dev->lock);
if (dev->active_pd) {
struct oz_serial_ctx *ctx = oz_cdev_claim_ctx(dev->active_pd);
if (ctx) {
if (... | 166,117,172,245,676,090,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,190 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | static ssize_t oz_cdev_read(struct file *filp, char __user *buf, size_t count,
loff_t *fpos)
{
int n;
int ix;
struct oz_pd *pd;
struct oz_serial_ctx *ctx;
spin_lock_bh(&g_cdev.lock);
pd = g_cdev.active_pd;
if (pd)
oz_pd_get(pd);
spin_unlock_bh(&g_cdev.lock);
if (pd == NULL)
return -1;
ctx = oz_cdev_cl... | 120,822,573,329,436,670,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,191 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | int oz_cdev_register(void)
{
int err;
struct device *dev;
memset(&g_cdev, 0, sizeof(g_cdev));
err = alloc_chrdev_region(&g_cdev.devnum, 0, 1, "ozwpan");
if (err < 0)
return err;
oz_dbg(ON, "Alloc dev number %d:%d\n",
MAJOR(g_cdev.devnum), MINOR(g_cdev.devnum));
cdev_init(&g_cdev.cdev, &oz_fops);
g_cd... | 175,346,694,143,183,560,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,192 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | static int oz_cdev_release(struct inode *inode, struct file *filp)
{
return 0;
}
| 165,355,376,615,856,600,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,193 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | static void oz_cdev_release_ctx(struct oz_serial_ctx *ctx)
{
if (atomic_dec_and_test(&ctx->ref_count)) {
oz_dbg(ON, "Dealloc serial context\n");
kfree(ctx);
}
}
| 227,653,740,511,248,500,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,194 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | void oz_cdev_rx(struct oz_pd *pd, struct oz_elt *elt)
{
struct oz_serial_ctx *ctx;
struct oz_app_hdr *app_hdr;
u8 *data;
int len;
int space;
int copy_sz;
int ix;
ctx = oz_cdev_claim_ctx(pd);
if (ctx == NULL) {
oz_dbg(ON, "Cannot claim serial context\n");
return;
}
app_hdr = (struct oz_app_hdr *)(elt+1)... | 230,439,563,788,095,740,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,195 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | int oz_cdev_start(struct oz_pd *pd, int resume)
{
struct oz_serial_ctx *ctx;
struct oz_serial_ctx *old_ctx;
if (resume) {
oz_dbg(ON, "Serial service resumed\n");
return 0;
}
ctx = kzalloc(sizeof(struct oz_serial_ctx), GFP_ATOMIC);
if (ctx == NULL)
return -ENOMEM;
atomic_set(&ctx->ref_count, 1);
ctx->tx_s... | 72,633,657,794,822,260,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,196 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | void oz_cdev_stop(struct oz_pd *pd, int pause)
{
struct oz_serial_ctx *ctx;
if (pause) {
oz_dbg(ON, "Serial service paused\n");
return;
}
spin_lock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
ctx = (struct oz_serial_ctx *)pd->app_ctx[OZ_APPID_SERIAL-1];
pd->app_ctx[OZ_APPID_SERIAL-1] = NULL;
spin_unlock_bh(&pd->a... | 252,178,694,595,868,020,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,197 | linux | c2c65cd2e14ada6de44cb527e7f1990bede24e15 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/c2c65cd2e14ada6de44cb527e7f1990bede24e15 | staging: ozwpan: prevent overflow in oz_cdev_write()
We need to check "count" so we don't overflow the ei->data buffer.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: stable@kernel.org
Signed-off-by: Linus Torvalds <t... | 0 | static int oz_set_active_pd(const u8 *addr)
{
int rc = 0;
struct oz_pd *pd;
struct oz_pd *old_pd;
pd = oz_pd_find(addr);
if (pd) {
spin_lock_bh(&g_cdev.lock);
memcpy(g_cdev.active_addr, addr, ETH_ALEN);
old_pd = g_cdev.active_pd;
g_cdev.active_pd = pd;
spin_unlock_bh(&g_cdev.lock);
if (old_pd)
oz_p... | 194,490,611,719,215,600,000,000,000,000,000,000,000 | ozcdev.c | 237,028,343,997,351,830,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4513 | Buffer overflow in the oz_cdev_write function in drivers/staging/ozwpan/ozcdev.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact via a crafted write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4513 |
31,198 | linux | 201f99f170df14ba52ea4c52847779042b7a623b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/201f99f170df14ba52ea4c52847779042b7a623b | uml: check length in exitcode_proc_write()
We don't cap the size of buffer from the user so we could write past the
end of the array here. Only root can write to this file.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
... | 0 | static int exitcode_proc_open(struct inode *inode, struct file *file)
{
return single_open(file, exitcode_proc_show, NULL);
}
| 127,100,223,749,924,930,000,000,000,000,000,000,000 | exitcode.c | 58,029,372,588,021,620,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4512 | Buffer overflow in the exitcode_proc_write function in arch/um/kernel/exitcode.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact by leveraging root privileges for a write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4512 |
31,199 | linux | 201f99f170df14ba52ea4c52847779042b7a623b | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/201f99f170df14ba52ea4c52847779042b7a623b | uml: check length in exitcode_proc_write()
We don't cap the size of buffer from the user so we could write past the
end of the array here. Only root can write to this file.
Reported-by: Nico Golde <nico@ngolde.de>
Reported-by: Fabian Yamaguchi <fabs@goesec.de>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
... | 0 | static int make_proc_exitcode(void)
{
struct proc_dir_entry *ent;
ent = proc_create("exitcode", 0600, NULL, &exitcode_proc_fops);
if (ent == NULL) {
printk(KERN_WARNING "make_proc_exitcode : Failed to register "
"/proc/exitcode\n");
return 0;
}
return 0;
}
| 302,344,989,327,846,280,000,000,000,000,000,000,000 | exitcode.c | 58,029,372,588,021,620,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2013-4512 | Buffer overflow in the exitcode_proc_write function in arch/um/kernel/exitcode.c in the Linux kernel before 3.12 allows local users to cause a denial of service or possibly have unspecified other impact by leveraging root privileges for a write operation. | https://nvd.nist.gov/vuln/detail/CVE-2013-4512 |
31,200 | linux | 6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | ipc,sem: fine grained locking for semtimedop
Introduce finer grained locking for semtimedop, to handle the common case
of a program wanting to manipulate one semaphore from an array with
multiple semaphores.
If the call is a semop manipulating just one semaphore in an array with
multiple semaphores, only take the loc... | 0 | SYSCALL_DEFINE2(msgget, key_t, key, int, msgflg)
{
struct ipc_namespace *ns;
struct ipc_ops msg_ops;
struct ipc_params msg_params;
ns = current->nsproxy->ipc_ns;
msg_ops.getnew = newque;
msg_ops.associate = msg_security;
msg_ops.more_checks = NULL;
msg_params.key = key;
msg_params.flg = msgflg;
return ipc... | 64,735,850,174,246,790,000,000,000,000,000,000,000 | msg.c | 134,253,663,128,864,880,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-4483 | The ipc_rcu_putref function in ipc/util.c in the Linux kernel before 3.10 does not properly manage a reference count, which allows local users to cause a denial of service (memory consumption or system crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-4483 |
31,201 | linux | 6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | ipc,sem: fine grained locking for semtimedop
Introduce finer grained locking for semtimedop, to handle the common case
of a program wanting to manipulate one semaphore from an array with
multiple semaphores.
If the call is a semop manipulating just one semaphore in an array with
multiple semaphores, only take the loc... | 0 | SYSCALL_DEFINE3(msgctl, int, msqid, int, cmd, struct msqid_ds __user *, buf)
{
struct msg_queue *msq;
int err, version;
struct ipc_namespace *ns;
if (msqid < 0 || cmd < 0)
return -EINVAL;
version = ipc_parse_version(&cmd);
ns = current->nsproxy->ipc_ns;
switch (cmd) {
case IPC_INFO:
case MSG_INFO:
{
st... | 328,248,333,079,297,540,000,000,000,000,000,000,000 | msg.c | 134,253,663,128,864,880,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-4483 | The ipc_rcu_putref function in ipc/util.c in the Linux kernel before 3.10 does not properly manage a reference count, which allows local users to cause a denial of service (memory consumption or system crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-4483 |
31,202 | linux | 6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | ipc,sem: fine grained locking for semtimedop
Introduce finer grained locking for semtimedop, to handle the common case
of a program wanting to manipulate one semaphore from an array with
multiple semaphores.
If the call is a semop manipulating just one semaphore in an array with
multiple semaphores, only take the loc... | 0 | SYSCALL_DEFINE5(msgrcv, int, msqid, struct msgbuf __user *, msgp, size_t, msgsz,
long, msgtyp, int, msgflg)
{
return do_msgrcv(msqid, msgp, msgsz, msgtyp, msgflg, do_msg_fill);
}
| 171,781,714,987,619,660,000,000,000,000,000,000,000 | msg.c | 134,253,663,128,864,880,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-4483 | The ipc_rcu_putref function in ipc/util.c in the Linux kernel before 3.10 does not properly manage a reference count, which allows local users to cause a denial of service (memory consumption or system crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-4483 |
31,203 | linux | 6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | ipc,sem: fine grained locking for semtimedop
Introduce finer grained locking for semtimedop, to handle the common case
of a program wanting to manipulate one semaphore from an array with
multiple semaphores.
If the call is a semop manipulating just one semaphore in an array with
multiple semaphores, only take the loc... | 0 | static inline int convert_mode(long *msgtyp, int msgflg)
{
if (msgflg & MSG_COPY)
return SEARCH_NUMBER;
/*
* find message of correct type.
* msgtyp = 0 => get first.
* msgtyp > 0 => get first message of matching type.
* msgtyp < 0 => get message with least type must be < abs(msgtype).
*/
if (*msgtyp ... | 101,811,647,498,297,770,000,000,000,000,000,000,000 | msg.c | 134,253,663,128,864,880,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-4483 | The ipc_rcu_putref function in ipc/util.c in the Linux kernel before 3.10 does not properly manage a reference count, which allows local users to cause a denial of service (memory consumption or system crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-4483 |
31,204 | linux | 6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | ipc,sem: fine grained locking for semtimedop
Introduce finer grained locking for semtimedop, to handle the common case
of a program wanting to manipulate one semaphore from an array with
multiple semaphores.
If the call is a semop manipulating just one semaphore in an array with
multiple semaphores, only take the loc... | 0 | copy_msqid_from_user(struct msqid64_ds *out, void __user *buf, int version)
{
switch(version) {
case IPC_64:
if (copy_from_user(out, buf, sizeof(*out)))
return -EFAULT;
return 0;
case IPC_OLD:
{
struct msqid_ds tbuf_old;
if (copy_from_user(&tbuf_old, buf, sizeof(tbuf_old)))
return -EFAULT;
out->ms... | 267,293,703,077,977,430,000,000,000,000,000,000,000 | msg.c | 134,253,663,128,864,880,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-4483 | The ipc_rcu_putref function in ipc/util.c in the Linux kernel before 3.10 does not properly manage a reference count, which allows local users to cause a denial of service (memory consumption or system crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-4483 |
31,205 | linux | 6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | ipc,sem: fine grained locking for semtimedop
Introduce finer grained locking for semtimedop, to handle the common case
of a program wanting to manipulate one semaphore from an array with
multiple semaphores.
If the call is a semop manipulating just one semaphore in an array with
multiple semaphores, only take the loc... | 0 | long do_msgrcv(int msqid, void __user *buf, size_t bufsz, long msgtyp,
int msgflg,
long (*msg_handler)(void __user *, struct msg_msg *, size_t))
{
struct msg_queue *msq;
struct msg_msg *msg;
int mode;
struct ipc_namespace *ns;
struct msg_msg *copy = NULL;
ns = current->nsproxy->ipc_ns;
if (msqi... | 32,481,990,840,618,590,000,000,000,000,000,000,000 | msg.c | 134,253,663,128,864,880,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-4483 | The ipc_rcu_putref function in ipc/util.c in the Linux kernel before 3.10 does not properly manage a reference count, which allows local users to cause a denial of service (memory consumption or system crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-4483 |
31,206 | linux | 6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | ipc,sem: fine grained locking for semtimedop
Introduce finer grained locking for semtimedop, to handle the common case
of a program wanting to manipulate one semaphore from an array with
multiple semaphores.
If the call is a semop manipulating just one semaphore in an array with
multiple semaphores, only take the loc... | 0 | static void expunge_all(struct msg_queue *msq, int res)
{
struct list_head *tmp;
tmp = msq->q_receivers.next;
while (tmp != &msq->q_receivers) {
struct msg_receiver *msr;
msr = list_entry(tmp, struct msg_receiver, r_list);
tmp = tmp->next;
msr->r_msg = NULL;
wake_up_process(msr->r_tsk);
smp_mb();
msr... | 308,615,549,642,143,860,000,000,000,000,000,000,000 | msg.c | 134,253,663,128,864,880,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-4483 | The ipc_rcu_putref function in ipc/util.c in the Linux kernel before 3.10 does not properly manage a reference count, which allows local users to cause a denial of service (memory consumption or system crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-4483 |
31,207 | linux | 6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6062a8dc0517bce23e3c2f7d2fea5e22411269a3 | ipc,sem: fine grained locking for semtimedop
Introduce finer grained locking for semtimedop, to handle the common case
of a program wanting to manipulate one semaphore from an array with
multiple semaphores.
If the call is a semop manipulating just one semaphore in an array with
multiple semaphores, only take the loc... | 0 | static struct msg_msg *find_msg(struct msg_queue *msq, long *msgtyp, int mode)
{
struct msg_msg *msg;
long count = 0;
list_for_each_entry(msg, &msq->q_messages, m_list) {
if (testmsg(msg, *msgtyp, mode) &&
!security_msg_queue_msgrcv(msq, msg, current,
*msgtyp, mode)) {
if (mode == SEARCH_LESS... | 222,992,376,980,879,400,000,000,000,000,000,000,000 | msg.c | 134,253,663,128,864,880,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2013-4483 | The ipc_rcu_putref function in ipc/util.c in the Linux kernel before 3.10 does not properly manage a reference count, which allows local users to cause a denial of service (memory consumption or system crash) via a crafted application. | https://nvd.nist.gov/vuln/detail/CVE-2013-4483 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.