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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
22,952 | linux | 1bb57e940e1958e40d51f2078f50c3a96a9b2d75 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1bb57e940e1958e40d51f2078f50c3a96a9b2d75 | dl2k: Clean up rio_ioctl
The dl2k driver's rio_ioctl call has a few issues:
- No permissions checking
- Implements SIOCGMIIREG and SIOCGMIIREG using the SIOCDEVPRIVATE numbers
- Has a few ioctls that may have been used for debugging at one point
but have no place in the kernel proper.
This patch removes all but the... | 0 | set_multicast (struct net_device *dev)
{
long ioaddr = dev->base_addr;
u32 hash_table[2];
u16 rx_mode = 0;
struct netdev_private *np = netdev_priv(dev);
hash_table[0] = hash_table[1] = 0;
/* RxFlowcontrol DA: 01-80-C2-00-00-01. Hash index=0x39 */
hash_table[1] |= 0x02000000;
if (dev->flags & IFF_PROMISC) {
/... | 146,283,265,998,513,980,000,000,000,000,000,000,000 | dl2k.c | 264,131,992,717,676,740,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2012-2313 | The rio_ioctl function in drivers/net/ethernet/dlink/dl2k.c in the Linux kernel before 3.3.7 does not restrict access to the SIOCSMIIREG command, which allows local users to write data to an Ethernet adapter via an ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2012-2313 |
22,953 | linux | 1bb57e940e1958e40d51f2078f50c3a96a9b2d75 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1bb57e940e1958e40d51f2078f50c3a96a9b2d75 | dl2k: Clean up rio_ioctl
The dl2k driver's rio_ioctl call has a few issues:
- No permissions checking
- Implements SIOCGMIIREG and SIOCGMIIREG using the SIOCDEVPRIVATE numbers
- Has a few ioctls that may have been used for debugging at one point
but have no place in the kernel proper.
This patch removes all but the... | 0 | start_xmit (struct sk_buff *skb, struct net_device *dev)
{
struct netdev_private *np = netdev_priv(dev);
struct netdev_desc *txdesc;
unsigned entry;
u32 ioaddr;
u64 tfc_vlan_tag = 0;
if (np->link_status == 0) { /* Link Down */
dev_kfree_skb(skb);
return NETDEV_TX_OK;
}
ioaddr = dev->base_addr;
entry = np-... | 181,195,423,312,700,650,000,000,000,000,000,000,000 | dl2k.c | 264,131,992,717,676,740,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2012-2313 | The rio_ioctl function in drivers/net/ethernet/dlink/dl2k.c in the Linux kernel before 3.3.7 does not restrict access to the SIOCSMIIREG command, which allows local users to write data to an Ethernet adapter via an ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2012-2313 |
22,954 | linux | 1bb57e940e1958e40d51f2078f50c3a96a9b2d75 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1bb57e940e1958e40d51f2078f50c3a96a9b2d75 | dl2k: Clean up rio_ioctl
The dl2k driver's rio_ioctl call has a few issues:
- No permissions checking
- Implements SIOCGMIIREG and SIOCGMIIREG using the SIOCDEVPRIVATE numbers
- Has a few ioctls that may have been used for debugging at one point
but have no place in the kernel proper.
This patch removes all but the... | 0 | tx_error (struct net_device *dev, int tx_status)
{
struct netdev_private *np;
long ioaddr = dev->base_addr;
int frame_id;
int i;
np = netdev_priv(dev);
frame_id = (tx_status & 0xffff0000);
printk (KERN_ERR "%s: Transmit error, TxStatus %4.4x, FrameId %d.\n",
dev->name, tx_status, frame_id);
np->stats.tx_err... | 247,170,952,551,945,300,000,000,000,000,000,000,000 | dl2k.c | 264,131,992,717,676,740,000,000,000,000,000,000,000 | [
"CWE-264"
] | CVE-2012-2313 | The rio_ioctl function in drivers/net/ethernet/dlink/dl2k.c in the Linux kernel before 3.3.7 does not restrict access to the SIOCSMIIREG command, which allows local users to write data to an Ethernet adapter via an ioctl call. | https://nvd.nist.gov/vuln/detail/CVE-2012-2313 |
22,955 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | __acquires(proto_list_mutex)
{
mutex_lock(&proto_list_mutex);
return seq_list_start_head(&proto_list, *pos);
}
| 206,440,470,410,385,800,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,956 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
{
struct dst_entry *dst = __sk_dst_get(sk);
if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
sk_tx_queue_clear(sk);
RCU_INIT_POINTER(sk->sk_dst_cache, NULL);
dst_release(dst);
return NULL;
}
return dst;
}
| 89,334,092,376,064,200,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,957 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int __sk_mem_schedule(struct sock *sk, int size, int kind)
{
struct proto *prot = sk->sk_prot;
int amt = sk_mem_pages(size);
long allocated;
int parent_status = UNDER_LIMIT;
sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
allocated = sk_memory_allocated_add(sk, amt, &parent_status);
/* Under limit. */
if (pare... | 280,088,059,252,102,000,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,958 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void assign_proto_idx(struct proto *prot)
{
prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
pr_err("PROTO_INUSE_NR exhausted\n");
return;
}
set_bit(prot->inuse_idx, proto_inuse_idx);
}
| 178,109,103,836,057,800,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,959 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static inline void assign_proto_idx(struct proto *prot)
{
}
| 338,247,018,155,175,440,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,960 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
char __user *optval, int __user *optlen)
{
struct sock *sk = sock->sk;
if (sk->sk_prot->compat_getsockopt != NULL)
return sk->sk_prot->compat_getsockopt(sk, level, optname,
optval, optlen);
return sk->sk_prot->getsock... | 255,598,197,237,840,300,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,961 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
char __user *optval, unsigned int optlen)
{
struct sock *sk = sock->sk;
if (sk->sk_prot->compat_setsockopt != NULL)
return sk->sk_prot->compat_setsockopt(sk, level, optname,
optval, optlen);
return sk->sk_prot->setsoc... | 213,429,122,026,459,300,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,962 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void cred_to_ucred(struct pid *pid, const struct cred *cred,
struct ucred *ucred)
{
ucred->pid = pid_vnr(pid);
ucred->uid = ucred->gid = -1;
if (cred) {
struct user_namespace *current_ns = current_user_ns();
ucred->uid = from_kuid(current_ns, cred->euid);
ucred->gid = from_kgid(current_ns, cred->egid);
... | 299,133,079,727,233,700,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,963 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | bool lock_sock_fast(struct sock *sk)
{
might_sleep();
spin_lock_bh(&sk->sk_lock.slock);
if (!sk->sk_lock.owned)
/*
* Note : We must disable BH
*/
return false;
__lock_sock(sk);
sk->sk_lock.owned = 1;
spin_unlock(&sk->sk_lock.slock);
/*
* The sk_lock has mutex_lock() semantics here:
*/
mutex_acqu... | 32,258,591,195,970,337,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,964 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void lock_sock_nested(struct sock *sk, int subclass)
{
might_sleep();
spin_lock_bh(&sk->sk_lock.slock);
if (sk->sk_lock.owned)
__lock_sock(sk);
sk->sk_lock.owned = 1;
spin_unlock(&sk->sk_lock.slock);
/*
* The sk_lock has mutex_lock() semantics here:
*/
mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_... | 236,426,750,588,760,100,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,965 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void mem_cgroup_sockets_destroy(struct mem_cgroup *memcg)
{
struct proto *proto;
mutex_lock(&proto_list_mutex);
list_for_each_entry_reverse(proto, &proto_list, node)
if (proto->destroy_cgroup)
proto->destroy_cgroup(memcg);
mutex_unlock(&proto_list_mutex);
}
| 306,278,289,918,981,830,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,966 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int mem_cgroup_sockets_init(struct mem_cgroup *memcg, struct cgroup_subsys *ss)
{
struct proto *proto;
int ret = 0;
mutex_lock(&proto_list_mutex);
list_for_each_entry(proto, &proto_list, node) {
if (proto->init_cgroup) {
ret = proto->init_cgroup(memcg, ss);
if (ret)
goto out;
}
}
mutex_unlock(&pro... | 244,036,457,362,753,940,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,967 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static __init int net_inuse_init(void)
{
if (register_pernet_subsys(&net_inuse_ops))
panic("Cannot initialize net inuse counters");
return 0;
}
| 135,545,765,662,416,200,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,968 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static __net_exit void proto_exit_net(struct net *net)
{
proc_net_remove(net, "protocols");
}
| 138,675,798,749,425,300,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,969 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static int __init proto_init(void)
{
return register_pernet_subsys(&proto_net_ops);
}
| 278,588,571,411,646,630,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,970 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static __net_init int proto_init_net(struct net *net)
{
if (!proc_net_fops_create(net, "protocols", S_IRUGO, &proto_seq_fops))
return -ENOMEM;
return 0;
}
| 87,018,196,605,856,420,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,971 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static char proto_method_implemented(const void *method)
{
return method == NULL ? 'n' : 'y';
}
| 326,439,584,892,035,100,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,972 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int proto_register(struct proto *prot, int alloc_slab)
{
if (alloc_slab) {
prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
SLAB_HWCACHE_ALIGN | prot->slab_flags,
NULL);
if (prot->slab == NULL) {
pr_crit("%s: Can't create sock SLAB cache!\n",
prot->name);
goto out;
}
if (prot... | 7,915,539,957,986,980,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,973 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
return seq_list_next(v, &proto_list, pos);
}
| 33,497,796,685,296,910,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,974 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static int proto_seq_open(struct inode *inode, struct file *file)
{
return seq_open_net(inode, file, &proto_seq_ops,
sizeof(struct seq_net_private));
}
| 316,585,016,414,081,080,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,975 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
{
seq_printf(seq, "%-9s %4u %6d %6ld %-3s %6u %-3s %-10s "
"%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
proto->name,
proto->obj_size,
sock_prot_inuse_get(seq_file_net(seq), proto),
... | 160,979,083,968,478,710,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,976 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static int proto_seq_show(struct seq_file *seq, void *v)
{
if (v == &proto_list)
seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
"protocol",
"size",
"sockets",
"memory",
"press",
"maxhdr",
"slab",
"module",
"cl co di ac io in de sh ss gs se re sp b... | 140,278,987,032,356,460,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,977 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void proto_unregister(struct proto *prot)
{
mutex_lock(&proto_list_mutex);
release_proto_idx(prot);
list_del(&prot->node);
mutex_unlock(&proto_list_mutex);
if (prot->slab != NULL) {
kmem_cache_destroy(prot->slab);
prot->slab = NULL;
}
if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) {
kmem_cac... | 123,724,061,751,789,250,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,978 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void release_proto_idx(struct proto *prot)
{
if (prot->inuse_idx != PROTO_INUSE_NR - 1)
clear_bit(prot->inuse_idx, proto_inuse_idx);
}
| 257,774,477,499,980,740,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,979 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static inline void release_proto_idx(struct proto *prot)
{
}
| 258,440,211,788,483,330,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,980 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void release_sock(struct sock *sk)
{
/*
* The sk_lock has mutex_unlock() semantics:
*/
mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
spin_lock_bh(&sk->sk_lock.slock);
if (sk->sk_backlog.tail)
__release_sock(sk);
sk->sk_lock.owned = 0;
if (waitqueue_active(&sk->sk_lock.wq))
wake_up(&sk->sk_lock.wq);
... | 28,530,605,515,242,686,000,000,000,000,000,000,000 | sock.c | 109,934,911,297,062,120,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,981 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
struct proto *prot)
{
struct sock *sk;
sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
if (sk) {
sk->sk_family = family;
/*
* See comment in struct sock definition to understand
* why we need sk_prot_creator -acme
*/
... | 184,044,143,441,737,000,000,000,000,000,000,000,000 | sock.c | 109,934,911,297,062,120,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,982 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
{
struct sock *newsk;
newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
if (newsk != NULL) {
struct sk_filter *filter;
sock_copy(newsk, sk);
/* SANITY */
get_net(sock_net(newsk));
sk_node_init(&newsk->sk_node);
sock_loc... | 250,058,537,605,793,520,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,983 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sk_common_release(struct sock *sk)
{
if (sk->sk_prot->destroy)
sk->sk_prot->destroy(sk);
/*
* Observation: when sock_common_release is called, processes have
* no access to socket. But net still has.
* Step one, detach it from networking:
*
* A. Remove from hash tables.
*/
sk->sk_prot->unhash(sk... | 110,808,302,761,198,640,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,984 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
{
struct dst_entry *dst = sk_dst_get(sk);
if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
sk_dst_reset(sk);
dst_release(dst);
return NULL;
}
return dst;
}
| 106,656,876,294,176,060,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,985 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sk_free(struct sock *sk)
{
/*
* We subtract one from sk_wmem_alloc and can know if
* some packets are still in some tx queue.
* If not null, sock_wfree() will call __sk_free(sk) later
*/
if (atomic_dec_and_test(&sk->sk_wmem_alloc))
__sk_free(sk);
}
| 75,131,923,001,002,250,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,986 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void __init sk_init(void)
{
if (totalram_pages <= 4096) {
sysctl_wmem_max = 32767;
sysctl_rmem_max = 32767;
sysctl_wmem_default = 32767;
sysctl_rmem_default = 32767;
} else if (totalram_pages >= 131072) {
sysctl_wmem_max = 131071;
sysctl_rmem_max = 131071;
}
}
| 84,539,509,761,239,780,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,987 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
int family)
{
struct sock *sk;
struct kmem_cache *slab;
slab = prot->slab;
if (slab != NULL) {
sk = kmem_cache_alloc(slab, priority & ~__GFP_ZERO);
if (!sk)
return sk;
if (priority & __GFP_ZERO) {
if (prot->clear_sk)
prot->clea... | 97,404,689,973,872,030,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,988 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static inline void sk_prot_clear_nulls(struct sock *sk, int size)
{
if (offsetof(struct sock, sk_node.next) != 0)
memset(sk, 0, offsetof(struct sock, sk_node.next));
memset(&sk->sk_node.pprev, 0,
size - offsetof(struct sock, sk_node.pprev));
}
| 75,342,159,032,574,560,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,989 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sk_prot_clear_portaddr_nulls(struct sock *sk, int size)
{
unsigned long nulls1, nulls2;
nulls1 = offsetof(struct sock, __sk_common.skc_node.next);
nulls2 = offsetof(struct sock, __sk_common.skc_portaddr_node.next);
if (nulls1 > nulls2)
swap(nulls1, nulls2);
if (nulls1 != 0)
memset((char *)sk, 0, nulls1)... | 21,922,194,816,502,814,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,990 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void sk_prot_free(struct proto *prot, struct sock *sk)
{
struct kmem_cache *slab;
struct module *owner;
owner = prot->owner;
slab = prot->slab;
security_sk_free(sk);
if (slab != NULL)
kmem_cache_free(slab, sk);
else
kfree(sk);
module_put(owner);
}
| 17,757,867,862,166,063,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,991 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sk_receive_skb(struct sock *sk, struct sk_buff *skb, const int nested)
{
int rc = NET_RX_SUCCESS;
if (sk_filter(sk, skb))
goto discard_and_relse;
skb->dev = NULL;
if (sk_rcvqueues_full(sk, skb, sk->sk_rcvbuf)) {
atomic_inc(&sk->sk_drops);
goto discard_and_relse;
}
if (nested)
bh_lock_sock_nested(sk... | 338,759,570,374,428,700,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,992 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sk_release_kernel(struct sock *sk)
{
if (sk == NULL || sk->sk_socket == NULL)
return;
sock_hold(sk);
sock_release(sk->sk_socket);
release_net(sock_net(sk));
sock_net_set(sk, get_net(&init_net));
sock_put(sk);
}
| 233,694,724,912,481,100,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,993 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sk_reset_timer(struct sock *sk, struct timer_list* timer,
unsigned long expires)
{
if (!mod_timer(timer, expires))
sock_hold(sk);
}
| 260,769,815,015,894,330,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,994 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sk_reset_txq(struct sock *sk)
{
sk_tx_queue_clear(sk);
}
| 151,357,591,129,893,140,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,995 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sk_send_sigurg(struct sock *sk)
{
if (sk->sk_socket && sk->sk_socket->file)
if (send_sigurg(&sk->sk_socket->file->f_owner))
sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
}
| 141,024,276,090,785,800,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,996 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
{
__sk_dst_set(sk, dst);
sk->sk_route_caps = dst->dev->features;
if (sk->sk_route_caps & NETIF_F_GSO)
sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
sk->sk_route_caps &= ~sk->sk_route_nocaps;
if (sk_can_gso(sk)) {
if (dst->header_len) {
sk->sk_route_cap... | 69,938,543,763,311,930,000,000,000,000,000,000,000 | sock.c | 109,934,911,297,062,120,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,997 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sk_stop_timer(struct sock *sk, struct timer_list* timer)
{
if (timer_pending(timer) && del_timer(timer))
__sock_put(sk);
}
| 12,349,401,284,720,502,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,998 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void sk_update_clone(const struct sock *sk, struct sock *newsk)
{
if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
sock_update_memcg(newsk);
}
| 147,681,461,847,797,530,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
22,999 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sk_wait_data(struct sock *sk, long *timeo)
{
int rc;
DEFINE_WAIT(wait);
prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);... | 206,968,246,705,678,140,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,000 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
int noblock, int *errcode)
{
return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
}
| 327,174,801,755,751,750,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,001 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static int sock_bindtodevice(struct sock *sk, char __user *optval, int optlen)
{
int ret = -ENOPROTOOPT;
#ifdef CONFIG_NETDEVICES
struct net *net = sock_net(sk);
char devname[IFNAMSIZ];
int index;
/* Sorry... */
ret = -EPERM;
if (!capable(CAP_NET_RAW))
goto out;
ret = -EINVAL;
if (optlen < 0)
goto out;
... | 105,033,119,963,753,800,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,002 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t size, int flags)
{
struct sock *sk = sock->sk;
int addr_len = 0;
int err;
err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
flags & ~MSG_DONTWAIT, &addr_len);
if (err >= 0)
msg->msg_namelen ... | 304,028,472,204,860,270,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,003 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_common_setsockopt(struct socket *sock, int level, int optname,
char __user *optval, unsigned int optlen)
{
struct sock *sk = sock->sk;
return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
}
| 138,054,732,825,041,860,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,004 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void sock_copy(struct sock *nsk, const struct sock *osk)
{
#ifdef CONFIG_SECURITY_NETWORK
void *sptr = nsk->sk_security;
#endif
memcpy(nsk, osk, offsetof(struct sock, sk_dontcopy_begin));
memcpy(&nsk->sk_dontcopy_end, &osk->sk_dontcopy_end,
osk->sk_prot->obj_size - offsetof(struct sock, sk_dontcopy_e... | 114,178,755,897,612,280,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,005 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void sock_def_destruct(struct sock *sk)
{
kfree(sk->sk_protinfo);
}
| 69,443,251,045,394,680,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,006 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void sock_def_error_report(struct sock *sk)
{
struct socket_wq *wq;
rcu_read_lock();
wq = rcu_dereference(sk->sk_wq);
if (wq_has_sleeper(wq))
wake_up_interruptible_poll(&wq->wait, POLLERR);
sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
rcu_read_unlock();
}
| 132,472,285,541,560,840,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,007 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void sock_def_wakeup(struct sock *sk)
{
struct socket_wq *wq;
rcu_read_lock();
wq = rcu_dereference(sk->sk_wq);
if (wq_has_sleeper(wq))
wake_up_interruptible_all(&wq->wait);
rcu_read_unlock();
}
| 119,960,935,926,908,380,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,008 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void sock_def_write_space(struct sock *sk)
{
struct socket_wq *wq;
rcu_read_lock();
/* Do not wake up a writer until he can make "significant"
* progress. --DaveM
*/
if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
wq = rcu_dereference(sk->sk_wq);
if (wq_has_sleeper(wq))
wake_up_i... | 284,026,062,322,410,730,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,009 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void sock_disable_timestamp(struct sock *sk, unsigned long flags)
{
if (sk->sk_flags & flags) {
sk->sk_flags &= ~flags;
if (!(sk->sk_flags & SK_FLAGS_TIMESTAMP))
net_disable_timestamp();
}
}
| 265,135,179,886,594,940,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,010 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sock_enable_timestamp(struct sock *sk, int flag)
{
if (!sock_flag(sk, flag)) {
unsigned long previous_flags = sk->sk_flags;
sock_set_flag(sk, flag);
/*
* we just set one of the two flags which require net
* time stamping, but time stamping might have been on
* already because of the other one
*... | 123,981,007,793,962,930,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,011 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
{
struct timeval tv;
if (!sock_flag(sk, SOCK_TIMESTAMP))
sock_enable_timestamp(sk, SOCK_TIMESTAMP);
tv = ktime_to_timeval(sk->sk_stamp);
if (tv.tv_sec == -1)
return -ENOENT;
if (tv.tv_sec == 0) {
sk->sk_stamp = ktime_get_real();
tv =... | 291,746,116,436,135,840,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,012 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_getsockopt(struct socket *sock, int level, int optname,
char __user *optval, int __user *optlen)
{
struct sock *sk = sock->sk;
union {
int val;
struct linger ling;
struct timeval tm;
} v;
int lv = sizeof(int);
int len;
if (get_user(len, optlen))
return -EFAULT;
if (len < 0)
return -EI... | 34,605,834,766,005,530,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,013 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | unsigned long sock_i_ino(struct sock *sk)
{
unsigned long ino;
read_lock_bh(&sk->sk_callback_lock);
ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
read_unlock_bh(&sk->sk_callback_lock);
return ino;
}
| 91,909,199,909,231,600,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,014 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_i_uid(struct sock *sk)
{
int uid;
read_lock_bh(&sk->sk_callback_lock);
uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
read_unlock_bh(&sk->sk_callback_lock);
return uid;
}
| 287,089,326,777,247,600,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,015 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sock_init_data(struct socket *sock, struct sock *sk)
{
skb_queue_head_init(&sk->sk_receive_queue);
skb_queue_head_init(&sk->sk_write_queue);
skb_queue_head_init(&sk->sk_error_queue);
#ifdef CONFIG_NET_DMA
skb_queue_head_init(&sk->sk_async_wait_queue);
#endif
sk->sk_send_head = NULL;
init_timer(&sk->sk_time... | 21,584,588,755,955,350,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,016 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void __net_exit sock_inuse_exit_net(struct net *net)
{
free_percpu(net->core.inuse);
}
| 232,687,168,842,548,980,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,017 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static int __net_init sock_inuse_init_net(struct net *net)
{
net->core.inuse = alloc_percpu(struct prot_inuse);
return net->core.inuse ? 0 : -ENOMEM;
}
| 44,332,226,026,954,320,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,018 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sock_kfree_s(struct sock *sk, void *mem, int size)
{
kfree(mem);
atomic_sub(size, &sk->sk_omem_alloc);
}
| 309,018,824,428,036,700,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,019 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static inline void sock_lock_init(struct sock *sk)
{
sock_lock_init_class_and_name(sk,
af_family_slock_key_strings[sk->sk_family],
af_family_slock_keys + sk->sk_family,
af_family_key_strings[sk->sk_family],
af_family_keys + sk->sk_family);
}
| 253,236,048,980,129,870,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,020 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
{
return -EOPNOTSUPP;
}
| 284,301,737,432,797,830,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,021 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
{
return -EOPNOTSUPP;
}
| 61,178,779,582,672,090,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,022 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
int len, int flags)
{
return -EOPNOTSUPP;
}
| 81,406,666,784,202,680,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,023 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
int *len, int peer)
{
return -EOPNOTSUPP;
}
| 221,629,845,872,612,400,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,024 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
return -EOPNOTSUPP;
}
| 35,674,647,654,381,417,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,025 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_no_listen(struct socket *sock, int backlog)
{
return -EOPNOTSUPP;
}
| 194,373,384,167,289,800,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,026 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
{
/* Mirror missing mmap method error code */
return -ENODEV;
}
| 255,207,452,010,780,400,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,027 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | unsigned int sock_no_poll(struct file *file, struct socket *sock, poll_table *pt)
{
return 0;
}
| 144,778,628,383,495,700,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,028 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
size_t len, int flags)
{
return -EOPNOTSUPP;
}
| 37,853,630,655,489,557,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,029 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
size_t len)
{
return -EOPNOTSUPP;
}
| 94,602,247,322,270,750,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,030 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
{
ssize_t res;
struct msghdr msg = {.msg_flags = flags};
struct kvec iov;
char *kaddr = kmap(page);
iov.iov_base = kaddr + offset;
iov.iov_len = size;
res = kernel_sendmsg(sock, &msg, &iov, 1, size);
kunmap(page... | 218,525,349,392,738,330,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,031 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_no_setsockopt(struct socket *sock, int level, int optname,
char __user *optval, unsigned int optlen)
{
return -EOPNOTSUPP;
}
| 303,524,438,070,856,100,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,032 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_no_shutdown(struct socket *sock, int how)
{
return -EOPNOTSUPP;
}
| 227,800,287,643,105,270,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,033 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
{
return -EOPNOTSUPP;
}
| 88,134,487,105,977,730,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,034 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
{
__this_cpu_add(net->core.inuse->val[prot->inuse_idx], val);
}
| 295,636,453,133,205,940,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,035 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
{
__this_cpu_add(prot_inuse.val[prot->inuse_idx], val);
}
| 264,965,503,347,943,130,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,036 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_prot_inuse_get(struct net *net, struct proto *prot)
{
int cpu, idx = prot->inuse_idx;
int res = 0;
for_each_possible_cpu(cpu)
res += per_cpu_ptr(net->core.inuse, cpu)->val[idx];
return res >= 0 ? res : 0;
}
| 205,003,366,316,328,700,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,037 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_prot_inuse_get(struct net *net, struct proto *prot)
{
int cpu, idx = prot->inuse_idx;
int res = 0;
for_each_possible_cpu(cpu)
res += per_cpu(prot_inuse, cpu).val[idx];
return res >= 0 ? res : 0;
}
| 186,617,955,619,522,070,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,038 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static long sock_prot_memory_allocated(struct proto *proto)
{
return proto->memory_allocated != NULL ? proto_memory_allocated(proto) : -1L;
}
| 310,017,296,364,668,070,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,039 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static char *sock_prot_memory_pressure(struct proto *proto)
{
return proto->memory_pressure != NULL ?
proto_memory_pressure(proto) ? "yes" : "no" : "NI";
}
| 132,004,368,466,385,370,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,040 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
{
int err;
int skb_len;
unsigned long flags;
struct sk_buff_head *list = &sk->sk_receive_queue;
if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf) {
atomic_inc(&sk->sk_drops);
trace_sock_rcvqueue_full(sk, skb);
return -ENOMEM;
}
err = sk_fil... | 253,380,638,044,287,460,000,000,000,000,000,000,000 | sock.c | 109,934,911,297,062,120,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,041 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sock_rfree(struct sk_buff *skb)
{
struct sock *sk = skb->sk;
unsigned int len = skb->truesize;
atomic_sub(len, &sk->sk_rmem_alloc);
sk_mem_uncharge(sk, len);
}
| 141,844,298,474,272,180,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,042 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force,
gfp_t priority)
{
if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
struct sk_buff *skb = alloc_skb(size, priority);
if (skb) {
skb_set_owner_r(skb, sk);
return skb;
}
}
return NULL;
}
| 77,587,710,158,298,630,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,043 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
{
struct timeval tv;
if (optlen < sizeof(tv))
return -EINVAL;
if (copy_from_user(&tv, optval, sizeof(tv)))
return -EFAULT;
if (tv.tv_usec < 0 || tv.tv_usec >= USEC_PER_SEC)
return -EDOM;
if (tv.tv_sec < 0) {
static int warned __r... | 55,163,739,473,211,035,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,044 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sock_update_classid(struct sock *sk)
{
u32 classid;
rcu_read_lock(); /* doing current task, which cannot vanish. */
classid = task_cls_classid(current);
rcu_read_unlock();
if (classid && classid != sk->sk_classid)
sk->sk_classid = classid;
}
| 140,708,085,338,263,030,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,045 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sock_update_netprioidx(struct sock *sk)
{
if (in_interrupt())
return;
sk->sk_cgrp_prioidx = task_netprioidx(current);
}
| 224,243,332,261,655,430,000,000,000,000,000,000,000 | sock.c | 109,934,911,297,062,120,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,046 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static inline void sock_valbool_flag(struct sock *sk, int bit, int valbool)
{
if (valbool)
sock_set_flag(sk, bit);
else
sock_reset_flag(sk, bit);
}
| 218,258,806,440,453,280,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,047 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static long sock_wait_for_wmem(struct sock *sk, long timeo)
{
DEFINE_WAIT(wait);
clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
for (;;) {
if (!timeo)
break;
if (signal_pending(current))
break;
set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE... | 291,764,595,279,453,600,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,048 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | static void sock_warn_obsolete_bsdism(const char *name)
{
static int warned;
static char warncomm[TASK_COMM_LEN];
if (strcmp(warncomm, current->comm) && warned < 5) {
strcpy(warncomm, current->comm);
pr_warn("process `%s' is using obsolete %s SO_BSDCOMPAT\n",
warncomm, name);
warned++;
}
}
| 303,018,076,587,402,870,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,049 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | void sock_wfree(struct sk_buff *skb)
{
struct sock *sk = skb->sk;
unsigned int len = skb->truesize;
if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
/*
* Keep a reference on sk_wmem_alloc, this will be released
* after sk_write_space() call
*/
atomic_sub(len - 1, &sk->sk_wmem_alloc);
sk->sk_write_space(sk... | 305,558,145,637,802,960,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,050 | linux | cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/cc9b17ad29ecaa20bfe426a8d4dbfb94b13ff1cc | net: sock: validate data_len before allocating skb in sock_alloc_send_pskb()
We need to validate the number of pages consumed by data_len, otherwise frags
array could be overflowed by userspace. So this patch validate data_len and
return -EMSGSIZE when data_len may occupies more frags than MAX_SKB_FRAGS.
Signed-off-b... | 0 | struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
gfp_t priority)
{
if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
struct sk_buff *skb = alloc_skb(size, priority);
if (skb) {
skb_set_owner_w(skb, sk);
return skb;
}
}
return NULL;
}
| 162,812,100,650,596,770,000,000,000,000,000,000,000 | sock.c | 263,250,588,183,211,000,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2012-2136 | The sock_alloc_send_pskb function in net/core/sock.c in the Linux kernel before 3.4.5 does not properly validate a certain length value, which allows local users to cause a denial of service (heap-based buffer overflow and system crash) or possibly gain privileges by leveraging access to a TUN/TAP device. | https://nvd.nist.gov/vuln/detail/CVE-2012-2136 |
23,088 | linux | 905ad269c55fc62bee3da29f7b1d1efeba8aa1e1 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/905ad269c55fc62bee3da29f7b1d1efeba8aa1e1 | procfs: fix a vfsmount longterm reference leak
kern_mount() doesn't pair with plain mntput()...
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk> | 0 | static struct dentry *proc_mount(struct file_system_type *fs_type,
int flags, const char *dev_name, void *data)
{
int err;
struct super_block *sb;
struct pid_namespace *ns;
struct proc_inode *ei;
if (flags & MS_KERNMOUNT)
ns = (struct pid_namespace *)data;
else
ns = current->nsproxy->pid_ns;
sb = sget(fs_... | 7,598,559,004,032,076,000,000,000,000,000,000,000 | root.c | 283,662,311,685,635,130,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2012-2127 | fs/proc/root.c in the procfs implementation in the Linux kernel before 3.2 does not properly interact with CLONE_NEWPID clone system calls, which allows remote attackers to cause a denial of service (reference leak and memory consumption) by making many connections to a daemon that uses PID namespaces to isolate client... | https://nvd.nist.gov/vuln/detail/CVE-2012-2127 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.