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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
39,890 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_split(struct sk_buff *skb, struct sk_buff *skb1, const u32 len)
{
int pos = skb_headlen(skb);
skb_shinfo(skb1)->tx_flags = skb_shinfo(skb)->tx_flags & SKBTX_SHARED_FRAG;
if (len < pos) /* Split line is inside header. */
skb_split_inside_header(skb, skb1, len, pos);
else /* Second chunk has no header, n... | 35,807,484,052,218,895,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,891 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static inline void skb_split_inside_header(struct sk_buff *skb,
struct sk_buff* skb1,
const u32 len, const int pos)
{
int i;
skb_copy_from_linear_data_offset(skb, len, skb_put(skb1, pos - len),
pos - len);
/* And move data appendix as is. */
for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
s... | 119,482,315,583,392,130,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,892 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static inline void skb_split_no_header(struct sk_buff *skb,
struct sk_buff* skb1,
const u32 len, int pos)
{
int i, k = 0;
const int nfrags = skb_shinfo(skb)->nr_frags;
skb_shinfo(skb)->nr_frags = 0;
skb1->len = skb1->data_len = skb->len - len;
skb->len = len;
skb->data_len = len - ... | 295,170,638,406,942,700,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,893 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len)
{
int start = skb_headlen(skb);
struct sk_buff *frag_iter;
int i, copy;
if (offset > (int)skb->len - len)
goto fault;
if ((copy = start - offset) > 0) {
if (copy > len)
copy = len;
skb_copy_to_linear_data_offset(skb, offset, ... | 131,704,801,340,891,860,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,894 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | int skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
{
int nsg = __skb_to_sgvec(skb, sg, offset, len);
sg_mark_end(&sg[nsg - 1]);
return nsg;
}
| 192,676,974,855,605,700,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,895 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_trim(struct sk_buff *skb, unsigned int len)
{
if (skb->len > len)
__skb_trim(skb, len);
}
| 173,672,943,919,696,860,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,896 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | bool skb_try_coalesce(struct sk_buff *to, struct sk_buff *from,
bool *fragstolen, int *delta_truesize)
{
int i, delta, len = from->len;
*fragstolen = false;
if (skb_cloned(to))
return false;
if (len <= skb_tailroom(to)) {
BUG_ON(skb_copy_bits(from, 0, skb_put(to, len), len));
*delta_truesize = 0;
... | 28,320,712,639,582,603,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,897 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void skb_ts_finish(struct ts_config *conf, struct ts_state *state)
{
skb_abort_seq_read(TS_SKB_CB(state));
}
| 75,696,423,892,688,970,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,898 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static unsigned int skb_ts_get_next_block(unsigned int offset, const u8 **text,
struct ts_config *conf,
struct ts_state *state)
{
return skb_seq_read(offset, text, TS_SKB_CB(state));
}
| 105,535,984,291,581,600,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,899 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | void skb_tx_error(struct sk_buff *skb)
{
if (skb_shinfo(skb)->tx_flags & SKBTX_DEV_ZEROCOPY) {
struct ubuf_info *uarg;
uarg = skb_shinfo(skb)->destructor_arg;
if (uarg->callback)
uarg->callback(uarg, false);
skb_shinfo(skb)->tx_flags &= ~SKBTX_DEV_ZEROCOPY;
}
}
| 311,642,649,600,369,060,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,900 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void skb_under_panic(struct sk_buff *skb, unsigned int sz, void *addr)
{
skb_panic(skb, sz, addr, __func__);
}
| 129,291,561,553,722,340,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,901 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | skb_zerocopy(struct sk_buff *to, const struct sk_buff *from, int len, int hlen)
{
int i, j = 0;
int plen = 0; /* length of skb->head fragment */
struct page *page;
unsigned int offset;
BUG_ON(!from->head_frag && !hlen);
/* dont bother with small payloads */
if (len <= skb_tailroom(to)) {
skb_copy_bits(from, ... | 16,764,334,568,401,960,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,902 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | skb_zerocopy_headlen(const struct sk_buff *from)
{
unsigned int hlen = 0;
if (!from->head_frag ||
skb_headlen(from) < L1_CACHE_BYTES ||
skb_shinfo(from)->nr_frags >= MAX_SKB_FRAGS)
hlen = skb_headlen(from);
if (skb_has_frag_list(from))
hlen = from->len;
return hlen;
}
| 139,880,931,528,484,940,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,903 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void sock_rmem_free(struct sk_buff *skb)
{
struct sock *sk = skb->sk;
atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
}
| 226,637,023,269,145,240,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,904 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static void sock_spd_release(struct splice_pipe_desc *spd, unsigned int i)
{
put_page(spd->pages[i]);
}
| 163,838,260,538,482,540,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,905 | linux | 1fd819ecb90cc9b822cd84d3056ddba315d3340f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/1fd819ecb90cc9b822cd84d3056ddba315d3340f | skbuff: skb_segment: orphan frags before copying
skb_segment copies frags around, so we need
to copy them carefully to avoid accessing
user memory after reporting completion to userspace
through a callback.
skb_segment doesn't normally happen on datapath:
TSO needs to be disabled - so disabling zero copy
in this case... | 0 | static bool spd_fill_page(struct splice_pipe_desc *spd,
struct pipe_inode_info *pipe, struct page *page,
unsigned int *len, unsigned int offset,
bool linear,
struct sock *sk)
{
if (unlikely(spd->nr_pages == MAX_SKB_FRAGS))
return true;
if (linear) {
page = linear_to_page(page, len, &offset, s... | 225,945,482,042,593,100,000,000,000,000,000,000,000 | skbuff.c | 53,475,202,514,227,630,000,000,000,000,000,000,000 | [
"CWE-416"
] | CVE-2014-0131 | Use-after-free vulnerability in the skb_segment function in net/core/skbuff.c in the Linux kernel through 3.13.6 allows attackers to obtain sensitive information from kernel memory by leveraging the absence of a certain orphaning operation. | https://nvd.nist.gov/vuln/detail/CVE-2014-0131 |
39,906 | linux | ec0223ec48a90cb605244b45f7c62de856403729 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ec0223ec48a90cb605244b45f7c62de856403729 | net: sctp: fix sctp_sf_do_5_1D_ce to verify if we/peer is AUTH capable
RFC4895 introduced AUTH chunks for SCTP; during the SCTP
handshake RANDOM; CHUNKS; HMAC-ALGO are negotiated (CHUNKS
being optional though):
---------- INIT[RANDOM; CHUNKS; HMAC-ALGO] ---------->
<------- INIT-ACK[RANDOM; CHUNKS; HMAC-ALGO] ---... | 0 | static int sctp_eat_data(const struct sctp_association *asoc,
struct sctp_chunk *chunk,
sctp_cmd_seq_t *commands)
{
sctp_datahdr_t *data_hdr;
struct sctp_chunk *err;
size_t datalen;
sctp_verb_t deliver;
int tmp;
__u32 tsn;
struct sctp_tsnmap *map = (struct sctp_tsnmap *)&asoc->peer.tsn_map;
struct sock ... | 306,143,514,872,663,030,000,000,000,000,000,000,000 | sm_statefuns.c | 117,916,767,541,319,030,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0101 | The sctp_sf_do_5_1D_ce function in net/sctp/sm_statefuns.c in the Linux kernel through 3.13.6 does not validate certain auth_enable and auth_capable fields before making an sctp_sf_authenticate call, which allows remote attackers to cause a denial of service (NULL pointer dereference and system crash) via an SCTP hands... | https://nvd.nist.gov/vuln/detail/CVE-2014-0101 |
39,907 | linux | ec0223ec48a90cb605244b45f7c62de856403729 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/ec0223ec48a90cb605244b45f7c62de856403729 | net: sctp: fix sctp_sf_do_5_1D_ce to verify if we/peer is AUTH capable
RFC4895 introduced AUTH chunks for SCTP; during the SCTP
handshake RANDOM; CHUNKS; HMAC-ALGO are negotiated (CHUNKS
being optional though):
---------- INIT[RANDOM; CHUNKS; HMAC-ALGO] ---------->
<------- INIT-ACK[RANDOM; CHUNKS; HMAC-ALGO] ---... | 0 | sctp_disposition_t sctp_sf_unk_chunk(struct net *net,
const struct sctp_endpoint *ep,
const struct sctp_association *asoc,
const sctp_subtype_t type,
void *arg,
sctp_cmd_seq_t *commands)
{
struct sctp_chunk *unk_chunk = arg;
struct sctp_chunk *err_chunk;
sctp_chunkhdr_t *... | 175,856,740,400,578,830,000,000,000,000,000,000,000 | sm_statefuns.c | 117,916,767,541,319,030,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0101 | The sctp_sf_do_5_1D_ce function in net/sctp/sm_statefuns.c in the Linux kernel through 3.13.6 does not validate certain auth_enable and auth_capable fields before making an sctp_sf_authenticate call, which allows remote attackers to cause a denial of service (NULL pointer dereference and system crash) via an SCTP hands... | https://nvd.nist.gov/vuln/detail/CVE-2014-0101 |
39,908 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 0 | static void handle_tx(struct vhost_net *net)
{
struct vhost_net_virtqueue *nvq = &net->vqs[VHOST_NET_VQ_TX];
struct vhost_virtqueue *vq = &nvq->vq;
unsigned out, in, s;
int head;
struct msghdr msg = {
.msg_name = NULL,
.msg_namelen = 0,
.msg_control = NULL,
.msg_controllen = 0,
.msg_iov = vq->iov,
.msg... | 72,785,880,175,197,390,000,000,000,000,000,000,000 | net.c | 236,351,763,781,669,720,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
39,909 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 0 | static void vhost_net_flush(struct vhost_net *n)
{
vhost_net_flush_vq(n, VHOST_NET_VQ_TX);
vhost_net_flush_vq(n, VHOST_NET_VQ_RX);
if (n->vqs[VHOST_NET_VQ_TX].ubufs) {
mutex_lock(&n->vqs[VHOST_NET_VQ_TX].vq.mutex);
n->tx_flush = true;
mutex_unlock(&n->vqs[VHOST_NET_VQ_TX].vq.mutex);
/* Wait for all lower dev... | 205,921,932,333,969,700,000,000,000,000,000,000,000 | net.c | 268,911,689,132,856,720,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
39,910 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 0 | static int vhost_net_open(struct inode *inode, struct file *f)
{
struct vhost_net *n = kmalloc(sizeof *n, GFP_KERNEL);
struct vhost_dev *dev;
struct vhost_virtqueue **vqs;
int i;
if (!n)
return -ENOMEM;
vqs = kmalloc(VHOST_NET_VQ_MAX * sizeof(*vqs), GFP_KERNEL);
if (!vqs) {
kfree(n);
return -ENOMEM;
}
... | 209,009,636,880,762,040,000,000,000,000,000,000,000 | net.c | 236,351,763,781,669,720,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
39,911 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 0 | static long vhost_net_set_backend(struct vhost_net *n, unsigned index, int fd)
{
struct socket *sock, *oldsock;
struct vhost_virtqueue *vq;
struct vhost_net_virtqueue *nvq;
struct vhost_net_ubuf_ref *ubufs, *oldubufs = NULL;
int r;
mutex_lock(&n->dev.mutex);
r = vhost_dev_check_owner(&n->dev);
if (r)
goto er... | 226,361,141,312,270,280,000,000,000,000,000,000,000 | net.c | 236,351,763,781,669,720,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
39,912 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 0 | static int vhost_net_set_ubuf_info(struct vhost_net *n)
{
bool zcopy;
int i;
for (i = 0; i < VHOST_NET_VQ_MAX; ++i) {
zcopy = vhost_net_zcopy_mask & (0x1 << i);
if (!zcopy)
continue;
n->vqs[i].ubuf_info = kmalloc(sizeof(*n->vqs[i].ubuf_info) *
UIO_MAXIOV, GFP_KERNEL);
if (!n->vqs[i].ubuf_info... | 252,419,108,910,440,200,000,000,000,000,000,000,000 | net.c | 236,351,763,781,669,720,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
39,913 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 0 | static struct socket *vhost_net_stop_vq(struct vhost_net *n,
struct vhost_virtqueue *vq)
{
struct socket *sock;
mutex_lock(&vq->mutex);
sock = vq->private_data;
vhost_net_disable_vq(n, vq);
vq->private_data = NULL;
mutex_unlock(&vq->mutex);
return sock;
}
| 228,378,414,533,405,800,000,000,000,000,000,000,000 | net.c | 236,351,763,781,669,720,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
39,914 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 0 | vhost_net_ubuf_alloc(struct vhost_virtqueue *vq, bool zcopy)
{
struct vhost_net_ubuf_ref *ubufs;
/* No zero copy backend? Nothing to count. */
if (!zcopy)
return NULL;
ubufs = kmalloc(sizeof(*ubufs), GFP_KERNEL);
if (!ubufs)
return ERR_PTR(-ENOMEM);
atomic_set(&ubufs->refcount, 1);
init_waitqueue_head(&ubufs... | 115,752,114,174,923,480,000,000,000,000,000,000,000 | net.c | 268,911,689,132,856,720,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
39,915 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 0 | static int vhost_net_ubuf_put(struct vhost_net_ubuf_ref *ubufs)
{
int r = atomic_sub_return(1, &ubufs->refcount);
if (unlikely(!r))
wake_up(&ubufs->wait);
return r;
}
| 214,312,459,528,195,330,000,000,000,000,000,000,000 | net.c | 268,911,689,132,856,720,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
39,916 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 0 | static void vhost_net_ubuf_put_and_wait(struct vhost_net_ubuf_ref *ubufs)
{
vhost_net_ubuf_put(ubufs);
wait_event(ubufs->wait, !atomic_read(&ubufs->refcount));
}
| 45,445,144,197,698,940,000,000,000,000,000,000,000 | net.c | 268,911,689,132,856,720,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
39,917 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 0 | static void vhost_net_ubuf_put_wait_and_free(struct vhost_net_ubuf_ref *ubufs)
{
vhost_net_ubuf_put_and_wait(ubufs);
kfree(ubufs);
}
| 327,359,572,037,001,180,000,000,000,000,000,000,000 | net.c | 268,911,689,132,856,720,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
39,918 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 0 | static void vhost_net_vq_reset(struct vhost_net *n)
{
int i;
vhost_net_clear_ubuf_info(n);
for (i = 0; i < VHOST_NET_VQ_MAX; i++) {
n->vqs[i].done_idx = 0;
n->vqs[i].upend_idx = 0;
n->vqs[i].ubufs = NULL;
n->vqs[i].vhost_hlen = 0;
n->vqs[i].sock_hlen = 0;
}
}
| 192,505,798,894,412,350,000,000,000,000,000,000,000 | net.c | 236,351,763,781,669,720,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
39,919 | linux | d8316f3991d207fe32881a9ac20241be8fa2bad0 | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/d8316f3991d207fe32881a9ac20241be8fa2bad0 | vhost: fix total length when packets are too short
When mergeable buffers are disabled, and the
incoming packet is too large for the rx buffer,
get_rx_bufs returns success.
This was intentional in order for make recvmsg
truncate the packet and then handle_rx would
detect err != sock_len and drop it.
Unfortunately we... | 0 | static void vhost_zerocopy_signal_used(struct vhost_net *net,
struct vhost_virtqueue *vq)
{
struct vhost_net_virtqueue *nvq =
container_of(vq, struct vhost_net_virtqueue, vq);
int i, add;
int j = 0;
for (i = nvq->done_idx; i != nvq->upend_idx; i = (i + 1) % UIO_MAXIOV) {
if (vq->heads[i].len == VHOS... | 221,944,891,379,821,760,000,000,000,000,000,000,000 | net.c | 268,911,689,132,856,720,000,000,000,000,000,000,000 | [
"CWE-20"
] | CVE-2014-0077 | drivers/vhost/net.c in the Linux kernel before 3.13.10, when mergeable buffers are disabled, does not properly validate packet lengths, which allows guest OS users to cause a denial of service (memory corruption and host OS crash) or possibly gain privileges on the host OS via crafted packets, related to the handle_rx ... | https://nvd.nist.gov/vuln/detail/CVE-2014-0077 |
39,920 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifsFileInfo_get(struct cifsFileInfo *cifs_file)
{
spin_lock(&cifs_file_list_lock);
cifsFileInfo_get_locked(cifs_file);
spin_unlock(&cifs_file_list_lock);
return cifs_file;
}
| 161,164,578,687,309,780,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,921 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
{
struct inode *inode = cifs_file->dentry->d_inode;
struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
struct TCP_Server_Info *server = tcon->ses->server;
struct cifsInodeInfo *cifsi = CIFS_I(inode);
struct super_block *sb = inode->i_sb;
struct cifs_sb_inf... | 6,485,396,222,192,264,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,922 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | int cifs_closedir(struct inode *inode, struct file *file)
{
int rc = 0;
unsigned int xid;
struct cifsFileInfo *cfile = file->private_data;
struct cifs_tcon *tcon;
struct TCP_Server_Info *server;
char *buf;
cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
if (cfile == NULL)
return rc;
xid = get_xid();
tco... | 215,194,229,419,780,930,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,923 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static inline int cifs_convert_flags(unsigned int flags)
{
if ((flags & O_ACCMODE) == O_RDONLY)
return GENERIC_READ;
else if ((flags & O_ACCMODE) == O_WRONLY)
return GENERIC_WRITE;
else if ((flags & O_ACCMODE) == O_RDWR) {
/* GENERIC_ALL is too much permission to request
can cause unnecessary access denie... | 21,336,293,187,174,090,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,924 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_del_lock_waiters(struct cifsLockInfo *lock)
{
struct cifsLockInfo *li, *tmp;
list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
list_del_init(&li->blist);
wake_up(&li->block_q);
}
}
| 97,995,644,280,350,470,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,925 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_direct_io(int rw, struct kiocb *iocb, const struct iovec *iov,
loff_t pos, unsigned long nr_segs)
{
/*
* FIXME
* Eventually need to support direct IO for non forcedirectio mounts
*/
return -EINVAL;
}
| 252,843,705,627,619,170,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,926 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
int rc, xid;
xid = get_xid();
rc = cifs_revalidate_file(file);
if (rc) {
cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
rc);
free_xid(xid);
return rc;
}
rc = generic_file_mmap(file, vma);
if (rc == 0)
vma->vm_ops = &ci... | 50,151,077,298,924,310,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,927 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
__u64 length, __u8 type, struct cifsFileInfo *cfile,
struct cifsLockInfo **conf_lock, int rw_check)
{
struct cifsLockInfo *li;
struct cifsFileInfo *cur_cfile = fdlocks->cfile;
struct TCP_Server_Info *server = tlink_tcon(cfile->tl... | 96,183,599,972,769,960,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,928 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
__u8 type, struct cifsLockInfo **conf_lock,
int rw_check)
{
bool rc = false;
struct cifs_fid_locks *cur;
struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
list_for_each_entry(cur, &cinode->llist, llist) {
rc = cifs... | 106,819,949,867,214,660,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,929 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_free_llist(struct list_head *llist)
{
struct cifsLockInfo *li, *tmp;
list_for_each_entry_safe(li, tmp, llist, llist) {
cifs_del_lock_waiters(li);
list_del(&li->llist);
kfree(li);
}
}
| 18,859,444,861,656,897,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,930 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
{
unsigned int xid;
int rc = 0;
struct cifs_tcon *tcon;
struct TCP_Server_Info *server;
struct cifsFileInfo *smbfile = file->private_data;
struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
struct inode *inode = file->f_map... | 156,774,053,502,704,940,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,931 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
bool wait_flag, bool posix_lck, unsigned int xid)
{
int rc = 0;
__u64 length = 1 + flock->fl_end - flock->fl_start;
struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
struc... | 260,102,290,559,915,320,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,932 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_has_mand_locks(struct cifsInodeInfo *cinode)
{
struct cifs_fid_locks *cur;
bool has_locks = false;
down_read(&cinode->lock_sem);
list_for_each_entry(cur, &cinode->llist, llist) {
if (!list_empty(&cur->locks)) {
has_locks = true;
break;
}
}
up_read(&cinode->lock_sem);
return has_locks;
}
| 127,000,536,081,608,420,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,933 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static void cifs_invalidate_page(struct page *page, unsigned int offset,
unsigned int length)
{
struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
if (offset == 0 && length == PAGE_CACHE_SIZE)
cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
}
| 313,046,725,212,687,550,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,934 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_iovec_read(struct file *file, const struct iovec *iov,
unsigned long nr_segs, loff_t *poffset)
{
ssize_t rc;
size_t len, cur_len;
ssize_t total_read = 0;
loff_t offset = *poffset;
unsigned int npages;
struct cifs_sb_info *cifs_sb;
struct cifs_tcon *tcon;
struct cifsFileInfo *open_file;
struct cifs_read... | 237,628,611,187,639,000,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,935 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static int cifs_launder_page(struct page *page)
{
int rc = 0;
loff_t range_start = page_offset(page);
loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
struct writeback_control wbc = {
.sync_mode = WB_SYNC_ALL,
.nr_to_write = 0,
.range_start = range_start,
.range_end = range_end,
};
cifs_db... | 129,290,065,181,430,830,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,936 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
{
int rc, xid;
int lock = 0, unlock = 0;
bool wait_flag = false;
bool posix_lck = false;
struct cifs_sb_info *cifs_sb;
struct cifs_tcon *tcon;
struct cifsInodeInfo *cinode;
struct cifsFileInfo *cfile;
__u16 netfid;
__u32 type;
rc = -EACCES;
... | 189,734,968,919,479,720,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,937 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
{
struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
down_write(&cinode->lock_sem);
list_add_tail(&lock->llist, &cfile->llist->locks);
up_write(&cinode->lock_sem);
}
| 297,935,211,019,987,000,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,938 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
bool wait)
{
struct cifsLockInfo *conf_lock;
struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
bool exist;
int rc = 0;
try_again:
exist = false;
down_write(&cinode->lock_sem);
exist = cifs_find_lock_conflict(cfile, lock->of... | 29,274,664,523,833,820,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,939 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_lock_init(__u64 offset, __u64 length, __u8 type)
{
struct cifsLockInfo *lock =
kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
if (!lock)
return lock;
lock->offset = offset;
lock->length = length;
lock->type = type;
lock->pid = current->tgid;
INIT_LIST_HEAD(&lock->blist);
init_waitqueue_head(&lock->b... | 23,380,943,280,230,263,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,940 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
__u8 type, struct file_lock *flock)
{
int rc = 0;
struct cifsLockInfo *conf_lock;
struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
bool exist;
down_... | 281,069,309,641,930,700,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,941 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_move_llist(struct list_head *source, struct list_head *dest)
{
struct list_head *li, *tmp;
list_for_each_safe(li, tmp, source)
list_move(li, dest);
}
| 302,639,908,372,306,080,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,942 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
struct tcon_link *tlink, __u32 oplock)
{
struct dentry *dentry = file->f_path.dentry;
struct inode *inode = dentry->d_inode;
struct cifsInodeInfo *cinode = CIFS_I(inode);
struct cifsFileInfo *cfile;
struct cifs_fid_locks *fdlocks;
struct cifs_tcon *tc... | 268,437,059,092,295,280,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,943 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
struct cifs_fid *fid, unsigned int xid)
{
int rc;
int desired_access;
int disposition;
int create_options = CREATE_NOT_DIR;
FILE_ALL_INFO *buf;
struct TCP_Serve... | 305,502,678,164,748,600,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,944 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | int cifs_open(struct inode *inode, struct file *file)
{
int rc = -EACCES;
unsigned int xid;
__u32 oplock;
struct cifs_sb_info *cifs_sb;
struct TCP_Server_Info *server;
struct cifs_tcon *tcon;
struct tcon_link *tlink;
struct cifsFileInfo *cfile = NULL;
char *full_path = NULL;
bool posix_open_ok = false;
stru... | 203,377,254,078,210,230,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,945 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | void cifs_oplock_break(struct work_struct *work)
{
struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
oplock_break);
struct inode *inode = cfile->dentry->d_inode;
struct cifsInodeInfo *cinode = CIFS_I(inode);
struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
int rc = 0;
if (!CIFS_CACHE... | 286,050,617,019,098,700,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,946 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
{
struct page *page = vmf->page;
lock_page(page);
return VM_FAULT_LOCKED;
}
| 16,735,290,203,373,308,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,947 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
{
struct address_space *mapping = page->mapping;
loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
char *write_data;
int rc = -EFAULT;
int bytes_written = 0;
struct inode *inode;
struct cifsFileInfo *open_file;
if (!mapping ... | 327,011,817,096,326,000,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,948 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static u32 cifs_posix_convert_flags(unsigned int flags)
{
u32 posix_flags = 0;
if ((flags & O_ACCMODE) == O_RDONLY)
posix_flags = SMB_O_RDONLY;
else if ((flags & O_ACCMODE) == O_WRONLY)
posix_flags = SMB_O_WRONLY;
else if ((flags & O_ACCMODE) == O_RDWR)
posix_flags = SMB_O_RDWR;
if (flags & O_CREAT) {
po... | 29,819,620,948,105,570,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,949 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_posix_lock_set(struct file *file, struct file_lock *flock)
{
struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
int rc = 1;
if ((flock->fl_flags & FL_POSIX) == 0)
return rc;
try_again:
down_write(&cinode->lock_sem);
if (!cinode->can_cache_brlcks) {
up_write(&cinode->lock_sem);
return rc;
}
rc... | 266,741,122,708,450,700,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,950 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_posix_lock_test(struct file *file, struct file_lock *flock)
{
int rc = 0;
struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
unsigned char saved_type = flock->fl_type;
if ((flock->fl_flags & FL_POSIX) == 0)
return 1;
down_read(&cinode->lock_sem);
posix_test_lock(file, flock);
if (flock->fl_type =... | 333,638,415,290,124,800,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,951 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | int cifs_posix_open(char *full_path, struct inode **pinode,
struct super_block *sb, int mode, unsigned int f_flags,
__u32 *poplock, __u16 *pnetfid, unsigned int xid)
{
int rc;
FILE_UNIX_BASIC_INFO *presp_data;
__u32 posix_flags = 0;
struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
struct cifs_fattr fattr;
struct... | 337,925,682,672,292,200,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,952 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_push_locks(struct cifsFileInfo *cfile)
{
struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
int rc = 0;
/* we are going to update can_cache_brlcks here - need a write access */
down_wr... | 29,884,190,568,608,005,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,953 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
{
unsigned int xid;
int rc = 0, stored_rc;
struct cifsLockInfo *li, *tmp;
struct cifs_tcon *tcon;
unsigned int num, max_num, max_buf;
LOCKING_ANDX_RANGE *buf, *cur;
int types[] = {LOCKING_ANDX_LARGE_FILES,
LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARG... | 185,945,953,697,182,770,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,954 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_push_posix_locks(struct cifsFileInfo *cfile)
{
struct inode *inode = cfile->dentry->d_inode;
struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
struct file_lock *flock, **before;
unsigned int count = 0, i = 0;
int rc = 0, xid, type;
struct list_head locks_to_send, *el;
struct lock_to_push *lck, *tmp;
__u64... | 330,560,466,096,692,200,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,955 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
{
int rc = -EACCES;
unsigned int bytes_read = 0;
unsigned int total_read;
unsigned int current_read_size;
unsigned int rsize;
struct cifs_sb_info *cifs_sb;
struct cifs_tcon *tcon;
struct TCP_Server_Info *server;
unsigned int xid;
... | 132,843,290,156,873,150,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,956 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
bool *wait_flag, struct TCP_Server_Info *server)
{
if (flock->fl_flags & FL_POSIX)
cifs_dbg(FYI, "Posix\n");
if (flock->fl_flags & FL_FLOCK)
cifs_dbg(FYI, "Flock\n");
if (flock->fl_flags & FL_SLEEP) {
cifs_dbg(FYI, "Blocking lock\n... | 101,938,831,560,736,950,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,957 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
{
struct cifs_readdata *rdata;
rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
GFP_KERNEL);
if (rdata != NULL) {
kref_init(&rdata->refcount);
INIT_LIST_HEAD(&rdata->list);
init_completion(&rdata->done);
INIT_WORK(&rdata... | 106,781,792,461,336,040,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,958 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
unsigned long nr_segs, loff_t offset, ssize_t *copied)
{
int rc = 0;
struct iov_iter ii;
size_t pos = rdata->offset - offset;
ssize_t remaining = rdata->bytes;
unsigned char *pdata;
unsigned int i;
/* set up iov_iter and advance to th... | 332,821,121,081,412,500,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,959 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static int cifs_readpage(struct file *file, struct page *page)
{
loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
int rc = -EACCES;
unsigned int xid;
xid = get_xid();
if (file->private_data == NULL) {
rc = -EBADF;
free_xid(xid);
return rc;
}
cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
pa... | 46,942,141,140,493,710,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,960 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static int cifs_readpage_worker(struct file *file, struct page *page,
loff_t *poffset)
{
char *read_data;
int rc;
/* Is the page cached? */
rc = cifs_readpage_from_fscache(file_inode(file), page);
if (rc == 0)
goto read_complete;
read_data = kmap(page);
/* for reads over a certain size could initiate async ... | 244,732,084,324,801,050,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,961 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static int cifs_readpages(struct file *file, struct address_space *mapping,
struct list_head *page_list, unsigned num_pages)
{
int rc;
struct list_head tmplist;
struct cifsFileInfo *open_file = file->private_data;
struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
unsigned int rsize = cifs_sb->rsi... | 298,731,347,944,792,100,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,962 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
struct cifs_readdata *rdata, unsigned int len)
{
int total_read = 0, result = 0;
unsigned int i;
u64 eof;
pgoff_t eof_index;
unsigned int nr_pages = rdata->nr_pages;
struct kvec iov;
/* determine the eof that the server (probably) has */
eof = C... | 45,443,597,007,197,690,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,963 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_readv_complete(struct work_struct *work)
{
unsigned int i;
struct cifs_readdata *rdata = container_of(work,
struct cifs_readdata, work);
for (i = 0; i < rdata->nr_pages; i++) {
struct page *page = rdata->pages[i];
lru_cache_add_file(page);
if (rdata->result == 0) {
flush_dcache_page(page);
... | 322,396,901,307,771,100,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,964 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static int cifs_release_page(struct page *page, gfp_t gfp)
{
if (PagePrivate(page))
return 0;
return cifs_fscache_release_page(page, gfp);
}
| 275,918,499,855,642,600,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,965 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_relock_file(struct cifsFileInfo *cfile)
{
struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
int rc = 0;
down_read(&cinode->lock_sem);
if (cinode->can_cache_brlcks) {
/* can cache lo... | 110,782,748,504,333,990,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,966 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
{
int rc = -EACCES;
unsigned int xid;
__u32 oplock;
struct cifs_sb_info *cifs_sb;
struct cifs_tcon *tcon;
struct TCP_Server_Info *server;
struct cifsInodeInfo *cinode;
struct inode *inode;
char *full_path = NULL;
int desired_access;
int disposition... | 258,476,620,961,665,040,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,967 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_retry_async_readv(struct cifs_readdata *rdata)
{
int rc;
struct TCP_Server_Info *server;
server = tlink_tcon(rdata->cfile->tlink)->ses->server;
do {
if (rdata->cfile->invalidHandle) {
rc = cifs_reopen_file(rdata->cfile, true);
if (rc != 0)
continue;
}
rc = server->ops->async_readv(rdata);
} ... | 18,478,452,309,392,210,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,968 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
bool wait_flag, bool posix_lck, int lock, int unlock,
unsigned int xid)
{
int rc = 0;
__u64 length = 1 + flock->fl_end - flock->fl_start;
struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
struct cifs_tcon *tcon = tlink_... | 322,433,161,041,046,500,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,969 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
int datasync)
{
unsigned int xid;
int rc = 0;
struct cifs_tcon *tcon;
struct TCP_Server_Info *server;
struct cifsFileInfo *smbfile = file->private_data;
struct inode *inode = file_inode(file);
struct cifs_sb_info *cifs_sb = CIFS_SB(inode-... | 94,586,575,274,845,790,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,970 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
unsigned long nr_segs, loff_t pos)
{
struct inode *inode = file_inode(iocb->ki_filp);
struct cifsInodeInfo *cinode = CIFS_I(inode);
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
struct cifsFileInfo *cfile = (struct cifsFileInfo *)
iocb-... | 259,995,094,017,591,520,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,971 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
unsigned long nr_segs, loff_t pos)
{
struct inode *inode = file_inode(iocb->ki_filp);
struct cifsInodeInfo *cinode = CIFS_I(inode);
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
struct cifsFileInfo *cfile = (struct cifsFileInfo *)
ioc... | 249,471,135,489,272,680,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,972 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
struct cifs_readdata *rdata, unsigned int len)
{
int total_read = 0, result = 0;
unsigned int i;
unsigned int nr_pages = rdata->nr_pages;
struct kvec iov;
rdata->tailsz = PAGE_SIZE;
for (i = 0; i < nr_pages; i++) {
struct page *page = rdata->page... | 168,457,133,405,346,190,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,973 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_uncached_readdata_release(struct kref *refcount)
{
struct cifs_readdata *rdata = container_of(refcount,
struct cifs_readdata, refcount);
unsigned int i;
for (i = 0; i < rdata->nr_pages; i++) {
put_page(rdata->pages[i]);
rdata->pages[i] = NULL;
}
cifs_readdata_release(refcount);
}
| 285,971,196,886,192,380,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,974 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_uncached_readv_complete(struct work_struct *work)
{
struct cifs_readdata *rdata = container_of(work,
struct cifs_readdata, work);
complete(&rdata->done);
kref_put(&rdata->refcount, cifs_uncached_readdata_release);
}
| 221,293,218,261,632,780,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,975 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_uncached_retry_writev(struct cifs_writedata *wdata)
{
int rc;
struct TCP_Server_Info *server;
server = tlink_tcon(wdata->cfile->tlink)->ses->server;
do {
if (wdata->cfile->invalidHandle) {
rc = cifs_reopen_file(wdata->cfile, false);
if (rc != 0)
continue;
}
rc = server->ops->async_writev(wdat... | 42,844,523,865,487,900,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,976 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_uncached_writedata_release(struct kref *refcount)
{
int i;
struct cifs_writedata *wdata = container_of(refcount,
struct cifs_writedata, refcount);
for (i = 0; i < wdata->nr_pages; i++)
put_page(wdata->pages[i]);
cifs_writedata_release(refcount);
}
| 45,359,781,280,094,290,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,977 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_uncached_writev_complete(struct work_struct *work)
{
struct cifs_writedata *wdata = container_of(work,
struct cifs_writedata, work);
struct inode *inode = wdata->cfile->dentry->d_inode;
struct cifsInodeInfo *cifsi = CIFS_I(inode);
spin_lock(&inode->i_lock);
cifs_update_eof(cifsi, wdata->offset, wdata->b... | 339,935,163,611,382,650,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,978 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
unsigned int xid)
{
int rc = 0, stored_rc;
int types[] = {LOCKING_ANDX_LARGE_FILES,
LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
unsigned int i;
unsigned int max_num, num, max_buf;
LOCKING_ANDX_RANGE *buf, *cur;
struct ci... | 235,174,381,349,530,600,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,979 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
unsigned int bytes_written)
{
loff_t end_of_write = offset + bytes_written;
if (end_of_write > cifsi->server_eof)
cifsi->server_eof = end_of_write;
}
| 225,603,328,889,192,830,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,980 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
unsigned long nr_segs, loff_t pos)
{
ssize_t read;
read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
if (read > 0)
iocb->ki_pos = pos;
return read;
}
| 79,768,740,132,703,910,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,981 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static int cifs_write_begin(struct file *file, struct address_space *mapping,
loff_t pos, unsigned len, unsigned flags,
struct page **pagep, void **fsdata)
{
int oncethru = 0;
pgoff_t index = pos >> PAGE_CACHE_SHIFT;
loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
loff_t page_start = pos & PAGE_MASK;
loff_t i_s... | 134,915,309,626,835,100,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,982 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static int cifs_write_end(struct file *file, struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied,
struct page *page, void *fsdata)
{
int rc;
struct inode *inode = mapping->host;
struct cifsFileInfo *cfile = file->private_data;
struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
... | 310,379,112,650,437,500,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,983 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static int cifs_writepage(struct page *page, struct writeback_control *wbc)
{
int rc = cifs_writepage_locked(page, wbc);
unlock_page(page);
return rc;
}
| 60,206,967,504,640,210,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,984 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
{
int rc;
unsigned int xid;
xid = get_xid();
/* BB add check for wbc flags */
page_cache_get(page);
if (!PageUptodate(page))
cifs_dbg(FYI, "ppw - page not up to date\n");
/*
* Set the "writeback" flag, and clear "dirty" in the radix tre... | 146,221,805,040,784,960,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,985 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | static int cifs_writepages(struct address_space *mapping,
struct writeback_control *wbc)
{
struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
bool done = false, scanned = false, range_whole = false;
pgoff_t end, index;
struct cifs_writedata *wdata;
struct TCP_Server_Info *server;
struct page *page... | 214,513,326,872,361,000,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,986 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | cifs_writev(struct kiocb *iocb, const struct iovec *iov,
unsigned long nr_segs, loff_t pos)
{
struct file *file = iocb->ki_filp;
struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
struct inode *inode = file->f_mapping->host;
struct cifsInodeInfo *cinode = CIFS_I(inode);
struct TCP_Server_... | 247,198,163,303,941,560,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,987 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
bool fsuid_only)
{
struct cifsFileInfo *open_file = NULL;
struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
/* only filter by fsuid on multiuser mounts */
if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
fsuid_... | 250,543,540,957,686,700,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,988 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
bool fsuid_only)
{
struct cifsFileInfo *open_file, *inv_file = NULL;
struct cifs_sb_info *cifs_sb;
bool any_available = false;
int rc;
unsigned int refind = 0;
/* Having a null inode here (because mapping->host was set to zero by
the... | 291,633,759,578,434,700,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
39,989 | linux | 5d81de8e8667da7135d3a32a964087c0faf5483f | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d81de8e8667da7135d3a32a964087c0faf5483f | cifs: ensure that uncached writes handle unmapped areas correctly
It's possible for userland to pass down an iovec via writev() that has a
bogus user pointer in it. If that happens and we're doing an uncached
write, then we can end up getting less bytes than we expect from the
call to iov_iter_copy_from_user. This is ... | 0 | size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
{
size_t num_pages;
size_t clen;
clen = min_t(const size_t, len, wsize);
num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
if (cur_len)
*cur_len = clen;
return num_pages;
}
| 151,141,336,957,001,620,000,000,000,000,000,000,000 | file.c | 173,681,901,170,196,700,000,000,000,000,000,000,000 | [
"CWE-119"
] | CVE-2014-0069 | The cifs_iovec_write function in fs/cifs/file.c in the Linux kernel through 3.13.5 does not properly handle uncached write operations that copy fewer than the requested number of bytes, which allows local users to obtain sensitive information from kernel memory, cause a denial of service (memory corruption and system c... | https://nvd.nist.gov/vuln/detail/CVE-2014-0069 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.