sample_id large_string | dataset large_string | split large_string | source_record_id large_string | source_revision large_string | project large_string | repo_url large_string | canonical_repo_url large_string | commit_url large_string | fixing_commit_sha large_string | variant large_string | is_vulnerable bool | revision_sha large_string | container_path large_string | container_sha256 large_string | source_sha256 large_string | function_name large_string | function_of_interest large_string | prompt large list | file_path large_string | cve_ids large list | cve_description large_string | cwe_ids large list | cwe_description large_string | description large_string | vulnerable_function large_string | fixed_function large_string | commit_message large_string |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
000cebd5407544af25e8a8cd | openvul | train | train:8856 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | jabberd2 | https://github.com/jabberd2/jabberd2 | https://github.com/jabberd2/jabberd2 | https://github.com/jabberd2/jabberd2/commit/aabcffae560d5fd00cd1d2ffce5d760353cf0a4d | aabcffae560d5fd00cd1d2ffce5d760353cf0a4d | before | true | 0b1d913899381d3e2cdccbbc7a787561a50389b5 | containers/aa/aabcffae560d5fd00cd1d2ffce5d760353cf0a4d_before.sif | sha256:4323077b8f7cbda20b96e4881dcb303bc3e4e0a103f4d470cf48190528731b48 | sha256:19931247b9797e4b5269a0a6329adb3b954da2ae2f2a9b08964db268c3e231fb | _out_result | static void _out_result(conn_t out, nad_t nad) {
int attr;
jid_t from, to;
char *rkey;
int rkeylen;
attr = nad_find_attr(nad, 0, -1, "from", NULL);
if(attr < 0 || (from = jid_new(NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr))) == NULL) {
log_debug(ZONE, "missing or invalid from on db result... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | s2s/out.c | [
"CVE-2012-3525"
] | s2s/out.c in jabberd2 2.2.16 and earlier does not verify that a request was made for an XMPP Server Dialback response, which allows remote XMPP servers to spoof domains via a (1) Verify Response or (2) Authorization Response. | [
"CWE-20"
] | null | null | static void _out_result(conn_t out, nad_t nad) {
int attr;
jid_t from, to;
char *rkey;
int rkeylen;
attr = nad_find_attr(nad, 0, -1, "from", NULL);
if(attr < 0 || (from = jid_new(NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr))) == NULL) {
log_debug(ZONE, "missing or invalid from on db result... | static void _out_result(conn_t out, nad_t nad) {
int attr;
jid_t from, to;
char *rkey;
int rkeylen;
attr = nad_find_attr(nad, 0, -1, "from", NULL);
if(attr < 0 || (from = jid_new(NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr))) == NULL) {
log_debug(ZONE, "missing or invalid from on db result... | Fixed possibility of Unsolicited Dialback Attacks |
000cebd5407544af25e8a8cd | openvul | train | train:8856 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | jabberd2 | https://github.com/jabberd2/jabberd2 | https://github.com/jabberd2/jabberd2 | https://github.com/jabberd2/jabberd2/commit/aabcffae560d5fd00cd1d2ffce5d760353cf0a4d | aabcffae560d5fd00cd1d2ffce5d760353cf0a4d | after | false | aabcffae560d5fd00cd1d2ffce5d760353cf0a4d | containers/aa/aabcffae560d5fd00cd1d2ffce5d760353cf0a4d_after.sif | sha256:b728d0d4d83c69c80203144aef37ed0b52e21abdc1d717aa4d2295d765ebe359 | sha256:d668d5bd91c9c9dacb6904c919424172636ec867e46b8b6fa17c633bc4c36ca3 | _out_result | static void _out_result(conn_t out, nad_t nad) {
int attr;
jid_t from, to;
char *rkey;
int rkeylen;
attr = nad_find_attr(nad, 0, -1, "from", NULL);
if(attr < 0 || (from = jid_new(NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr))) == NULL) {
log_debug(ZONE, "missing or invalid from on db result... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | s2s/out.c | [
"CVE-2012-3525"
] | s2s/out.c in jabberd2 2.2.16 and earlier does not verify that a request was made for an XMPP Server Dialback response, which allows remote XMPP servers to spoof domains via a (1) Verify Response or (2) Authorization Response. | [
"CWE-20"
] | null | null | static void _out_result(conn_t out, nad_t nad) {
int attr;
jid_t from, to;
char *rkey;
int rkeylen;
attr = nad_find_attr(nad, 0, -1, "from", NULL);
if(attr < 0 || (from = jid_new(NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr))) == NULL) {
log_debug(ZONE, "missing or invalid from on db result... | static void _out_result(conn_t out, nad_t nad) {
int attr;
jid_t from, to;
char *rkey;
int rkeylen;
attr = nad_find_attr(nad, 0, -1, "from", NULL);
if(attr < 0 || (from = jid_new(NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr))) == NULL) {
log_debug(ZONE, "missing or invalid from on db result... | Fixed possibility of Unsolicited Dialback Attacks |
002df632e20f28f79dd6aebf | openvul | train | train:7786 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/45f6fad84cc305103b28d73482b344d7f5b76f39 | 45f6fad84cc305103b28d73482b344d7f5b76f39 | before | true | 01b3f52157ff5a47d6d8d796f396a4b34a53c61d | containers/45/45f6fad84cc305103b28d73482b344d7f5b76f39_before.sif | sha256:11b9faa1b06a2f113554d999ae3bead306ee0c0f045aa5bc7a401b7835ad854a | sha256:de6227a6767b5a30e1fb0adb40e236d66258f90cecb5ba0d265de5c6d4355267 | inet6_csk_route_socket | static struct dst_entry *inet6_csk_route_socket(struct sock *sk,
struct flowi6 *fl6)
{
struct inet_sock *inet = inet_sk(sk);
struct ipv6_pinfo *np = inet6_sk(sk);
struct in6_addr *final_p, final;
struct dst_entry *dst;
memset(fl6, 0, sizeof(*fl6));
fl6->flowi6_proto = sk->sk_protocol;
fl6->daddr = sk->sk_v... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/ipv6/inet6_connection_sock.c | [
"CVE-2016-3841"
] | The IPv6 stack in the Linux kernel before 4.3.3 mishandles options data, which allows local users to gain privileges or cause a denial of service (use-after-free and system crash) via a crafted sendmsg system call. | [
"CWE-264, CWE-416"
] | null | null | static struct dst_entry *inet6_csk_route_socket(struct sock *sk,
struct flowi6 *fl6)
{
struct inet_sock *inet = inet_sk(sk);
struct ipv6_pinfo *np = inet6_sk(sk);
struct in6_addr *final_p, final;
struct dst_entry *dst;
memset(fl6, 0, sizeof(*fl6));
fl6->flowi6_proto = sk->sk_protocol;
fl6->daddr = sk->sk_v... | static struct dst_entry *inet6_csk_route_socket(struct sock *sk,
struct flowi6 *fl6)
{
struct inet_sock *inet = inet_sk(sk);
struct ipv6_pinfo *np = inet6_sk(sk);
struct in6_addr *final_p, final;
struct dst_entry *dst;
memset(fl6, 0, sizeof(*fl6));
fl6->flowi6_proto = sk->sk_protocol;
fl6->daddr = sk->sk_v... | ipv6: add complete rcu protection around np->opt
This patch addresses multiple problems :
UDP/RAW sendmsg() need to get a stable struct ipv6_txoptions
while socket is not locked : Other threads can change np->opt
concurrently. Dmitry posted a syzkaller
(http://github.com/google/syzkaller) program desmonstrating
use-a... |
002df632e20f28f79dd6aebf | openvul | train | train:7786 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/45f6fad84cc305103b28d73482b344d7f5b76f39 | 45f6fad84cc305103b28d73482b344d7f5b76f39 | after | false | 45f6fad84cc305103b28d73482b344d7f5b76f39 | containers/45/45f6fad84cc305103b28d73482b344d7f5b76f39_after.sif | sha256:09d613bc218022168a94b992e509e3822632c9b62d5478c0052dd40e2c560586 | sha256:ced034de510b27f442b88d45626ef57496b7c688ebccdf818e6c05935181d86c | inet6_csk_route_socket | static struct dst_entry *inet6_csk_route_socket(struct sock *sk,
struct flowi6 *fl6)
{
struct inet_sock *inet = inet_sk(sk);
struct ipv6_pinfo *np = inet6_sk(sk);
struct in6_addr *final_p, final;
struct dst_entry *dst;
memset(fl6, 0, sizeof(*fl6));
fl6->flowi6_proto = sk->sk_protocol;
fl6->daddr = sk->sk_v... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/ipv6/inet6_connection_sock.c | [
"CVE-2016-3841"
] | The IPv6 stack in the Linux kernel before 4.3.3 mishandles options data, which allows local users to gain privileges or cause a denial of service (use-after-free and system crash) via a crafted sendmsg system call. | [
"CWE-264, CWE-416"
] | null | null | static struct dst_entry *inet6_csk_route_socket(struct sock *sk,
struct flowi6 *fl6)
{
struct inet_sock *inet = inet_sk(sk);
struct ipv6_pinfo *np = inet6_sk(sk);
struct in6_addr *final_p, final;
struct dst_entry *dst;
memset(fl6, 0, sizeof(*fl6));
fl6->flowi6_proto = sk->sk_protocol;
fl6->daddr = sk->sk_v... | static struct dst_entry *inet6_csk_route_socket(struct sock *sk,
struct flowi6 *fl6)
{
struct inet_sock *inet = inet_sk(sk);
struct ipv6_pinfo *np = inet6_sk(sk);
struct in6_addr *final_p, final;
struct dst_entry *dst;
memset(fl6, 0, sizeof(*fl6));
fl6->flowi6_proto = sk->sk_protocol;
fl6->daddr = sk->sk_v... | ipv6: add complete rcu protection around np->opt
This patch addresses multiple problems :
UDP/RAW sendmsg() need to get a stable struct ipv6_txoptions
while socket is not locked : Other threads can change np->opt
concurrently. Dmitry posted a syzkaller
(http://github.com/google/syzkaller) program desmonstrating
use-a... |
002fb5a9eda762b0676f7990 | openvul | train | train:7782 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/45f6fad84cc305103b28d73482b344d7f5b76f39 | 45f6fad84cc305103b28d73482b344d7f5b76f39 | before | true | 01b3f52157ff5a47d6d8d796f396a4b34a53c61d | containers/45/45f6fad84cc305103b28d73482b344d7f5b76f39_before.sif | sha256:11b9faa1b06a2f113554d999ae3bead306ee0c0f045aa5bc7a401b7835ad854a | sha256:de6227a6767b5a30e1fb0adb40e236d66258f90cecb5ba0d265de5c6d4355267 | inet6_sk_rebuild_header | int inet6_sk_rebuild_header(struct sock *sk)
{
struct ipv6_pinfo *np = inet6_sk(sk);
struct dst_entry *dst;
dst = __sk_dst_check(sk, np->dst_cookie);
if (!dst) {
struct inet_sock *inet = inet_sk(sk);
struct in6_addr *final_p, final;
struct flowi6 fl6;
memset(&fl6, 0, sizeof(fl6));
fl6.flowi6_proto = sk->s... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/ipv6/af_inet6.c | [
"CVE-2016-3841"
] | The IPv6 stack in the Linux kernel before 4.3.3 mishandles options data, which allows local users to gain privileges or cause a denial of service (use-after-free and system crash) via a crafted sendmsg system call. | [
"CWE-264, CWE-416"
] | null | null | int inet6_sk_rebuild_header(struct sock *sk)
{
struct ipv6_pinfo *np = inet6_sk(sk);
struct dst_entry *dst;
dst = __sk_dst_check(sk, np->dst_cookie);
if (!dst) {
struct inet_sock *inet = inet_sk(sk);
struct in6_addr *final_p, final;
struct flowi6 fl6;
memset(&fl6, 0, sizeof(fl6));
fl6.flowi6_proto = sk->s... | int inet6_sk_rebuild_header(struct sock *sk)
{
struct ipv6_pinfo *np = inet6_sk(sk);
struct dst_entry *dst;
dst = __sk_dst_check(sk, np->dst_cookie);
if (!dst) {
struct inet_sock *inet = inet_sk(sk);
struct in6_addr *final_p, final;
struct flowi6 fl6;
memset(&fl6, 0, sizeof(fl6));
fl6.flowi6_proto = sk->s... | ipv6: add complete rcu protection around np->opt
This patch addresses multiple problems :
UDP/RAW sendmsg() need to get a stable struct ipv6_txoptions
while socket is not locked : Other threads can change np->opt
concurrently. Dmitry posted a syzkaller
(http://github.com/google/syzkaller) program desmonstrating
use-a... |
002fb5a9eda762b0676f7990 | openvul | train | train:7782 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/45f6fad84cc305103b28d73482b344d7f5b76f39 | 45f6fad84cc305103b28d73482b344d7f5b76f39 | after | false | 45f6fad84cc305103b28d73482b344d7f5b76f39 | containers/45/45f6fad84cc305103b28d73482b344d7f5b76f39_after.sif | sha256:09d613bc218022168a94b992e509e3822632c9b62d5478c0052dd40e2c560586 | sha256:ced034de510b27f442b88d45626ef57496b7c688ebccdf818e6c05935181d86c | inet6_sk_rebuild_header | int inet6_sk_rebuild_header(struct sock *sk)
{
struct ipv6_pinfo *np = inet6_sk(sk);
struct dst_entry *dst;
dst = __sk_dst_check(sk, np->dst_cookie);
if (!dst) {
struct inet_sock *inet = inet_sk(sk);
struct in6_addr *final_p, final;
struct flowi6 fl6;
memset(&fl6, 0, sizeof(fl6));
fl6.flowi6_proto = sk->s... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/ipv6/af_inet6.c | [
"CVE-2016-3841"
] | The IPv6 stack in the Linux kernel before 4.3.3 mishandles options data, which allows local users to gain privileges or cause a denial of service (use-after-free and system crash) via a crafted sendmsg system call. | [
"CWE-264, CWE-416"
] | null | null | int inet6_sk_rebuild_header(struct sock *sk)
{
struct ipv6_pinfo *np = inet6_sk(sk);
struct dst_entry *dst;
dst = __sk_dst_check(sk, np->dst_cookie);
if (!dst) {
struct inet_sock *inet = inet_sk(sk);
struct in6_addr *final_p, final;
struct flowi6 fl6;
memset(&fl6, 0, sizeof(fl6));
fl6.flowi6_proto = sk->s... | int inet6_sk_rebuild_header(struct sock *sk)
{
struct ipv6_pinfo *np = inet6_sk(sk);
struct dst_entry *dst;
dst = __sk_dst_check(sk, np->dst_cookie);
if (!dst) {
struct inet_sock *inet = inet_sk(sk);
struct in6_addr *final_p, final;
struct flowi6 fl6;
memset(&fl6, 0, sizeof(fl6));
fl6.flowi6_proto = sk->s... | ipv6: add complete rcu protection around np->opt
This patch addresses multiple problems :
UDP/RAW sendmsg() need to get a stable struct ipv6_txoptions
while socket is not locked : Other threads can change np->opt
concurrently. Dmitry posted a syzkaller
(http://github.com/google/syzkaller) program desmonstrating
use-a... |
00404c78aef7645abddb317d | openvul | train | train:12240 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow/commit/1970c2158b1ffa416d159d03c3370b9a462aee35 | 1970c2158b1ffa416d159d03c3370b9a462aee35 | before | true | fff2c8326280c07733828f990548979bdc893859 | containers/19/1970c2158b1ffa416d159d03c3370b9a462aee35_before.sif | sha256:425efe01da0ebc3b0e8357f418502e8727804dec64f4c596091b51f85a0225c8 | sha256:947649ae5a0a28f628cb308b3181afc4adf2bdca710f56e8e075efa4ccf281dc | EvalHybrid | void EvalHybrid(TfLiteContext* context, TfLiteNode* node,
TfLiteConvParams* params, OpData* data,
const TfLiteTensor* input, const TfLiteTensor* filter,
const TfLiteTensor* bias, TfLiteTensor* im2col,
TfLiteTensor* accum_scratch, TfLiteTensor* output) {
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | tensorflow/lite/kernels/conv.cc | [
"CVE-2020-15211"
] | In TensorFlow Lite before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, saved models in the flatbuffer format use a double indexing scheme: a model has a set of subgraphs, each subgraph has a set of operators and each operator has a set of input/output tensors. The flatbuffer format uses indices for the tensors, inde... | [
"CWE-125, CWE-787"
] | null | null | void EvalHybrid(TfLiteContext* context, TfLiteNode* node,
TfLiteConvParams* params, OpData* data,
const TfLiteTensor* input, const TfLiteTensor* filter,
const TfLiteTensor* bias, TfLiteTensor* im2col,
TfLiteTensor* accum_scratch, TfLiteTensor* output) {
... | TfLiteStatus EvalHybrid(TfLiteContext* context, TfLiteNode* node,
TfLiteConvParams* params, OpData* data,
const TfLiteTensor* input, const TfLiteTensor* filter,
const TfLiteTensor* bias, TfLiteTensor* im2col,
TfLiteTensor* a... | [tflite]: Insert `nullptr` checks when obtaining tensors.
As part of ongoing refactoring, `tflite::GetInput`, `tflite::GetOutput`, `tflite::GetTemporary` and `tflite::GetIntermediates` will return `nullptr` in some cases. Hence, we insert the `nullptr` checks on all usages.
We also insert `nullptr` checks on usages o... |
00404c78aef7645abddb317d | openvul | train | train:12240 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow/commit/1970c2158b1ffa416d159d03c3370b9a462aee35 | 1970c2158b1ffa416d159d03c3370b9a462aee35 | after | false | 1970c2158b1ffa416d159d03c3370b9a462aee35 | containers/19/1970c2158b1ffa416d159d03c3370b9a462aee35_after.sif | sha256:fde39b16c9b1f2a94bef2bd9df41f9bd4eb01a5768fef7c0c4a33c03011f3d96 | sha256:7ecbabd9073bbf8dcf9d35896380b0ab042d8fe345e43ce8e8b7711e96056a54 | EvalHybrid | TfLiteStatus EvalHybrid(TfLiteContext* context, TfLiteNode* node,
TfLiteConvParams* params, OpData* data,
const TfLiteTensor* input, const TfLiteTensor* filter,
const TfLiteTensor* bias, TfLiteTensor* im2col,
TfLiteTensor* a... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | tensorflow/lite/kernels/conv.cc | [
"CVE-2020-15211"
] | In TensorFlow Lite before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, saved models in the flatbuffer format use a double indexing scheme: a model has a set of subgraphs, each subgraph has a set of operators and each operator has a set of input/output tensors. The flatbuffer format uses indices for the tensors, inde... | [
"CWE-125, CWE-787"
] | null | null | void EvalHybrid(TfLiteContext* context, TfLiteNode* node,
TfLiteConvParams* params, OpData* data,
const TfLiteTensor* input, const TfLiteTensor* filter,
const TfLiteTensor* bias, TfLiteTensor* im2col,
TfLiteTensor* accum_scratch, TfLiteTensor* output) {
... | TfLiteStatus EvalHybrid(TfLiteContext* context, TfLiteNode* node,
TfLiteConvParams* params, OpData* data,
const TfLiteTensor* input, const TfLiteTensor* filter,
const TfLiteTensor* bias, TfLiteTensor* im2col,
TfLiteTensor* a... | [tflite]: Insert `nullptr` checks when obtaining tensors.
As part of ongoing refactoring, `tflite::GetInput`, `tflite::GetOutput`, `tflite::GetTemporary` and `tflite::GetIntermediates` will return `nullptr` in some cases. Hence, we insert the `nullptr` checks on all usages.
We also insert `nullptr` checks on usages o... |
0044e81c93d0df300a8442ce | openvul | train | train:1536 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/2287a51ba822384834dafc1c798453375d1107c7 | 2287a51ba822384834dafc1c798453375d1107c7 | before | true | 3a2b2eb55681158d3e3ef464fbf47574cf0c517c | containers/22/2287a51ba822384834dafc1c798453375d1107c7_before.sif | sha256:30d748dbe4913b42ae8fe82e90191aa8f194c7d1d342358abe4f2c42a67b19f7 | sha256:2b7393ce3cab305702898e4edc95de3a80c72ebec08a5e6def2e9f6690aa8df9 | vt_k_ioctl | static int vt_k_ioctl(struct tty_struct *tty, unsigned int cmd,
unsigned long arg, bool perm)
{
struct vc_data *vc = tty->driver_data;
void __user *up = (void __user *)arg;
unsigned int console = vc->vc_num;
int ret;
switch (cmd) {
case KIOCSOUND:
if (!perm)
return -EPERM;
if (arg)
arg = PIT_TICK_RATE... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | drivers/tty/vt/vt_ioctl.c | [
"CVE-2021-3753"
] | A race problem was seen in the vt_k_ioctl in drivers/tty/vt/vt_ioctl.c in the Linux kernel, which may cause an out of bounds read in vt as the write access to vc_mode is not protected by lock-in vt_ioctl (KDSETMDE). The highest threat from this vulnerability is to data confidentiality. | [
"CWE-200"
] | null | null | static int vt_k_ioctl(struct tty_struct *tty, unsigned int cmd,
unsigned long arg, bool perm)
{
struct vc_data *vc = tty->driver_data;
void __user *up = (void __user *)arg;
unsigned int console = vc->vc_num;
int ret;
switch (cmd) {
case KIOCSOUND:
if (!perm)
return -EPERM;
if (arg)
arg = PIT_TICK_RATE... | static int vt_k_ioctl(struct tty_struct *tty, unsigned int cmd,
unsigned long arg, bool perm)
{
struct vc_data *vc = tty->driver_data;
void __user *up = (void __user *)arg;
unsigned int console = vc->vc_num;
int ret;
switch (cmd) {
case KIOCSOUND:
if (!perm)
return -EPERM;
if (arg)
arg = PIT_TICK_RATE... | vt_kdsetmode: extend console locking
As per the long-suffering comment.
Reported-by: Minh Yuan <yuanmingbuaa@gmail.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Jiri Slaby <jirislaby@kernel.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> |
0044e81c93d0df300a8442ce | openvul | train | train:1536 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/2287a51ba822384834dafc1c798453375d1107c7 | 2287a51ba822384834dafc1c798453375d1107c7 | after | false | 2287a51ba822384834dafc1c798453375d1107c7 | containers/22/2287a51ba822384834dafc1c798453375d1107c7_after.sif | sha256:818b4319b975c9ea63fe8e35b9cd5de20257395ff06612402ff649502c2bba91 | sha256:98b362d75adab1de52c5d6834a9da681c7143042372052a3dff75244b77e6b33 | vt_k_ioctl | static int vt_k_ioctl(struct tty_struct *tty, unsigned int cmd,
unsigned long arg, bool perm)
{
struct vc_data *vc = tty->driver_data;
void __user *up = (void __user *)arg;
unsigned int console = vc->vc_num;
int ret;
switch (cmd) {
case KIOCSOUND:
if (!perm)
return -EPERM;
if (arg)
arg = PIT_TICK_RATE... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | drivers/tty/vt/vt_ioctl.c | [
"CVE-2021-3753"
] | A race problem was seen in the vt_k_ioctl in drivers/tty/vt/vt_ioctl.c in the Linux kernel, which may cause an out of bounds read in vt as the write access to vc_mode is not protected by lock-in vt_ioctl (KDSETMDE). The highest threat from this vulnerability is to data confidentiality. | [
"CWE-200"
] | null | null | static int vt_k_ioctl(struct tty_struct *tty, unsigned int cmd,
unsigned long arg, bool perm)
{
struct vc_data *vc = tty->driver_data;
void __user *up = (void __user *)arg;
unsigned int console = vc->vc_num;
int ret;
switch (cmd) {
case KIOCSOUND:
if (!perm)
return -EPERM;
if (arg)
arg = PIT_TICK_RATE... | static int vt_k_ioctl(struct tty_struct *tty, unsigned int cmd,
unsigned long arg, bool perm)
{
struct vc_data *vc = tty->driver_data;
void __user *up = (void __user *)arg;
unsigned int console = vc->vc_num;
int ret;
switch (cmd) {
case KIOCSOUND:
if (!perm)
return -EPERM;
if (arg)
arg = PIT_TICK_RATE... | vt_kdsetmode: extend console locking
As per the long-suffering comment.
Reported-by: Minh Yuan <yuanmingbuaa@gmail.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Jiri Slaby <jirislaby@kernel.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> |
00486bfd5a30b1d5e0d61dff | openvul | train | train:3934 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | jasper | https://github.com/mdadams/jasper | https://github.com/jasper-software/jasper | https://github.com/jasper-software/jasper/commit/03db7c81f6a8a92d896249bc673877749987fd7a | 03db7c81f6a8a92d896249bc673877749987fd7a | before | true | 839b1bcf0450ff036c28e8db40a7abf886e02891 | containers/03/03db7c81f6a8a92d896249bc673877749987fd7a_before.sif | sha256:b1c3cadb0930ca7a11483a648bd2e358c5ab126fd192c224c72637ece8bb5348 | sha256:948d6509bb42c4ae3c1af5046631554114ee31ae007768c6ea3aa84ceed55d45 | jp2_encode | int jp2_encode(jas_image_t *image, jas_stream_t *out, const char *optstr)
{
jp2_box_t *box;
jp2_ftyp_t *ftyp;
jp2_ihdr_t *ihdr;
jas_stream_t *tmpstream;
int allcmptssame;
jp2_bpcc_t *bpcc;
long len;
uint_fast16_t cmptno;
jp2_colr_t *colr;
char buf[4096];
uint_fast32_t overhead;
jp2_cdefchan_t *cdefchanent;
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | src/libjasper/jp2/jp2_enc.c | [
"CVE-2018-20570"
] | jp2_encode in jp2/jp2_enc.c in JasPer 2.0.14 has a heap-based buffer over-read. | [
"CWE-125"
] | null | null | int jp2_encode(jas_image_t *image, jas_stream_t *out, const char *optstr)
{
jp2_box_t *box;
jp2_ftyp_t *ftyp;
jp2_ihdr_t *ihdr;
jas_stream_t *tmpstream;
int allcmptssame;
jp2_bpcc_t *bpcc;
long len;
uint_fast16_t cmptno;
jp2_colr_t *colr;
char buf[4096];
uint_fast32_t overhead;
jp2_cdefchan_t *cdefchanent;
... | int jp2_encode(jas_image_t *image, jas_stream_t *out, const char *optstr)
{
jp2_box_t *box;
jp2_ftyp_t *ftyp;
jp2_ihdr_t *ihdr;
jas_stream_t *tmpstream;
int allcmptssame;
jp2_bpcc_t *bpcc;
long len;
uint_fast16_t cmptno;
jp2_colr_t *colr;
char buf[4096];
uint_fast32_t overhead;
jp2_cdefchan_t *cdefchanent;
... | jp2_enc: check number of components before dereferencing them
Fixes CVE-2018-20570
Closes https://github.com/jasper-maint/jasper/issues/11
Closes https://github.com/mdadams/jasper/issues/191 |
00486bfd5a30b1d5e0d61dff | openvul | train | train:3934 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | jasper | https://github.com/mdadams/jasper | https://github.com/jasper-software/jasper | https://github.com/jasper-software/jasper/commit/03db7c81f6a8a92d896249bc673877749987fd7a | 03db7c81f6a8a92d896249bc673877749987fd7a | after | false | 03db7c81f6a8a92d896249bc673877749987fd7a | containers/03/03db7c81f6a8a92d896249bc673877749987fd7a_after.sif | sha256:78f1aa09c9f607b48a30acb5bd2baf328e875126c1d4ab738b23626eaef7dbfc | sha256:f38be505a12607c4f1f787865696df409860984e7519c6e28723f1003e6c3398 | jp2_encode | int jp2_encode(jas_image_t *image, jas_stream_t *out, const char *optstr)
{
jp2_box_t *box;
jp2_ftyp_t *ftyp;
jp2_ihdr_t *ihdr;
jas_stream_t *tmpstream;
int allcmptssame;
jp2_bpcc_t *bpcc;
long len;
uint_fast16_t cmptno;
jp2_colr_t *colr;
char buf[4096];
uint_fast32_t overhead;
jp2_cdefchan_t *cdefchanent;
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | src/libjasper/jp2/jp2_enc.c | [
"CVE-2018-20570"
] | jp2_encode in jp2/jp2_enc.c in JasPer 2.0.14 has a heap-based buffer over-read. | [
"CWE-125"
] | null | null | int jp2_encode(jas_image_t *image, jas_stream_t *out, const char *optstr)
{
jp2_box_t *box;
jp2_ftyp_t *ftyp;
jp2_ihdr_t *ihdr;
jas_stream_t *tmpstream;
int allcmptssame;
jp2_bpcc_t *bpcc;
long len;
uint_fast16_t cmptno;
jp2_colr_t *colr;
char buf[4096];
uint_fast32_t overhead;
jp2_cdefchan_t *cdefchanent;
... | int jp2_encode(jas_image_t *image, jas_stream_t *out, const char *optstr)
{
jp2_box_t *box;
jp2_ftyp_t *ftyp;
jp2_ihdr_t *ihdr;
jas_stream_t *tmpstream;
int allcmptssame;
jp2_bpcc_t *bpcc;
long len;
uint_fast16_t cmptno;
jp2_colr_t *colr;
char buf[4096];
uint_fast32_t overhead;
jp2_cdefchan_t *cdefchanent;
... | jp2_enc: check number of components before dereferencing them
Fixes CVE-2018-20570
Closes https://github.com/jasper-maint/jasper/issues/11
Closes https://github.com/mdadams/jasper/issues/191 |
004a2af61b5ba4d5d9265046 | openvul | train | train:1760 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | evince | https://github.com/GNOME/evince | https://github.com/GNOME/evince | https://gitlab.gnome.org/GNOME/evince/commit/234f034a4d15cd46dd556f4945f99fbd57ef5f15 | 234f034a4d15cd46dd556f4945f99fbd57ef5f15 | before | true | c23f2a2cb7899e9b8cdef17aae71848eb8367860 | containers/23/234f034a4d15cd46dd556f4945f99fbd57ef5f15_before.sif | sha256:38ec27adfea60fdf94e3e11283fe31313ab848231bef2d81b48c5991126a5467 | sha256:963672bbab5ce4f85341b48f612be2c7f0293bf703b1563cd055f5eab7743cff | tiff_document_get_thumbnail | tiff_document_get_thumbnail (EvDocument *document,
EvRenderContext *rc)
{
TiffDocument *tiff_document = TIFF_DOCUMENT (document);
int width, height;
int scaled_width, scaled_height;
float x_res, y_res;
gint rowstride, bytes;
guchar *pixels = NULL;
GdkPixbuf *pixbuf;
GdkPixbuf *scaled_pixbuf;
GdkPi... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | backend/tiff/tiff-document.c | [
"CVE-2019-11459"
] | The tiff_document_render() and tiff_document_get_thumbnail() functions in the TIFF document backend in GNOME Evince through 3.32.0 did not handle errors from TIFFReadRGBAImageOriented(), leading to uninitialized memory use when processing certain TIFF image files. | [
"CWE-754"
] | null | null | tiff_document_get_thumbnail (EvDocument *document,
EvRenderContext *rc)
{
TiffDocument *tiff_document = TIFF_DOCUMENT (document);
int width, height;
int scaled_width, scaled_height;
float x_res, y_res;
gint rowstride, bytes;
guchar *pixels = NULL;
GdkPixbuf *pixbuf;
GdkPixbuf *scaled_pixbuf;
GdkPi... | tiff_document_get_thumbnail (EvDocument *document,
EvRenderContext *rc)
{
TiffDocument *tiff_document = TIFF_DOCUMENT (document);
int width, height;
int scaled_width, scaled_height;
float x_res, y_res;
gint rowstride, bytes;
guchar *pixels = NULL;
GdkPixbuf *pixbuf;
GdkPixbuf *scaled_pixbuf;
GdkPi... | tiff: Handle failure from TIFFReadRGBAImageOriented
The TIFFReadRGBAImageOriented function returns zero if it was unable to
read the image. Return NULL in this case instead of displaying
uninitialized memory.
Fixes #1129 |
004a2af61b5ba4d5d9265046 | openvul | train | train:1760 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | evince | https://github.com/GNOME/evince | https://github.com/GNOME/evince | https://gitlab.gnome.org/GNOME/evince/commit/234f034a4d15cd46dd556f4945f99fbd57ef5f15 | 234f034a4d15cd46dd556f4945f99fbd57ef5f15 | after | false | 234f034a4d15cd46dd556f4945f99fbd57ef5f15 | containers/23/234f034a4d15cd46dd556f4945f99fbd57ef5f15_after.sif | sha256:5323e234d87d6237a39fe1db5fec71bb246394ba0d9b32ee16af9c235f344215 | sha256:4209a516f897b2d334d94e11a40fef9a83b6a0e69e2e0a3ca9562ffa2cb21c8c | tiff_document_get_thumbnail | tiff_document_get_thumbnail (EvDocument *document,
EvRenderContext *rc)
{
TiffDocument *tiff_document = TIFF_DOCUMENT (document);
int width, height;
int scaled_width, scaled_height;
float x_res, y_res;
gint rowstride, bytes;
guchar *pixels = NULL;
GdkPixbuf *pixbuf;
GdkPixbuf *scaled_pixbuf;
GdkPi... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | backend/tiff/tiff-document.c | [
"CVE-2019-11459"
] | The tiff_document_render() and tiff_document_get_thumbnail() functions in the TIFF document backend in GNOME Evince through 3.32.0 did not handle errors from TIFFReadRGBAImageOriented(), leading to uninitialized memory use when processing certain TIFF image files. | [
"CWE-754"
] | null | null | tiff_document_get_thumbnail (EvDocument *document,
EvRenderContext *rc)
{
TiffDocument *tiff_document = TIFF_DOCUMENT (document);
int width, height;
int scaled_width, scaled_height;
float x_res, y_res;
gint rowstride, bytes;
guchar *pixels = NULL;
GdkPixbuf *pixbuf;
GdkPixbuf *scaled_pixbuf;
GdkPi... | tiff_document_get_thumbnail (EvDocument *document,
EvRenderContext *rc)
{
TiffDocument *tiff_document = TIFF_DOCUMENT (document);
int width, height;
int scaled_width, scaled_height;
float x_res, y_res;
gint rowstride, bytes;
guchar *pixels = NULL;
GdkPixbuf *pixbuf;
GdkPixbuf *scaled_pixbuf;
GdkPi... | tiff: Handle failure from TIFFReadRGBAImageOriented
The TIFFReadRGBAImageOriented function returns zero if it was unable to
read the image. Return NULL in this case instead of displaying
uninitialized memory.
Fixes #1129 |
004bdff3354bc830d6bc0cdc | openvul | train | train:5538 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b1728ff617f88a1f7a5d8c8f21fe17a2f6af5d16 | b1728ff617f88a1f7a5d8c8f21fe17a2f6af5d16 | before | true | 22f584c5c665461d6bb3d4e242084e4a5b87d5b6 | containers/b1/b1728ff617f88a1f7a5d8c8f21fe17a2f6af5d16_before.sif | sha256:83eeefefbf0a8f0042139eae90c32a8d69b0266cf4a94c55fca645fb1d0b1971 | sha256:12b746e4772655939b288c70dbfabc81c174757bf329de85cb5f2b4fdc01fed0 | __dvb_frontend_free | static void __dvb_frontend_free(struct dvb_frontend *fe)
{
struct dvb_frontend_private *fepriv = fe->frontend_priv;
if (fepriv)
dvb_free_device(fepriv->dvbdev);
dvb_frontend_invoke_release(fe, fe->ops.release);
if (fepriv)
kfree(fepriv);
} | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | drivers/media/dvb-core/dvb_frontend.c | [
"CVE-2017-16648"
] | The dvb_frontend_free function in drivers/media/dvb-core/dvb_frontend.c in the Linux kernel through 4.13.11 allows local users to cause a denial of service (use-after-free and system crash) or possibly have unspecified other impact via a crafted USB device. NOTE: the function was later renamed __dvb_frontend_free. | [
"CWE-416"
] | null | null | static void __dvb_frontend_free(struct dvb_frontend *fe)
{
struct dvb_frontend_private *fepriv = fe->frontend_priv;
if (fepriv)
dvb_free_device(fepriv->dvbdev);
dvb_frontend_invoke_release(fe, fe->ops.release);
if (fepriv)
kfree(fepriv);
} | static void __dvb_frontend_free(struct dvb_frontend *fe)
{
struct dvb_frontend_private *fepriv = fe->frontend_priv;
if (fepriv)
dvb_free_device(fepriv->dvbdev);
dvb_frontend_invoke_release(fe, fe->ops.release);
kfree(fepriv);
} | media: dvb_frontend: fix ifnullfree.cocci warnings
drivers/media/dvb-core/dvb_frontend.c:154:2-7: WARNING: NULL check before freeing functions like kfree, debugfs_remove, debugfs_remove_recursive or usb_free_urb is not needed. Maybe consider reorganizing relevant code to avoid passing NULL values.
NULL check before ... |
004bdff3354bc830d6bc0cdc | openvul | train | train:5538 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/b1728ff617f88a1f7a5d8c8f21fe17a2f6af5d16 | b1728ff617f88a1f7a5d8c8f21fe17a2f6af5d16 | after | false | b1728ff617f88a1f7a5d8c8f21fe17a2f6af5d16 | containers/b1/b1728ff617f88a1f7a5d8c8f21fe17a2f6af5d16_after.sif | sha256:182ac1a464e317df95ca863d1d1b6322ff4d7c0355b8652377963023c88ee3c8 | sha256:6ba60a30e652686972506b1d6fa17fe3f398f81d0114bf8eadd6ced3d17cd5b0 | __dvb_frontend_free | static void __dvb_frontend_free(struct dvb_frontend *fe)
{
struct dvb_frontend_private *fepriv = fe->frontend_priv;
if (fepriv)
dvb_free_device(fepriv->dvbdev);
dvb_frontend_invoke_release(fe, fe->ops.release);
kfree(fepriv);
} | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | drivers/media/dvb-core/dvb_frontend.c | [
"CVE-2017-16648"
] | The dvb_frontend_free function in drivers/media/dvb-core/dvb_frontend.c in the Linux kernel through 4.13.11 allows local users to cause a denial of service (use-after-free and system crash) or possibly have unspecified other impact via a crafted USB device. NOTE: the function was later renamed __dvb_frontend_free. | [
"CWE-416"
] | null | null | static void __dvb_frontend_free(struct dvb_frontend *fe)
{
struct dvb_frontend_private *fepriv = fe->frontend_priv;
if (fepriv)
dvb_free_device(fepriv->dvbdev);
dvb_frontend_invoke_release(fe, fe->ops.release);
if (fepriv)
kfree(fepriv);
} | static void __dvb_frontend_free(struct dvb_frontend *fe)
{
struct dvb_frontend_private *fepriv = fe->frontend_priv;
if (fepriv)
dvb_free_device(fepriv->dvbdev);
dvb_frontend_invoke_release(fe, fe->ops.release);
kfree(fepriv);
} | media: dvb_frontend: fix ifnullfree.cocci warnings
drivers/media/dvb-core/dvb_frontend.c:154:2-7: WARNING: NULL check before freeing functions like kfree, debugfs_remove, debugfs_remove_recursive or usb_free_urb is not needed. Maybe consider reorganizing relevant code to avoid passing NULL values.
NULL check before ... |
0056e44b121ead69570c4c6d | openvul | train | train:5866 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/3344b58b53a76199dae48faa396e9fc37bf86992 | 3344b58b53a76199dae48faa396e9fc37bf86992 | before | true | 703535e6ae1e94c89a9c1396b4c7b6b41160ef0c | containers/33/3344b58b53a76199dae48faa396e9fc37bf86992_before.sif | sha256:b5764c07e8ebe596222485b46538963b576c4e1d3490fb5e069a726338eff46e | sha256:7919cb56a249c27acd3cf3d44757eacc6eb8eb8601fb218c753bd7007de3fa23 | resp_verify | static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
{
bool is_bytchk3 = false;
u8 bytchk;
int ret, j;
u32 vnum, a_num, off;
const u32 lb_size = sdebug_sector_size;
u64 lba;
u8 *arr;
u8 *cmd = scp->cmnd;
struct sdeb_store_info *sip = devip2sip(devip, true);
rwlock_t *macc_lckp = &sip->... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | drivers/scsi/scsi_debug.c | [
"CVE-2021-47578"
] | In the Linux kernel, the following vulnerability has been resolved:
scsi: scsi_debug: Don't call kcalloc() if size arg is zero
If the size arg to kcalloc() is zero, it returns ZERO_SIZE_PTR. Because of
that, for a following NULL pointer check to work on the returned pointer,
kcalloc() must not be called with the siz... | [
"CWE-476"
] | null | null | static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
{
bool is_bytchk3 = false;
u8 bytchk;
int ret, j;
u32 vnum, a_num, off;
const u32 lb_size = sdebug_sector_size;
u64 lba;
u8 *arr;
u8 *cmd = scp->cmnd;
struct sdeb_store_info *sip = devip2sip(devip, true);
rwlock_t *macc_lckp = &sip->... | static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
{
bool is_bytchk3 = false;
u8 bytchk;
int ret, j;
u32 vnum, a_num, off;
const u32 lb_size = sdebug_sector_size;
u64 lba;
u8 *arr;
u8 *cmd = scp->cmnd;
struct sdeb_store_info *sip = devip2sip(devip, true);
rwlock_t *macc_lckp = &sip->... | scsi: scsi_debug: Don't call kcalloc() if size arg is zero
If the size arg to kcalloc() is zero, it returns ZERO_SIZE_PTR. Because of
that, for a following NULL pointer check to work on the returned pointer,
kcalloc() must not be called with the size arg equal to zero. Return early
without error before the kcalloc() ... |
0056e44b121ead69570c4c6d | openvul | train | train:5866 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/3344b58b53a76199dae48faa396e9fc37bf86992 | 3344b58b53a76199dae48faa396e9fc37bf86992 | after | false | 3344b58b53a76199dae48faa396e9fc37bf86992 | containers/33/3344b58b53a76199dae48faa396e9fc37bf86992_after.sif | sha256:cf35fb3248b881277e70cb1f0be357802ba52bcb0ab2c001e4997e16a8021958 | sha256:43ec61677cf7c64f4083038c8bb7ab37e4e5f98dbf8d4a6e7e30386b58559318 | resp_verify | static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
{
bool is_bytchk3 = false;
u8 bytchk;
int ret, j;
u32 vnum, a_num, off;
const u32 lb_size = sdebug_sector_size;
u64 lba;
u8 *arr;
u8 *cmd = scp->cmnd;
struct sdeb_store_info *sip = devip2sip(devip, true);
rwlock_t *macc_lckp = &sip->... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | drivers/scsi/scsi_debug.c | [
"CVE-2021-47578"
] | In the Linux kernel, the following vulnerability has been resolved:
scsi: scsi_debug: Don't call kcalloc() if size arg is zero
If the size arg to kcalloc() is zero, it returns ZERO_SIZE_PTR. Because of
that, for a following NULL pointer check to work on the returned pointer,
kcalloc() must not be called with the siz... | [
"CWE-476"
] | null | null | static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
{
bool is_bytchk3 = false;
u8 bytchk;
int ret, j;
u32 vnum, a_num, off;
const u32 lb_size = sdebug_sector_size;
u64 lba;
u8 *arr;
u8 *cmd = scp->cmnd;
struct sdeb_store_info *sip = devip2sip(devip, true);
rwlock_t *macc_lckp = &sip->... | static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
{
bool is_bytchk3 = false;
u8 bytchk;
int ret, j;
u32 vnum, a_num, off;
const u32 lb_size = sdebug_sector_size;
u64 lba;
u8 *arr;
u8 *cmd = scp->cmnd;
struct sdeb_store_info *sip = devip2sip(devip, true);
rwlock_t *macc_lckp = &sip->... | scsi: scsi_debug: Don't call kcalloc() if size arg is zero
If the size arg to kcalloc() is zero, it returns ZERO_SIZE_PTR. Because of
that, for a following NULL pointer check to work on the returned pointer,
kcalloc() must not be called with the size arg equal to zero. Return early
without error before the kcalloc() ... |
0057bb81e7e90c231c2355e7 | openvul | train | train:7058 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6094628bfd94323fc1cea05ec2c6affd98c18f7f | 6094628bfd94323fc1cea05ec2c6affd98c18f7f | before | true | 9ac3524a948cab48137a8b40a4fa8ae1092b0a24 | containers/60/6094628bfd94323fc1cea05ec2c6affd98c18f7f_before.sif | sha256:00226570dda3eb09b0da6cffbbce569aac024c790b23011b11fff20caf62a6ae | sha256:be362b72da4d238d09f9824b17645a00095d765f6415ebc8edd141aece5feb13 | rds_ib_xmit | int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
unsigned int hdr_off, unsigned int sg, unsigned int off)
{
struct rds_ib_connection *ic = conn->c_transport_data;
struct ib_device *dev = ic->i_cm_id->device;
struct rds_ib_send_work *send = NULL;
struct rds_ib_send_work *first;
struct rds_ib_s... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/rds/ib_send.c | [
"CVE-2011-1023"
] | The Reliable Datagram Sockets (RDS) subsystem in the Linux kernel before 2.6.38 does not properly handle congestion map updates, which allows local users to cause a denial of service (BUG_ON and system crash) via vectors involving (1) a loopback (aka loop) transmit operation or (2) an InfiniBand (aka ib) transmit opera... | [
"CWE-131"
] | null | null | int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
unsigned int hdr_off, unsigned int sg, unsigned int off)
{
struct rds_ib_connection *ic = conn->c_transport_data;
struct ib_device *dev = ic->i_cm_id->device;
struct rds_ib_send_work *send = NULL;
struct rds_ib_send_work *first;
struct rds_ib_s... | int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
unsigned int hdr_off, unsigned int sg, unsigned int off)
{
struct rds_ib_connection *ic = conn->c_transport_data;
struct ib_device *dev = ic->i_cm_id->device;
struct rds_ib_send_work *send = NULL;
struct rds_ib_send_work *first;
struct rds_ib_s... | rds: prevent BUG_ON triggering on congestion map updates
Recently had this bug halt reported to me:
kernel BUG at net/rds/send.c:329!
Oops: Exception in kernel mode, sig: 5 [#1]
SMP NR_CPUS=1024 NUMA pSeries
Modules linked in: rds sunrpc ipv6 dm_mirror dm_region_hash dm_log ibmveth sg
ext4 jbd2 mbcache sd_mod crc_t10... |
0057bb81e7e90c231c2355e7 | openvul | train | train:7058 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6094628bfd94323fc1cea05ec2c6affd98c18f7f | 6094628bfd94323fc1cea05ec2c6affd98c18f7f | after | false | 6094628bfd94323fc1cea05ec2c6affd98c18f7f | containers/60/6094628bfd94323fc1cea05ec2c6affd98c18f7f_after.sif | sha256:c28ed58671be799e81474637698da169a34b8de8e800d3805da111926d61ad15 | sha256:1e8cde667165a4c4c1d375daa8aadb0ebc5030df8b0d52f9a87d593392492593 | rds_ib_xmit | int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
unsigned int hdr_off, unsigned int sg, unsigned int off)
{
struct rds_ib_connection *ic = conn->c_transport_data;
struct ib_device *dev = ic->i_cm_id->device;
struct rds_ib_send_work *send = NULL;
struct rds_ib_send_work *first;
struct rds_ib_s... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/rds/ib_send.c | [
"CVE-2011-1023"
] | The Reliable Datagram Sockets (RDS) subsystem in the Linux kernel before 2.6.38 does not properly handle congestion map updates, which allows local users to cause a denial of service (BUG_ON and system crash) via vectors involving (1) a loopback (aka loop) transmit operation or (2) an InfiniBand (aka ib) transmit opera... | [
"CWE-131"
] | null | null | int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
unsigned int hdr_off, unsigned int sg, unsigned int off)
{
struct rds_ib_connection *ic = conn->c_transport_data;
struct ib_device *dev = ic->i_cm_id->device;
struct rds_ib_send_work *send = NULL;
struct rds_ib_send_work *first;
struct rds_ib_s... | int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,
unsigned int hdr_off, unsigned int sg, unsigned int off)
{
struct rds_ib_connection *ic = conn->c_transport_data;
struct ib_device *dev = ic->i_cm_id->device;
struct rds_ib_send_work *send = NULL;
struct rds_ib_send_work *first;
struct rds_ib_s... | rds: prevent BUG_ON triggering on congestion map updates
Recently had this bug halt reported to me:
kernel BUG at net/rds/send.c:329!
Oops: Exception in kernel mode, sig: 5 [#1]
SMP NR_CPUS=1024 NUMA pSeries
Modules linked in: rds sunrpc ipv6 dm_mirror dm_region_hash dm_log ibmveth sg
ext4 jbd2 mbcache sd_mod crc_t10... |
0060cff852620bc16499ed44 | openvul | train | train:18492 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/17368442aec0f48859a3561ae5e441175c7041ba | 17368442aec0f48859a3561ae5e441175c7041ba | before | true | 380a36d36437de210645fb589e0108d123705727 | containers/17/17368442aec0f48859a3561ae5e441175c7041ba_before.sif | sha256:3c5c68a3542ad781bfb4480a16a315efbb90f21b1ac2aa022d6df3305086f35c | sha256:11baeb80ed37a1cd23d0553cc9487635ff3b008a7b60c9adebc372913f17396e | DownloadManagerImpl::CreateNewDownloadItemToStart | void DownloadManagerImpl::CreateNewDownloadItemToStart(
std::unique_ptr<download::DownloadCreateInfo> info,
const download::DownloadUrlParameters::OnStartedCallback& on_started,
download::InProgressDownloadManager::StartDownloadItemCallback callback,
uint32_t id) {
DCHECK_CURRENTLY_ON(BrowserThread::U... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | content/browser/download/download_manager_impl.cc | [
"CVE-2019-5829"
] | Integer overflow in download manager in Google Chrome prior to 75.0.3770.80 allowed a remote attacker to potentially perform out of bounds memory access via a crafted HTML page. | [
"CWE-416"
] | null | null | void DownloadManagerImpl::CreateNewDownloadItemToStart(
std::unique_ptr<download::DownloadCreateInfo> info,
const download::DownloadUrlParameters::OnStartedCallback& on_started,
download::InProgressDownloadManager::StartDownloadItemCallback callback,
uint32_t id) {
DCHECK_CURRENTLY_ON(BrowserThread::U... | void DownloadManagerImpl::CreateNewDownloadItemToStart(
std::unique_ptr<download::DownloadCreateInfo> info,
const download::DownloadUrlParameters::OnStartedCallback& on_started,
download::InProgressDownloadManager::StartDownloadItemCallback callback,
uint32_t id) {
DCHECK_CURRENTLY_ON(BrowserThread::U... | Early return if a download Id is already used when creating a download
This is protect against download Id overflow and use-after-free
issue.
BUG=958533
Change-Id: I2c183493cb09106686df9822b3987bfb95bcf720
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1591485
Reviewed-by: Xing Liu <xingliu@c... |
0060cff852620bc16499ed44 | openvul | train | train:18492 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/17368442aec0f48859a3561ae5e441175c7041ba | 17368442aec0f48859a3561ae5e441175c7041ba | after | false | 17368442aec0f48859a3561ae5e441175c7041ba | containers/17/17368442aec0f48859a3561ae5e441175c7041ba_after.sif | sha256:2d5d415a06f6151b8e17d526d6b0895701f545f69bea5263d0636c80c0222fae | sha256:87a41eb16f76aef23aa22e7c9abc4f664d94af0c0d1f6091e11a35f9d1a882d8 | DownloadManagerImpl::CreateNewDownloadItemToStart | void DownloadManagerImpl::CreateNewDownloadItemToStart(
std::unique_ptr<download::DownloadCreateInfo> info,
const download::DownloadUrlParameters::OnStartedCallback& on_started,
download::InProgressDownloadManager::StartDownloadItemCallback callback,
uint32_t id) {
DCHECK_CURRENTLY_ON(BrowserThread::U... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | content/browser/download/download_manager_impl.cc | [
"CVE-2019-5829"
] | Integer overflow in download manager in Google Chrome prior to 75.0.3770.80 allowed a remote attacker to potentially perform out of bounds memory access via a crafted HTML page. | [
"CWE-416"
] | null | null | void DownloadManagerImpl::CreateNewDownloadItemToStart(
std::unique_ptr<download::DownloadCreateInfo> info,
const download::DownloadUrlParameters::OnStartedCallback& on_started,
download::InProgressDownloadManager::StartDownloadItemCallback callback,
uint32_t id) {
DCHECK_CURRENTLY_ON(BrowserThread::U... | void DownloadManagerImpl::CreateNewDownloadItemToStart(
std::unique_ptr<download::DownloadCreateInfo> info,
const download::DownloadUrlParameters::OnStartedCallback& on_started,
download::InProgressDownloadManager::StartDownloadItemCallback callback,
uint32_t id) {
DCHECK_CURRENTLY_ON(BrowserThread::U... | Early return if a download Id is already used when creating a download
This is protect against download Id overflow and use-after-free
issue.
BUG=958533
Change-Id: I2c183493cb09106686df9822b3987bfb95bcf720
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1591485
Reviewed-by: Xing Liu <xingliu@c... |
00669ad69c99bc5d0311d4f2 | openvul | train | train:2330 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | curl | https://github.com/curl/curl | https://github.com/curl/curl | https://github.com/curl/curl/commit/75dc096e01ef1e21b6c57690d99371dedb2c0b80 | 75dc096e01ef1e21b6c57690d99371dedb2c0b80 | before | true | 9cb1059f92286a6eb5d28c477fdd3f26aed1d554 | containers/75/75dc096e01ef1e21b6c57690d99371dedb2c0b80_before.sif | sha256:45950f9464d3d43ffc0422cc02a40b5f3f70214d82c8e7bc4e3e412b44dee8d5 | sha256:6354008b63fc12dedf46d0310d81dd52fa0d406f95d8f97966324d66ab67db23 | close_all_connections | static void close_all_connections(struct Curl_multi *multi)
{
struct connectdata *conn;
conn = Curl_conncache_find_first_connection(&multi->conn_cache);
while(conn) {
SIGPIPE_VARIABLE(pipe_st);
conn->data = multi->closure_handle;
sigpipe_ignore(conn->data, &pipe_st);
(void)Curl_disconnect(conn, FA... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | lib/multi.c | [
"CVE-2016-5421"
] | Use-after-free vulnerability in libcurl before 7.50.1 allows attackers to control which connection is used or possibly have unspecified other impact via unknown vectors. | [
"CWE-416"
] | null | null | static void close_all_connections(struct Curl_multi *multi)
{
struct connectdata *conn;
conn = Curl_conncache_find_first_connection(&multi->conn_cache);
while(conn) {
SIGPIPE_VARIABLE(pipe_st);
conn->data = multi->closure_handle;
sigpipe_ignore(conn->data, &pipe_st);
(void)Curl_disconnect(conn, FA... | static void close_all_connections(struct Curl_multi *multi)
{
struct connectdata *conn;
conn = Curl_conncache_find_first_connection(&multi->conn_cache);
while(conn) {
SIGPIPE_VARIABLE(pipe_st);
conn->data = multi->closure_handle;
sigpipe_ignore(conn->data, &pipe_st);
conn->data->easy_conn = NULL; ... | curl_multi_cleanup: clear connection pointer for easy handles
CVE-2016-5421
Bug: https://curl.haxx.se/docs/adv_20160803C.html
Reported-by: Marcelo Echeverria and Fernando Muñoz |
00669ad69c99bc5d0311d4f2 | openvul | train | train:2330 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | curl | https://github.com/curl/curl | https://github.com/curl/curl | https://github.com/curl/curl/commit/75dc096e01ef1e21b6c57690d99371dedb2c0b80 | 75dc096e01ef1e21b6c57690d99371dedb2c0b80 | after | false | 75dc096e01ef1e21b6c57690d99371dedb2c0b80 | containers/75/75dc096e01ef1e21b6c57690d99371dedb2c0b80_after.sif | sha256:12925359a75a38ae812d9574aab885e7fb71113d1272fe754f065edd19c7b7c9 | sha256:aa7b181f1e4f684887f652af840c9006f95bae4bd9b3fc02aebfe21dcb5ff66c | close_all_connections | static void close_all_connections(struct Curl_multi *multi)
{
struct connectdata *conn;
conn = Curl_conncache_find_first_connection(&multi->conn_cache);
while(conn) {
SIGPIPE_VARIABLE(pipe_st);
conn->data = multi->closure_handle;
sigpipe_ignore(conn->data, &pipe_st);
conn->data->easy_conn = NULL; ... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | lib/multi.c | [
"CVE-2016-5421"
] | Use-after-free vulnerability in libcurl before 7.50.1 allows attackers to control which connection is used or possibly have unspecified other impact via unknown vectors. | [
"CWE-416"
] | null | null | static void close_all_connections(struct Curl_multi *multi)
{
struct connectdata *conn;
conn = Curl_conncache_find_first_connection(&multi->conn_cache);
while(conn) {
SIGPIPE_VARIABLE(pipe_st);
conn->data = multi->closure_handle;
sigpipe_ignore(conn->data, &pipe_st);
(void)Curl_disconnect(conn, FA... | static void close_all_connections(struct Curl_multi *multi)
{
struct connectdata *conn;
conn = Curl_conncache_find_first_connection(&multi->conn_cache);
while(conn) {
SIGPIPE_VARIABLE(pipe_st);
conn->data = multi->closure_handle;
sigpipe_ignore(conn->data, &pipe_st);
conn->data->easy_conn = NULL; ... | curl_multi_cleanup: clear connection pointer for easy handles
CVE-2016-5421
Bug: https://curl.haxx.se/docs/adv_20160803C.html
Reported-by: Marcelo Echeverria and Fernando Muñoz |
0067f0d152098d8ad3c5fdc2 | openvul | train | train:18434 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/6ed26f014f76f10e76e80636027a2db9dcbe1664 | 6ed26f014f76f10e76e80636027a2db9dcbe1664 | before | true | e2028a77332ce7c5a64174dfce23a1782b7c8212 | containers/6e/6ed26f014f76f10e76e80636027a2db9dcbe1664_before.sif | sha256:d0588937cefe071393a4601b1406b6707d8008e42dd6d8f230729ac6d08ac97b | sha256:f090cd8f33b47bfcefa1d25a0b94df092c29c7bc39f20b7097eabce486e89a73 | clip_antialiasing_ | BaseRenderingContext2D::BaseRenderingContext2D()
: clip_antialiasing_(kNotAntiAliased) {
state_stack_.push_back(CanvasRenderingContext2DState::Create());
} | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | third_party/WebKit/Source/modules/canvas/canvas2d/BaseRenderingContext2D.cpp | [
"CVE-2018-6077"
] | Displacement map filters being applied to cross-origin images in Blink SVG rendering in Google Chrome prior to 65.0.3325.146 allowed a remote attacker to leak cross-origin data via a crafted HTML page. | [
"CWE-200"
] | null | null | BaseRenderingContext2D::BaseRenderingContext2D()
: clip_antialiasing_(kNotAntiAliased) {
state_stack_.push_back(CanvasRenderingContext2DState::Create());
} | BaseRenderingContext2D::BaseRenderingContext2D()
: clip_antialiasing_(kNotAntiAliased), origin_tainted_by_content_(false) {
state_stack_.push_back(CanvasRenderingContext2DState::Create());
} | [PE] Distinguish between tainting due to canvas content and filter.
A filter on a canvas can itself lead to origin tainting, for reasons
other than that the canvas contents are tainted. This CL changes
to distinguish these two causes, so that we recompute filters
on content-tainting change.
Bug: 778506
Change-Id: I3c... |
0067f0d152098d8ad3c5fdc2 | openvul | train | train:18434 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/6ed26f014f76f10e76e80636027a2db9dcbe1664 | 6ed26f014f76f10e76e80636027a2db9dcbe1664 | after | false | 6ed26f014f76f10e76e80636027a2db9dcbe1664 | containers/6e/6ed26f014f76f10e76e80636027a2db9dcbe1664_after.sif | sha256:62f543ecf4fb4c6d42e7ee3299159e70e2feb268a6a17ca1c82435604e05aeae | sha256:9ef5e85ac6d0f86cb209b50c2fe221ba385f6d8df7b0791bb7e435ee165f6424 | clip_antialiasing_ | BaseRenderingContext2D::BaseRenderingContext2D()
: clip_antialiasing_(kNotAntiAliased), origin_tainted_by_content_(false) {
state_stack_.push_back(CanvasRenderingContext2DState::Create());
} | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | third_party/WebKit/Source/modules/canvas/canvas2d/BaseRenderingContext2D.cpp | [
"CVE-2018-6077"
] | Displacement map filters being applied to cross-origin images in Blink SVG rendering in Google Chrome prior to 65.0.3325.146 allowed a remote attacker to leak cross-origin data via a crafted HTML page. | [
"CWE-200"
] | null | null | BaseRenderingContext2D::BaseRenderingContext2D()
: clip_antialiasing_(kNotAntiAliased) {
state_stack_.push_back(CanvasRenderingContext2DState::Create());
} | BaseRenderingContext2D::BaseRenderingContext2D()
: clip_antialiasing_(kNotAntiAliased), origin_tainted_by_content_(false) {
state_stack_.push_back(CanvasRenderingContext2DState::Create());
} | [PE] Distinguish between tainting due to canvas content and filter.
A filter on a canvas can itself lead to origin tainting, for reasons
other than that the canvas contents are tainted. This CL changes
to distinguish these two causes, so that we recompute filters
on content-tainting change.
Bug: 778506
Change-Id: I3c... |
0070a9fbdb4ce58fe6922f09 | openvul | train | train:488 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8f44c9a41386729fea410e688959ddaa9d51be7c | 8f44c9a41386729fea410e688959ddaa9d51be7c | before | true | 76b825ab870be3281edac4ae8a414da6e54b0d3a | containers/8f/8f44c9a41386729fea410e688959ddaa9d51be7c_before.sif | sha256:5fdac4f7554ff471a4e21016e148aba77117bb367492872ecc821d0d447d4cb4 | sha256:e12d38e6a93cc0f8c313a33e9b59df493c50ebf058ccee03f4406274dec7547d | brcmf_cfg80211_mgmt_tx | brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
struct cfg80211_mgmt_tx_params *params, u64 *cookie)
{
struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
struct ieee80211_channel *chan = params->chan;
const u8 *buf = params->buf;
size_t len = params->len;
const struct ieee80211_... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c | [
"CVE-2017-7541"
] | The brcmf_cfg80211_mgmt_tx function in drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c in the Linux kernel before 4.12.3 allows local users to cause a denial of service (buffer overflow and system crash) or possibly gain privileges via a crafted NL80211_CMD_FRAME Netlink packet. | [
"CWE-119"
] | null | null | brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
struct cfg80211_mgmt_tx_params *params, u64 *cookie)
{
struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
struct ieee80211_channel *chan = params->chan;
const u8 *buf = params->buf;
size_t len = params->len;
const struct ieee80211_... | brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
struct cfg80211_mgmt_tx_params *params, u64 *cookie)
{
struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
struct ieee80211_channel *chan = params->chan;
const u8 *buf = params->buf;
size_t len = params->len;
const struct ieee80211_... | brcmfmac: fix possible buffer overflow in brcmf_cfg80211_mgmt_tx()
The lower level nl80211 code in cfg80211 ensures that "len" is between
25 and NL80211_ATTR_FRAME (2304). We subtract DOT11_MGMT_HDR_LEN (24) from
"len" so thats's max of 2280. However, the action_frame->data[] buffer is
only BRCMF_FIL_ACTION_FRAME_SI... |
0070a9fbdb4ce58fe6922f09 | openvul | train | train:488 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/8f44c9a41386729fea410e688959ddaa9d51be7c | 8f44c9a41386729fea410e688959ddaa9d51be7c | after | false | 8f44c9a41386729fea410e688959ddaa9d51be7c | containers/8f/8f44c9a41386729fea410e688959ddaa9d51be7c_after.sif | sha256:747ed057e4cfa3f70630801f04552c77cf735f94b064ba0cca18b6ada15d8dbf | sha256:a4b7e29530fc2a995ddcf93ff32bcad9b5db5632706fd4333dc26424b527136a | brcmf_cfg80211_mgmt_tx | brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
struct cfg80211_mgmt_tx_params *params, u64 *cookie)
{
struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
struct ieee80211_channel *chan = params->chan;
const u8 *buf = params->buf;
size_t len = params->len;
const struct ieee80211_... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c | [
"CVE-2017-7541"
] | The brcmf_cfg80211_mgmt_tx function in drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c in the Linux kernel before 4.12.3 allows local users to cause a denial of service (buffer overflow and system crash) or possibly gain privileges via a crafted NL80211_CMD_FRAME Netlink packet. | [
"CWE-119"
] | null | null | brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
struct cfg80211_mgmt_tx_params *params, u64 *cookie)
{
struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
struct ieee80211_channel *chan = params->chan;
const u8 *buf = params->buf;
size_t len = params->len;
const struct ieee80211_... | brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
struct cfg80211_mgmt_tx_params *params, u64 *cookie)
{
struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
struct ieee80211_channel *chan = params->chan;
const u8 *buf = params->buf;
size_t len = params->len;
const struct ieee80211_... | brcmfmac: fix possible buffer overflow in brcmf_cfg80211_mgmt_tx()
The lower level nl80211 code in cfg80211 ensures that "len" is between
25 and NL80211_ATTR_FRAME (2304). We subtract DOT11_MGMT_HDR_LEN (24) from
"len" so thats's max of 2280. However, the action_frame->data[] buffer is
only BRCMF_FIL_ACTION_FRAME_SI... |
00726fe00905c411ceb363d4 | openvul | train | train:16354 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | u-boot | https://github.com/u-boot/u-boot | https://github.com/u-boot/u-boot | https://github.com/u-boot/u-boot/commit/2c871f9e084b2c03d1961884228a6901387ab8d6 | 2c871f9e084b2c03d1961884228a6901387ab8d6 | before | true | 052170c6a043eec4e73fad80955876cf1ba5e4f2 | containers/2c/2c871f9e084b2c03d1961884228a6901387ab8d6_before.sif | sha256:b096010ac8601656c8edcafe782126696f52ceb0ef011835e67f94c937e23442 | sha256:4d7ba9e7c24767f1d61d0720ae801e1dc9e501c56d43a777fb81ff7e6257ffe9 | trigger_fpga_config | int trigger_fpga_config(void)
{
int ret = 0, init_l;
u32 timeout = 10000;
toggle_fpga_eeprom_bus(false);
qrio_gpio_direction_output(GPIO_A, CONF_SEL_L, 0);
qrio_gpio_direction_output(GPIO_A, FPGA_PROG_L, 0);
udelay(10);
do {
init_l = qrio_get_gpio(GPIO_A, FPGA_INIT_L);
if (timeout-- == 0) {
printf("F... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | board/keymile/kmp204x/pci.c | [
"CVE-2019-13106"
] | Das U-Boot versions 2016.09 through 2019.07-rc4 can memset() too much data while reading a crafted ext4 filesystem, which results in a stack buffer overflow and likely code execution. | [
"CWE-787"
] | null | null | int trigger_fpga_config(void)
{
int ret = 0, init_l;
u32 timeout = 10000;
toggle_fpga_eeprom_bus(false);
qrio_gpio_direction_output(GPIO_A, CONF_SEL_L, 0);
qrio_gpio_direction_output(GPIO_A, FPGA_PROG_L, 0);
udelay(10);
do {
init_l = qrio_get_gpio(GPIO_A, FPGA_INIT_L);
if (timeout-- == 0) {
printf("F... | int trigger_fpga_config(void)
{
int ret = 0, init_l;
u32 timeout = 10000;
toggle_fpga_eeprom_bus(false);
qrio_gpio_direction_output(QRIO_GPIO_A, CONF_SEL_L, 0);
qrio_gpio_direction_output(QRIO_GPIO_A, FPGA_PROG_L, 0);
udelay(10);
do {
init_l = qrio_get_gpio(QRIO_GPIO_A, FPGA_INIT_L);
if (timeout-- == 0) ... | Merge branch '2020-01-22-master-imports'
- Re-add U8500 platform support
- Add bcm968360bg support
- Assorted Keymile fixes
- Other assorted bugfixes |
00726fe00905c411ceb363d4 | openvul | train | train:16354 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | u-boot | https://github.com/u-boot/u-boot | https://github.com/u-boot/u-boot | https://github.com/u-boot/u-boot/commit/2c871f9e084b2c03d1961884228a6901387ab8d6 | 2c871f9e084b2c03d1961884228a6901387ab8d6 | after | false | 2c871f9e084b2c03d1961884228a6901387ab8d6 | containers/2c/2c871f9e084b2c03d1961884228a6901387ab8d6_after.sif | sha256:964383312cc86005d35d6a9ca1b0fc145a7b9b584e568baf8669280f7de35c25 | sha256:0e65af8b0c9aaba92847632a73ae62ad2307786b234afaed99cce53fdc495b4c | trigger_fpga_config | int trigger_fpga_config(void)
{
int ret = 0, init_l;
u32 timeout = 10000;
toggle_fpga_eeprom_bus(false);
qrio_gpio_direction_output(QRIO_GPIO_A, CONF_SEL_L, 0);
qrio_gpio_direction_output(QRIO_GPIO_A, FPGA_PROG_L, 0);
udelay(10);
do {
init_l = qrio_get_gpio(QRIO_GPIO_A, FPGA_INIT_L);
if (timeout-- == 0) ... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | board/keymile/kmp204x/pci.c | [
"CVE-2019-13106"
] | Das U-Boot versions 2016.09 through 2019.07-rc4 can memset() too much data while reading a crafted ext4 filesystem, which results in a stack buffer overflow and likely code execution. | [
"CWE-787"
] | null | null | int trigger_fpga_config(void)
{
int ret = 0, init_l;
u32 timeout = 10000;
toggle_fpga_eeprom_bus(false);
qrio_gpio_direction_output(GPIO_A, CONF_SEL_L, 0);
qrio_gpio_direction_output(GPIO_A, FPGA_PROG_L, 0);
udelay(10);
do {
init_l = qrio_get_gpio(GPIO_A, FPGA_INIT_L);
if (timeout-- == 0) {
printf("F... | int trigger_fpga_config(void)
{
int ret = 0, init_l;
u32 timeout = 10000;
toggle_fpga_eeprom_bus(false);
qrio_gpio_direction_output(QRIO_GPIO_A, CONF_SEL_L, 0);
qrio_gpio_direction_output(QRIO_GPIO_A, FPGA_PROG_L, 0);
udelay(10);
do {
init_l = qrio_get_gpio(QRIO_GPIO_A, FPGA_INIT_L);
if (timeout-- == 0) ... | Merge branch '2020-01-22-master-imports'
- Re-add U8500 platform support
- Add bcm968360bg support
- Assorted Keymile fixes
- Other assorted bugfixes |
0079839c1f3e8ed7406dc4bb | openvul | train | train:17960 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/1c40f9042ae2d6ee7483d72998aabb5e73b2ff60 | 1c40f9042ae2d6ee7483d72998aabb5e73b2ff60 | before | true | 1fab25bdd1a38c7f760dee27b06348257e0d0971 | containers/1c/1c40f9042ae2d6ee7483d72998aabb5e73b2ff60_before.sif | sha256:1bdecb7dadd7578a23135770ece0162a42fdb5318f85474a27167a0a123520ce | sha256:f44b896f0c1f3f5ffab452fd164bc89fc22ae138ec58ff8da810589a552ce62d | WorkerFetchContext::DispatchDidBlockRequest | void WorkerFetchContext::DispatchDidBlockRequest(
const ResourceRequest& resource_request,
const FetchInitiatorInfo& fetch_initiator_info,
ResourceRequestBlockedReason blocked_reason) const {
probe::didBlockRequest(global_scope_, resource_request, nullptr,
fetch_initiator_info... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | third_party/WebKit/Source/core/loader/WorkerFetchContext.cpp | [
"CVE-2017-5009"
] | WebRTC in Google Chrome prior to 56.0.2924.76 for Linux, Windows and Mac, and 56.0.2924.87 for Android, failed to perform proper bounds checking, which allowed a remote attacker to potentially exploit heap corruption via a crafted HTML page. | [
"CWE-119"
] | null | null | void WorkerFetchContext::DispatchDidBlockRequest(
const ResourceRequest& resource_request,
const FetchInitiatorInfo& fetch_initiator_info,
ResourceRequestBlockedReason blocked_reason) const {
probe::didBlockRequest(global_scope_, resource_request, nullptr,
fetch_initiator_info... | void WorkerFetchContext::DispatchDidBlockRequest(
const ResourceRequest& resource_request,
const FetchInitiatorInfo& fetch_initiator_info,
ResourceRequestBlockedReason blocked_reason,
Resource::Type resource_type) const {
probe::didBlockRequest(global_scope_, resource_request, nullptr,
... | DevTools: send proper resource type in Network.RequestWillBeSent
This patch plumbs resoure type into the DispatchWillSendRequest
instrumenation. This allows us to report accurate type in
Network.RequestWillBeSent event, instead of "Other", that we report
today.
BUG=765501
R=dgozman
Change-Id: I0134c08b841e8dd247fdc8... |
0079839c1f3e8ed7406dc4bb | openvul | train | train:17960 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/1c40f9042ae2d6ee7483d72998aabb5e73b2ff60 | 1c40f9042ae2d6ee7483d72998aabb5e73b2ff60 | after | false | 1c40f9042ae2d6ee7483d72998aabb5e73b2ff60 | containers/1c/1c40f9042ae2d6ee7483d72998aabb5e73b2ff60_after.sif | sha256:82ad3ea44c70affd9a891efa21e9a894eceb58799e8cd9127a688d56aa1a672e | sha256:ebd5e2ef9e0fbf69cab581247390af7b33b6cb9d277a7c093428df9c63d45a75 | WorkerFetchContext::DispatchDidBlockRequest | void WorkerFetchContext::DispatchDidBlockRequest(
const ResourceRequest& resource_request,
const FetchInitiatorInfo& fetch_initiator_info,
ResourceRequestBlockedReason blocked_reason,
Resource::Type resource_type) const {
probe::didBlockRequest(global_scope_, resource_request, nullptr,
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | third_party/WebKit/Source/core/loader/WorkerFetchContext.cpp | [
"CVE-2017-5009"
] | WebRTC in Google Chrome prior to 56.0.2924.76 for Linux, Windows and Mac, and 56.0.2924.87 for Android, failed to perform proper bounds checking, which allowed a remote attacker to potentially exploit heap corruption via a crafted HTML page. | [
"CWE-119"
] | null | null | void WorkerFetchContext::DispatchDidBlockRequest(
const ResourceRequest& resource_request,
const FetchInitiatorInfo& fetch_initiator_info,
ResourceRequestBlockedReason blocked_reason) const {
probe::didBlockRequest(global_scope_, resource_request, nullptr,
fetch_initiator_info... | void WorkerFetchContext::DispatchDidBlockRequest(
const ResourceRequest& resource_request,
const FetchInitiatorInfo& fetch_initiator_info,
ResourceRequestBlockedReason blocked_reason,
Resource::Type resource_type) const {
probe::didBlockRequest(global_scope_, resource_request, nullptr,
... | DevTools: send proper resource type in Network.RequestWillBeSent
This patch plumbs resoure type into the DispatchWillSendRequest
instrumenation. This allows us to report accurate type in
Network.RequestWillBeSent event, instead of "Other", that we report
today.
BUG=765501
R=dgozman
Change-Id: I0134c08b841e8dd247fdc8... |
00798b22e9054ffa69d1f121 | openvul | train | train:8196 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6acb47d1a318e5b3b7115354ebc4ea060c59d3a1 | 6acb47d1a318e5b3b7115354ebc4ea060c59d3a1 | before | true | 81fa7a69c2174ed8de314b9c231ef30a8718e5e1 | containers/6a/6acb47d1a318e5b3b7115354ebc4ea060c59d3a1_before.sif | sha256:03697b4f10992158640f4b8526100d06f0b146b08b8adeb233269fb01661c12a | sha256:fac6b33c4a6054fb00813ad1e57b80f4ddbaf2c70ca9a787f557d8a39a051c7c | serdes_probe | static int serdes_probe(struct platform_device *pdev)
{
struct phy_provider *provider;
struct serdes_ctrl *ctrl;
unsigned int i;
int ret;
ctrl = devm_kzalloc(&pdev->dev, sizeof(*ctrl), GFP_KERNEL);
if (!ctrl)
return -ENOMEM;
ctrl->dev = &pdev->dev;
ctrl->regs = syscon_node_to_regmap(pdev->dev.parent->of_node)... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | drivers/phy/mscc/phy-ocelot-serdes.c | [
"CVE-2018-20854"
] | An issue was discovered in the Linux kernel before 4.20. drivers/phy/mscc/phy-ocelot-serdes.c has an off-by-one error with a resultant ctrl->phys out-of-bounds read. | [
"CWE-125"
] | null | null | static int serdes_probe(struct platform_device *pdev)
{
struct phy_provider *provider;
struct serdes_ctrl *ctrl;
unsigned int i;
int ret;
ctrl = devm_kzalloc(&pdev->dev, sizeof(*ctrl), GFP_KERNEL);
if (!ctrl)
return -ENOMEM;
ctrl->dev = &pdev->dev;
ctrl->regs = syscon_node_to_regmap(pdev->dev.parent->of_node)... | static int serdes_probe(struct platform_device *pdev)
{
struct phy_provider *provider;
struct serdes_ctrl *ctrl;
unsigned int i;
int ret;
ctrl = devm_kzalloc(&pdev->dev, sizeof(*ctrl), GFP_KERNEL);
if (!ctrl)
return -ENOMEM;
ctrl->dev = &pdev->dev;
ctrl->regs = syscon_node_to_regmap(pdev->dev.parent->of_node)... | phy: ocelot-serdes: fix out-of-bounds read
Currently, there is an out-of-bounds read on array ctrl->phys,
once variable i reaches the maximum array size of SERDES_MAX
in the for loop.
Fix this by changing the condition in the for loop from
i <= SERDES_MAX to i < SERDES_MAX.
Addresses-Coverity-ID: 1473966 ("Out-of-bo... |
00798b22e9054ffa69d1f121 | openvul | train | train:8196 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/6acb47d1a318e5b3b7115354ebc4ea060c59d3a1 | 6acb47d1a318e5b3b7115354ebc4ea060c59d3a1 | after | false | 6acb47d1a318e5b3b7115354ebc4ea060c59d3a1 | containers/6a/6acb47d1a318e5b3b7115354ebc4ea060c59d3a1_after.sif | sha256:ab6358523fa691c9f2428658b86eb92f0cd5ea6a83268a4f13ba5ec5adeab759 | sha256:75db48859b2d30b951d1e2c672cb3adfcafe753abdd5ecfdcd2864f518d017ba | serdes_probe | static int serdes_probe(struct platform_device *pdev)
{
struct phy_provider *provider;
struct serdes_ctrl *ctrl;
unsigned int i;
int ret;
ctrl = devm_kzalloc(&pdev->dev, sizeof(*ctrl), GFP_KERNEL);
if (!ctrl)
return -ENOMEM;
ctrl->dev = &pdev->dev;
ctrl->regs = syscon_node_to_regmap(pdev->dev.parent->of_node)... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | drivers/phy/mscc/phy-ocelot-serdes.c | [
"CVE-2018-20854"
] | An issue was discovered in the Linux kernel before 4.20. drivers/phy/mscc/phy-ocelot-serdes.c has an off-by-one error with a resultant ctrl->phys out-of-bounds read. | [
"CWE-125"
] | null | null | static int serdes_probe(struct platform_device *pdev)
{
struct phy_provider *provider;
struct serdes_ctrl *ctrl;
unsigned int i;
int ret;
ctrl = devm_kzalloc(&pdev->dev, sizeof(*ctrl), GFP_KERNEL);
if (!ctrl)
return -ENOMEM;
ctrl->dev = &pdev->dev;
ctrl->regs = syscon_node_to_regmap(pdev->dev.parent->of_node)... | static int serdes_probe(struct platform_device *pdev)
{
struct phy_provider *provider;
struct serdes_ctrl *ctrl;
unsigned int i;
int ret;
ctrl = devm_kzalloc(&pdev->dev, sizeof(*ctrl), GFP_KERNEL);
if (!ctrl)
return -ENOMEM;
ctrl->dev = &pdev->dev;
ctrl->regs = syscon_node_to_regmap(pdev->dev.parent->of_node)... | phy: ocelot-serdes: fix out-of-bounds read
Currently, there is an out-of-bounds read on array ctrl->phys,
once variable i reaches the maximum array size of SERDES_MAX
in the for loop.
Fix this by changing the condition in the for loop from
i <= SERDES_MAX to i < SERDES_MAX.
Addresses-Coverity-ID: 1473966 ("Out-of-bo... |
00856af3f41e18e52390e3f3 | openvul | train | train:1722 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | php-src | https://github.com/php/php-src | https://github.com/php/php-src | http://git.php.net/?p=php-src.git;a=commitdiff;h=f59b67ae50064560d7bfcdb0d6a8ab284179053c | f59b67ae50064560d7bfcdb0d6a8ab284179053c | before | true | 45facd15fb1be704ee1ae374fa306dad8450edbd | containers/f5/f59b67ae50064560d7bfcdb0d6a8ab284179053c_before.sif | sha256:b9e11815d11aadfea22eb4a07eb2013f33f75ace185c9ec5c3ff6e99c48e6510 | sha256:3068aa62bbf96bd977f90b20822f460e1bdf10ec795f7140eeda8737faa5f49f | phar_set_inode | static inline void phar_set_inode(phar_entry_info *entry TSRMLS_DC)
{
char tmp[MAXPATHLEN];
int tmp_len;
tmp_len = entry->filename_len + entry->phar->fname_len;
memcpy(tmp, entry->phar->fname, entry->phar->fname_len);
memcpy(tmp + entry->phar->fname_len, entry->filename, entry->filename_len);
entry->inode = (un... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | ext/phar/phar_internal.h | [
"CVE-2015-3329"
] | Multiple stack-based buffer overflows in the phar_set_inode function in phar_internal.h in PHP before 5.4.40, 5.5.x before 5.5.24, and 5.6.x before 5.6.8 allow remote attackers to execute arbitrary code via a crafted length value in a (1) tar, (2) phar, or (3) ZIP archive. | [
"CWE-119"
] | null | null | static inline void phar_set_inode(phar_entry_info *entry TSRMLS_DC)
{
char tmp[MAXPATHLEN];
int tmp_len;
tmp_len = entry->filename_len + entry->phar->fname_len;
memcpy(tmp, entry->phar->fname, entry->phar->fname_len);
memcpy(tmp + entry->phar->fname_len, entry->filename, entry->filename_len);
entry->inode = (un... | static inline void phar_set_inode(phar_entry_info *entry TSRMLS_DC)
{
char tmp[MAXPATHLEN];
int tmp_len;
size_t len;
tmp_len = MIN(MAXPATHLEN, entry->filename_len + entry->phar->fname_len);
len = MIN(entry->phar->fname_len, tmp_len);
memcpy(tmp, entry->phar->fname, len);
len = MIN(tmp_len - len, entry->filenam... | Fix bug #69441 (Buffer Overflow when parsing tar/zip/phar in phar_set_inode) |
00856af3f41e18e52390e3f3 | openvul | train | train:1722 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | php-src | https://github.com/php/php-src | https://github.com/php/php-src | http://git.php.net/?p=php-src.git;a=commitdiff;h=f59b67ae50064560d7bfcdb0d6a8ab284179053c | f59b67ae50064560d7bfcdb0d6a8ab284179053c | after | false | f59b67ae50064560d7bfcdb0d6a8ab284179053c | containers/f5/f59b67ae50064560d7bfcdb0d6a8ab284179053c_after.sif | sha256:d244fffbe418e574d38a1fb2b63b0eb5971841da7e820238d5cba8fb61652653 | sha256:7d3c9a7ec6f52f7c917107d3d48f8745e9c2d1f5b79402b3faf67392983cc237 | phar_set_inode | static inline void phar_set_inode(phar_entry_info *entry TSRMLS_DC)
{
char tmp[MAXPATHLEN];
int tmp_len;
size_t len;
tmp_len = MIN(MAXPATHLEN, entry->filename_len + entry->phar->fname_len);
len = MIN(entry->phar->fname_len, tmp_len);
memcpy(tmp, entry->phar->fname, len);
len = MIN(tmp_len - len, entry->filenam... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | ext/phar/phar_internal.h | [
"CVE-2015-3329"
] | Multiple stack-based buffer overflows in the phar_set_inode function in phar_internal.h in PHP before 5.4.40, 5.5.x before 5.5.24, and 5.6.x before 5.6.8 allow remote attackers to execute arbitrary code via a crafted length value in a (1) tar, (2) phar, or (3) ZIP archive. | [
"CWE-119"
] | null | null | static inline void phar_set_inode(phar_entry_info *entry TSRMLS_DC)
{
char tmp[MAXPATHLEN];
int tmp_len;
tmp_len = entry->filename_len + entry->phar->fname_len;
memcpy(tmp, entry->phar->fname, entry->phar->fname_len);
memcpy(tmp + entry->phar->fname_len, entry->filename, entry->filename_len);
entry->inode = (un... | static inline void phar_set_inode(phar_entry_info *entry TSRMLS_DC)
{
char tmp[MAXPATHLEN];
int tmp_len;
size_t len;
tmp_len = MIN(MAXPATHLEN, entry->filename_len + entry->phar->fname_len);
len = MIN(entry->phar->fname_len, tmp_len);
memcpy(tmp, entry->phar->fname, len);
len = MIN(tmp_len - len, entry->filenam... | Fix bug #69441 (Buffer Overflow when parsing tar/zip/phar in phar_set_inode) |
00935629df1c79cf0ec96284 | openvul | train | train:1718 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | libevent | https://github.com/libevent/libevent | https://github.com/libevent/libevent | https://github.com/libevent/libevent/commit/7b21c4eabf1f3946d3f63cce1319c490caab8ecf | 7b21c4eabf1f3946d3f63cce1319c490caab8ecf | before | true | 53c47c2eb9f63f012d5fd7e7709d97d295b15f78 | containers/7b/7b21c4eabf1f3946d3f63cce1319c490caab8ecf_before.sif | sha256:1be2cd1f0cf2be9d4a869c3b565d89247e58aca0a019ed138e07d362746a97e7 | sha256:436672ab60d11b2c8fb9df67c49a05a0bd53750724ebf16c6dbdaa2208b20e77 | evbuffer_expand | evbuffer_expand(struct evbuffer *buf, size_t datlen)
{
size_t need = buf->misalign + buf->off + datlen;
if (buf->totallen >= need)
return (0);
if (buf->misalign >= datlen) {
evbuffer_align(buf);
} else {
void *newbuf;
size_t length = buf->totallen;
if (length < 256)
length = 256;
while (length < need... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | buffer.c | [
"CVE-2014-6272"
] | Multiple integer overflows in the evbuffer API in Libevent 1.4.x before 1.4.15, 2.0.x before 2.0.22, and 2.1.x before 2.1.5-beta allow context-dependent attackers to cause a denial of service or possibly have other unspecified impact via "insanely large inputs" to the (1) evbuffer_add, (2) evbuffer_expand, or (3) buffe... | [
"CWE-680"
] | null | null | evbuffer_expand(struct evbuffer *buf, size_t datlen)
{
size_t need = buf->misalign + buf->off + datlen;
if (buf->totallen >= need)
return (0);
if (buf->misalign >= datlen) {
evbuffer_align(buf);
} else {
void *newbuf;
size_t length = buf->totallen;
if (length < 256)
length = 256;
while (length < need... | evbuffer_expand(struct evbuffer *buf, size_t datlen)
{
size_t used = buf->misalign + buf->off;
size_t need;
assert(buf->totallen >= used);
if (buf->totallen - used >= datlen)
return (0);
if (datlen > SIZE_MAX - buf->off)
return (-1);
if (buf->totallen - buf->off >= datlen) {
evbuffer_align(buf);
} else {
... | Fix CVE-2014-6272 in Libevent 1.4
For this fix, we need to make sure that passing too-large inputs to
the evbuffer functions can't make us do bad things with the heap. |
00935629df1c79cf0ec96284 | openvul | train | train:1718 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | libevent | https://github.com/libevent/libevent | https://github.com/libevent/libevent | https://github.com/libevent/libevent/commit/7b21c4eabf1f3946d3f63cce1319c490caab8ecf | 7b21c4eabf1f3946d3f63cce1319c490caab8ecf | after | false | 7b21c4eabf1f3946d3f63cce1319c490caab8ecf | containers/7b/7b21c4eabf1f3946d3f63cce1319c490caab8ecf_after.sif | sha256:417ca71ada2ac8da29479e78763d6c347fc647a903fe1aa0417ca0eeb7ac9fb7 | sha256:84c8fa91a3d8e91a209951ad3ca6a04d2a092d7fd8fa69c4ea33002d7b2cc3f5 | evbuffer_expand | evbuffer_expand(struct evbuffer *buf, size_t datlen)
{
size_t used = buf->misalign + buf->off;
size_t need;
assert(buf->totallen >= used);
if (buf->totallen - used >= datlen)
return (0);
if (datlen > SIZE_MAX - buf->off)
return (-1);
if (buf->totallen - buf->off >= datlen) {
evbuffer_align(buf);
} else {
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | buffer.c | [
"CVE-2014-6272"
] | Multiple integer overflows in the evbuffer API in Libevent 1.4.x before 1.4.15, 2.0.x before 2.0.22, and 2.1.x before 2.1.5-beta allow context-dependent attackers to cause a denial of service or possibly have other unspecified impact via "insanely large inputs" to the (1) evbuffer_add, (2) evbuffer_expand, or (3) buffe... | [
"CWE-680"
] | null | null | evbuffer_expand(struct evbuffer *buf, size_t datlen)
{
size_t need = buf->misalign + buf->off + datlen;
if (buf->totallen >= need)
return (0);
if (buf->misalign >= datlen) {
evbuffer_align(buf);
} else {
void *newbuf;
size_t length = buf->totallen;
if (length < 256)
length = 256;
while (length < need... | evbuffer_expand(struct evbuffer *buf, size_t datlen)
{
size_t used = buf->misalign + buf->off;
size_t need;
assert(buf->totallen >= used);
if (buf->totallen - used >= datlen)
return (0);
if (datlen > SIZE_MAX - buf->off)
return (-1);
if (buf->totallen - buf->off >= datlen) {
evbuffer_align(buf);
} else {
... | Fix CVE-2014-6272 in Libevent 1.4
For this fix, we need to make sure that passing too-large inputs to
the evbuffer functions can't make us do bad things with the heap. |
009fa0356a0e4f281c54b477 | openvul | train | train:16938 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/b8573aa643b03a59f4e2c99c72d3511a11cfb0b6 | b8573aa643b03a59f4e2c99c72d3511a11cfb0b6 | before | true | 6113e611df95cb143b61cdbb4eefa07d231d1dd2 | containers/b8/b8573aa643b03a59f4e2c99c72d3511a11cfb0b6_before.sif | sha256:acecc9b22791894924030382d0a3bec16270b7c6f0857f3245f918576c26af54 | sha256:004b2d59d9b1685b8c37f3220998dae6d4f896a73cbdda37d14d9325c7ef2e35 | GestureSequence::PinchUpdate | bool GestureSequence::PinchUpdate(const TouchEvent& event,
const GesturePoint& point, Gestures* gestures) {
DCHECK(state_ == GS_PINCH);
float distance = points_[0].Distance(points_[1]);
if (abs(distance - pinch_distance_current_) < kMinimumPinchUpdateDistance) {
if (!points_[0].DidScroll(event, kMinimu... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | ui/aura/gestures/gesture_sequence.cc | [
"CVE-2011-3094"
] | Google Chrome before 19.0.1084.46 does not properly handle Tibetan text, which allows remote attackers to cause a denial of service (out-of-bounds read) via unspecified vectors. | [
"CWE-20"
] | null | null | bool GestureSequence::PinchUpdate(const TouchEvent& event,
const GesturePoint& point, Gestures* gestures) {
DCHECK(state_ == GS_PINCH);
float distance = points_[0].Distance(points_[1]);
if (abs(distance - pinch_distance_current_) < kMinimumPinchUpdateDistance) {
if (!points_[0].DidScroll(event, kMinimu... | bool GestureSequence::PinchUpdate(const TouchEvent& event,
const GesturePoint& point, Gestures* gestures) {
DCHECK(state_ == GS_PINCH);
float distance = points_[0].Distance(points_[1]);
if (abs(distance - pinch_distance_current_) <
GestureConfiguration::minimum_pinch_update_distance_in_pixels()) {
... | Add setters for the aura gesture recognizer constants.
BUG=113227
TEST=none
Review URL: http://codereview.chromium.org/9372040
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@122586 0039d316-1c4b-4281-b951-d872f2087c98 |
009fa0356a0e4f281c54b477 | openvul | train | train:16938 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/b8573aa643b03a59f4e2c99c72d3511a11cfb0b6 | b8573aa643b03a59f4e2c99c72d3511a11cfb0b6 | after | false | b8573aa643b03a59f4e2c99c72d3511a11cfb0b6 | containers/b8/b8573aa643b03a59f4e2c99c72d3511a11cfb0b6_after.sif | sha256:5bc8b65497592fd266d8e4eb53dc46ba92218f681d13b774909755b856ddccf8 | sha256:6437d40243a4f8f06e10f6036d88655d465fdcbbf05835f6ee48cd39f464d63a | GestureSequence::PinchUpdate | bool GestureSequence::PinchUpdate(const TouchEvent& event,
const GesturePoint& point, Gestures* gestures) {
DCHECK(state_ == GS_PINCH);
float distance = points_[0].Distance(points_[1]);
if (abs(distance - pinch_distance_current_) <
GestureConfiguration::minimum_pinch_update_distance_in_pixels()) {
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | ui/aura/gestures/gesture_sequence.cc | [
"CVE-2011-3094"
] | Google Chrome before 19.0.1084.46 does not properly handle Tibetan text, which allows remote attackers to cause a denial of service (out-of-bounds read) via unspecified vectors. | [
"CWE-20"
] | null | null | bool GestureSequence::PinchUpdate(const TouchEvent& event,
const GesturePoint& point, Gestures* gestures) {
DCHECK(state_ == GS_PINCH);
float distance = points_[0].Distance(points_[1]);
if (abs(distance - pinch_distance_current_) < kMinimumPinchUpdateDistance) {
if (!points_[0].DidScroll(event, kMinimu... | bool GestureSequence::PinchUpdate(const TouchEvent& event,
const GesturePoint& point, Gestures* gestures) {
DCHECK(state_ == GS_PINCH);
float distance = points_[0].Distance(points_[1]);
if (abs(distance - pinch_distance_current_) <
GestureConfiguration::minimum_pinch_update_distance_in_pixels()) {
... | Add setters for the aura gesture recognizer constants.
BUG=113227
TEST=none
Review URL: http://codereview.chromium.org/9372040
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@122586 0039d316-1c4b-4281-b951-d872f2087c98 |
00aa37f0a00ad65916844069 | openvul | train | train:19170 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | Android | https://android.googlesource.com/platform/external/libvpx/+/cc274e2abe8b2a6698a5c47d8aa4bb45f1f9538d | https://android.googlesource.com/platform/external/libvpx | https://android.googlesource.com/platform/external/libvpx/+/cc274e2abe8b2a6698a5c47d8aa4bb45f1f9538d%5E%21/#F0 | cc274e2abe8b2a6698a5c47d8aa4bb45f1f9538d | before | true | 4ec72fb10684276b048d5b3a6ba7a88d43b06411 | containers/cc/cc274e2abe8b2a6698a5c47d8aa4bb45f1f9538d_before.sif | sha256:6e83c9fce558806ad5891e8d59ade2d5cc7cb927cea50941c8929ccc02a02df3 | sha256:9a1e3d2b9cf48aa5658290c1e783804474553394b92d161f616d626be1e22f51 | Segment::DoParseNext | long Segment::DoParseNext(const Cluster*& pResult, long long& pos, long& len) {
long long total, avail;
long status = m_pReader->Length(&total, &avail);
if (status < 0)
return status;
assert((total < 0) || (avail <= total));
const long long segment_stop = (m_size < 0) ? -1 : m_start + m_size;
long long off_ne... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | libwebm/mkvparser.cpp | [
"CVE-2016-2464"
] | libvpx in libwebm in mediaserver in Android 4.x before 4.4.4, 5.0.x before 5.0.2, 5.1.x before 5.1.1, and 6.x before 2016-06-01 allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted mkv file, aka internal bug 23167726. | [
"CWE-20"
] | null | null | long Segment::DoParseNext(const Cluster*& pResult, long long& pos, long& len) {
long long total, avail;
long status = m_pReader->Length(&total, &avail);
if (status < 0)
return status;
assert((total < 0) || (avail <= total));
const long long segment_stop = (m_size < 0) ? -1 : m_start + m_size;
long long off_ne... | long Segment::DoParseNext(const Cluster*& pResult, long long& pos, long& len) {
long long total, avail;
long status = m_pReader->Length(&total, &avail);
if (status < 0)
return status;
assert((total < 0) || (avail <= total));
const long long segment_stop = (m_size < 0) ? -1 : m_start + m_size;
long long off_ne... | external/libvpx/libwebm: Update snapshot
Update libwebm snapshot. This update contains security fixes from upstream.
Upstream git hash: 229f49347d19b0ca0941e072b199a242ef6c5f2b
BUG=23167726
Change-Id: Id3e140e7b31ae11294724b1ecfe2e9c83b4d4207
(cherry picked from commit d0281a15b3c6bd91756e453cc9398c5ef412d99a) |
00aa37f0a00ad65916844069 | openvul | train | train:19170 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | Android | https://android.googlesource.com/platform/external/libvpx/+/cc274e2abe8b2a6698a5c47d8aa4bb45f1f9538d | https://android.googlesource.com/platform/external/libvpx | https://android.googlesource.com/platform/external/libvpx/+/cc274e2abe8b2a6698a5c47d8aa4bb45f1f9538d%5E%21/#F0 | cc274e2abe8b2a6698a5c47d8aa4bb45f1f9538d | after | false | cc274e2abe8b2a6698a5c47d8aa4bb45f1f9538d | containers/cc/cc274e2abe8b2a6698a5c47d8aa4bb45f1f9538d_after.sif | sha256:b8e13b069de68b942519e26ed9c6aedc0f4ff5dd5e347ba67dc690b410eca6d8 | sha256:df2733205f7071dd83e1dc2413b271fa325638be9b00f065736cfd24d6e29f21 | Segment::DoParseNext | long Segment::DoParseNext(const Cluster*& pResult, long long& pos, long& len) {
long long total, avail;
long status = m_pReader->Length(&total, &avail);
if (status < 0)
return status;
assert((total < 0) || (avail <= total));
const long long segment_stop = (m_size < 0) ? -1 : m_start + m_size;
long long off_ne... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | libwebm/mkvparser.cpp | [
"CVE-2016-2464"
] | libvpx in libwebm in mediaserver in Android 4.x before 4.4.4, 5.0.x before 5.0.2, 5.1.x before 5.1.1, and 6.x before 2016-06-01 allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted mkv file, aka internal bug 23167726. | [
"CWE-20"
] | null | null | long Segment::DoParseNext(const Cluster*& pResult, long long& pos, long& len) {
long long total, avail;
long status = m_pReader->Length(&total, &avail);
if (status < 0)
return status;
assert((total < 0) || (avail <= total));
const long long segment_stop = (m_size < 0) ? -1 : m_start + m_size;
long long off_ne... | long Segment::DoParseNext(const Cluster*& pResult, long long& pos, long& len) {
long long total, avail;
long status = m_pReader->Length(&total, &avail);
if (status < 0)
return status;
assert((total < 0) || (avail <= total));
const long long segment_stop = (m_size < 0) ? -1 : m_start + m_size;
long long off_ne... | external/libvpx/libwebm: Update snapshot
Update libwebm snapshot. This update contains security fixes from upstream.
Upstream git hash: 229f49347d19b0ca0941e072b199a242ef6c5f2b
BUG=23167726
Change-Id: Id3e140e7b31ae11294724b1ecfe2e9c83b4d4207
(cherry picked from commit d0281a15b3c6bd91756e453cc9398c5ef412d99a) |
00aea708b6ae2dcc116bbaf1 | openvul | train | train:3222 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow/commit/02cc160e29d20631de3859c6653184e3f876b9d7 | 02cc160e29d20631de3859c6653184e3f876b9d7 | before | true | 234a51acec19b5728a07915e89eb8f01f4c80b06 | containers/02/02cc160e29d20631de3859c6653184e3f876b9d7_before.sif | sha256:6454317bf937271d1ac477f7db6803fb1b6da87b925a511d937896c3e8efec35 | sha256:bddba07454a9d297ede2f614b6d568a22032a18d29828350d8d937e94a61755d | MakeDataset | void MakeDataset(OpKernelContext* ctx, DatasetBase** output) override {
const Tensor* indices;
OP_REQUIRES_OK(ctx, ctx->input("indices", &indices));
const Tensor* values;
OP_REQUIRES_OK(ctx, ctx->input("values", &values));
const Tensor* dense_shape;
OP_REQUIRES_OK(ctx, ctx->input("dense_shape"... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | tensorflow/core/kernels/data/sparse_tensor_slice_dataset_op.cc | [
"CVE-2021-37647"
] | TensorFlow is an end-to-end open source platform for machine learning. When a user does not supply arguments that determine a valid sparse tensor, `tf.raw_ops.SparseTensorSliceDataset` implementation can be made to dereference a null pointer. The [implementation](https://github.com/tensorflow/tensorflow/blob/8d72537c6a... | [
"CWE-476"
] | null | null | void MakeDataset(OpKernelContext* ctx, DatasetBase** output) override {
const Tensor* indices;
OP_REQUIRES_OK(ctx, ctx->input("indices", &indices));
const Tensor* values;
OP_REQUIRES_OK(ctx, ctx->input("values", &values));
const Tensor* dense_shape;
OP_REQUIRES_OK(ctx, ctx->input("dense_shape"... | void MakeDataset(OpKernelContext* ctx, DatasetBase** output) override {
const Tensor* indices;
OP_REQUIRES_OK(ctx, ctx->input("indices", &indices));
const Tensor* values;
OP_REQUIRES_OK(ctx, ctx->input("values", &values));
const Tensor* dense_shape;
OP_REQUIRES_OK(ctx, ctx->input("dense_shape"... | Prevent nullptr deref in SparseTensorSliceDataset
The arguments must determine a valid sparse tensor. This means that when indices are empty then the values must be empty too (and the reverse).
Also added test, by modifying existing test with empty sparse tensor to now run with an invalid sparse tensor input.
PiperO... |
00aea708b6ae2dcc116bbaf1 | openvul | train | train:3222 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow/commit/02cc160e29d20631de3859c6653184e3f876b9d7 | 02cc160e29d20631de3859c6653184e3f876b9d7 | after | false | 02cc160e29d20631de3859c6653184e3f876b9d7 | containers/02/02cc160e29d20631de3859c6653184e3f876b9d7_after.sif | sha256:37fb9d08246b9ffbf2bfefbe1c8fd925a30054a2dc39bedd7f05dda87741939b | sha256:6c767eb130cd086ddebdabc0f4e1b6ac7f03fe172b3ac86a06b1c5d5d412bc68 | MakeDataset | void MakeDataset(OpKernelContext* ctx, DatasetBase** output) override {
const Tensor* indices;
OP_REQUIRES_OK(ctx, ctx->input("indices", &indices));
const Tensor* values;
OP_REQUIRES_OK(ctx, ctx->input("values", &values));
const Tensor* dense_shape;
OP_REQUIRES_OK(ctx, ctx->input("dense_shape"... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | tensorflow/core/kernels/data/sparse_tensor_slice_dataset_op.cc | [
"CVE-2021-37647"
] | TensorFlow is an end-to-end open source platform for machine learning. When a user does not supply arguments that determine a valid sparse tensor, `tf.raw_ops.SparseTensorSliceDataset` implementation can be made to dereference a null pointer. The [implementation](https://github.com/tensorflow/tensorflow/blob/8d72537c6a... | [
"CWE-476"
] | null | null | void MakeDataset(OpKernelContext* ctx, DatasetBase** output) override {
const Tensor* indices;
OP_REQUIRES_OK(ctx, ctx->input("indices", &indices));
const Tensor* values;
OP_REQUIRES_OK(ctx, ctx->input("values", &values));
const Tensor* dense_shape;
OP_REQUIRES_OK(ctx, ctx->input("dense_shape"... | void MakeDataset(OpKernelContext* ctx, DatasetBase** output) override {
const Tensor* indices;
OP_REQUIRES_OK(ctx, ctx->input("indices", &indices));
const Tensor* values;
OP_REQUIRES_OK(ctx, ctx->input("values", &values));
const Tensor* dense_shape;
OP_REQUIRES_OK(ctx, ctx->input("dense_shape"... | Prevent nullptr deref in SparseTensorSliceDataset
The arguments must determine a valid sparse tensor. This means that when indices are empty then the values must be empty too (and the reverse).
Also added test, by modifying existing test with empty sparse tensor to now run with an invalid sparse tensor input.
PiperO... |
00bd2968d8a5d624fed22b83 | openvul | train | train:13844 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | nDPI | https://github.com/ntop/nDPI | https://github.com/ntop/nDPI | https://github.com/ntop/nDPI/commit/b7e666e465f138ae48ab81976726e67deed12701 | b7e666e465f138ae48ab81976726e67deed12701 | before | true | 3d9285f1be84db7ecec821b75f67964dc4773a65 | containers/b7/b7e666e465f138ae48ab81976726e67deed12701_before.sif | sha256:4a4af8b1f7628a661182cf63582fb777caa31952262ab35b61b0659c2bf2e716 | sha256:fcca1aaf1bbf7d0e8a98940005bf6b0d5df6af759615922133a73587fe34b36a | ndpi_search_h323 | void ndpi_search_h323(struct ndpi_detection_module_struct *ndpi_struct, struct ndpi_flow_struct *flow)
{
struct ndpi_packet_struct *packet = &flow->packet;
u_int16_t dport = 0, sport = 0;
NDPI_LOG_DBG(ndpi_struct, "search H323\n");
if((packet->tcp != NULL) && (packet->tcp->dest != ntohs(102))) {
NDPI_LOG_DB... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | src/lib/protocols/h323.c | [
"CVE-2020-15472"
] | In nDPI through 3.2, the H.323 dissector is vulnerable to a heap-based buffer over-read in ndpi_search_h323 in lib/protocols/h323.c, as demonstrated by a payload packet length that is too short. | [
"CWE-125"
] | null | null | void ndpi_search_h323(struct ndpi_detection_module_struct *ndpi_struct, struct ndpi_flow_struct *flow)
{
struct ndpi_packet_struct *packet = &flow->packet;
u_int16_t dport = 0, sport = 0;
NDPI_LOG_DBG(ndpi_struct, "search H323\n");
if((packet->tcp != NULL) && (packet->tcp->dest != ntohs(102))) {
NDPI_LOG_DB... | void ndpi_search_h323(struct ndpi_detection_module_struct *ndpi_struct, struct ndpi_flow_struct *flow)
{
struct ndpi_packet_struct *packet = &flow->packet;
u_int16_t dport = 0, sport = 0;
NDPI_LOG_DBG(ndpi_struct, "search H323\n");
if((packet->tcp != NULL) && (packet->tcp->dest != ntohs(102))) {
NDPI_LOG_DB... | Added fix to avoid potential heap buffer overflow in H.323 dissector
Modified HTTP report information to make it closer to the HTTP field names |
00bd2968d8a5d624fed22b83 | openvul | train | train:13844 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | nDPI | https://github.com/ntop/nDPI | https://github.com/ntop/nDPI | https://github.com/ntop/nDPI/commit/b7e666e465f138ae48ab81976726e67deed12701 | b7e666e465f138ae48ab81976726e67deed12701 | after | false | b7e666e465f138ae48ab81976726e67deed12701 | containers/b7/b7e666e465f138ae48ab81976726e67deed12701_after.sif | sha256:11652ca2f10fd5e77a7480eec9da45be09fc6f38e5bf7f9fd18b8134a1dcddc6 | sha256:2152975cb4e9e9c8d6d2ee4587cd653ec85a34c284f65702e75ca13687d0f4fe | ndpi_search_h323 | void ndpi_search_h323(struct ndpi_detection_module_struct *ndpi_struct, struct ndpi_flow_struct *flow)
{
struct ndpi_packet_struct *packet = &flow->packet;
u_int16_t dport = 0, sport = 0;
NDPI_LOG_DBG(ndpi_struct, "search H323\n");
if((packet->tcp != NULL) && (packet->tcp->dest != ntohs(102))) {
NDPI_LOG_DB... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | src/lib/protocols/h323.c | [
"CVE-2020-15472"
] | In nDPI through 3.2, the H.323 dissector is vulnerable to a heap-based buffer over-read in ndpi_search_h323 in lib/protocols/h323.c, as demonstrated by a payload packet length that is too short. | [
"CWE-125"
] | null | null | void ndpi_search_h323(struct ndpi_detection_module_struct *ndpi_struct, struct ndpi_flow_struct *flow)
{
struct ndpi_packet_struct *packet = &flow->packet;
u_int16_t dport = 0, sport = 0;
NDPI_LOG_DBG(ndpi_struct, "search H323\n");
if((packet->tcp != NULL) && (packet->tcp->dest != ntohs(102))) {
NDPI_LOG_DB... | void ndpi_search_h323(struct ndpi_detection_module_struct *ndpi_struct, struct ndpi_flow_struct *flow)
{
struct ndpi_packet_struct *packet = &flow->packet;
u_int16_t dport = 0, sport = 0;
NDPI_LOG_DBG(ndpi_struct, "search H323\n");
if((packet->tcp != NULL) && (packet->tcp->dest != ntohs(102))) {
NDPI_LOG_DB... | Added fix to avoid potential heap buffer overflow in H.323 dissector
Modified HTTP report information to make it closer to the HTTP field names |
00c522dc29adf76a64c241e9 | openvul | train | train:14724 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | GameNetworkingSockets | https://github.com/ValveSoftware/GameNetworkingSockets | https://github.com/ValveSoftware/GameNetworkingSockets | https://github.com/ValveSoftware/GameNetworkingSockets/commit/d944a10808891d202bb1d5e1998de6e0423af678 | d944a10808891d202bb1d5e1998de6e0423af678 | before | true | e0c86dcb9139771db3db0cfdb1fb8bef0af19c43 | containers/d9/d944a10808891d202bb1d5e1998de6e0423af678_before.sif | sha256:77030bd55ffc67d3d3823f5b87f2a5e263cd230e7c1d6ae274e59858f17036e9 | sha256:ca60622a5d2fa5ab160917e774af29bc4d46fa373827dc9f8b0cb02a86f0a011 | CConnectionTransportUDPBase::Received_Data | void CConnectionTransportUDPBase::Received_Data( const uint8 *pPkt, int cbPkt, SteamNetworkingMicroseconds usecNow )
{
if ( cbPkt < sizeof(UDPDataMsgHdr) )
{
ReportBadUDPPacketFromConnectionPeer( "DataPacket", "Packet of size %d is too small.", cbPkt );
return;
}
const UDPDataMsgHdr *hdr = (const UDPDataMsgHdr ... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | src/steamnetworkingsockets/clientlib/steamnetworkingsockets_udp.cpp | [
"CVE-2020-6019"
] | Valve's Game Networking Sockets prior to version v1.2.0 improperly handles inlined statistics messages in function CConnectionTransportUDPBase::Received_Data(), leading to an exception thrown from libprotobuf and resulting in a crash. | [
"CWE-680, CWE-190"
] | null | null | void CConnectionTransportUDPBase::Received_Data( const uint8 *pPkt, int cbPkt, SteamNetworkingMicroseconds usecNow )
{
if ( cbPkt < sizeof(UDPDataMsgHdr) )
{
ReportBadUDPPacketFromConnectionPeer( "DataPacket", "Packet of size %d is too small.", cbPkt );
return;
}
const UDPDataMsgHdr *hdr = (const UDPDataMsgHdr ... | void CConnectionTransportUDPBase::Received_Data( const uint8 *pPkt, int cbPkt, SteamNetworkingMicroseconds usecNow )
{
if ( cbPkt < sizeof(UDPDataMsgHdr) )
{
ReportBadUDPPacketFromConnectionPeer( "DataPacket", "Packet of size %d is too small.", cbPkt );
return;
}
const UDPDataMsgHdr *hdr = (const UDPDataMsgHdr ... | Tweak pointer math to avoid possible integer overflow |
00c522dc29adf76a64c241e9 | openvul | train | train:14724 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | GameNetworkingSockets | https://github.com/ValveSoftware/GameNetworkingSockets | https://github.com/ValveSoftware/GameNetworkingSockets | https://github.com/ValveSoftware/GameNetworkingSockets/commit/d944a10808891d202bb1d5e1998de6e0423af678 | d944a10808891d202bb1d5e1998de6e0423af678 | after | false | d944a10808891d202bb1d5e1998de6e0423af678 | containers/d9/d944a10808891d202bb1d5e1998de6e0423af678_after.sif | sha256:175306c01246859514f0b82ad5d50321c0139061efbd691527bfebb9e568dff0 | sha256:be0632afd159cef29520e40f860d96dee831e5501c9c85d4c0b29aba6cc84e77 | CConnectionTransportUDPBase::Received_Data | void CConnectionTransportUDPBase::Received_Data( const uint8 *pPkt, int cbPkt, SteamNetworkingMicroseconds usecNow )
{
if ( cbPkt < sizeof(UDPDataMsgHdr) )
{
ReportBadUDPPacketFromConnectionPeer( "DataPacket", "Packet of size %d is too small.", cbPkt );
return;
}
const UDPDataMsgHdr *hdr = (const UDPDataMsgHdr ... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | src/steamnetworkingsockets/clientlib/steamnetworkingsockets_udp.cpp | [
"CVE-2020-6019"
] | Valve's Game Networking Sockets prior to version v1.2.0 improperly handles inlined statistics messages in function CConnectionTransportUDPBase::Received_Data(), leading to an exception thrown from libprotobuf and resulting in a crash. | [
"CWE-680, CWE-190"
] | null | null | void CConnectionTransportUDPBase::Received_Data( const uint8 *pPkt, int cbPkt, SteamNetworkingMicroseconds usecNow )
{
if ( cbPkt < sizeof(UDPDataMsgHdr) )
{
ReportBadUDPPacketFromConnectionPeer( "DataPacket", "Packet of size %d is too small.", cbPkt );
return;
}
const UDPDataMsgHdr *hdr = (const UDPDataMsgHdr ... | void CConnectionTransportUDPBase::Received_Data( const uint8 *pPkt, int cbPkt, SteamNetworkingMicroseconds usecNow )
{
if ( cbPkt < sizeof(UDPDataMsgHdr) )
{
ReportBadUDPPacketFromConnectionPeer( "DataPacket", "Packet of size %d is too small.", cbPkt );
return;
}
const UDPDataMsgHdr *hdr = (const UDPDataMsgHdr ... | Tweak pointer math to avoid possible integer overflow |
00cd8a6d87296ef7d93f053a | openvul | train | train:16390 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | tcpdump | https://github.com/the-tcpdump-group/tcpdump | https://github.com/the-tcpdump-group/tcpdump | https://github.com/the-tcpdump-group/tcpdump/commit/c24922e692a52121e853a84ead6b9337f4c08a94 | c24922e692a52121e853a84ead6b9337f4c08a94 | before | true | e5ae1fd2c5d86277e76ec901ed5f311df731caff | containers/c2/c24922e692a52121e853a84ead6b9337f4c08a94_before.sif | sha256:8f8aaca315675ed8e986c82e792ae78f858951c03f89d886860b06d974064e21 | sha256:12726ef478c2e78fb6d863b420b5c2ba0e3222d92ae2a5a0ba71e22c618cd519 | rx_cache_insert | rx_cache_insert(netdissect_options *ndo,
const u_char *bp, const struct ip *ip, int dport)
{
struct rx_cache_entry *rxent;
const struct rx_header *rxh = (const struct rx_header *) bp;
if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t)))
return;
rxent = &rx_cache[rx_c... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | print-rx.c | [
"CVE-2018-14466"
] | The Rx parser in tcpdump before 4.9.3 has a buffer over-read in print-rx.c:rx_cache_find() and rx_cache_insert(). | [
"CWE-125"
] | null | null | rx_cache_insert(netdissect_options *ndo,
const u_char *bp, const struct ip *ip, int dport)
{
struct rx_cache_entry *rxent;
const struct rx_header *rxh = (const struct rx_header *) bp;
if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t)))
return;
rxent = &rx_cache[rx_c... | rx_cache_insert(netdissect_options *ndo,
const u_char *bp, const struct ip *ip, int dport)
{
struct rx_cache_entry *rxent;
const struct rx_header *rxh = (const struct rx_header *) bp;
if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t)))
return;
rxent = &rx_cache[rx_c... | (for 4.9.3) CVE-2018-14466/Rx: fix an over-read bug
In rx_cache_insert() and rx_cache_find() properly read the serviceId
field of the rx_header structure as a 16-bit integer. When those
functions tried to read 32 bits the extra 16 bits could be outside of
the bounds checked in rx_print() for the rx_header structure, a... |
00cd8a6d87296ef7d93f053a | openvul | train | train:16390 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | tcpdump | https://github.com/the-tcpdump-group/tcpdump | https://github.com/the-tcpdump-group/tcpdump | https://github.com/the-tcpdump-group/tcpdump/commit/c24922e692a52121e853a84ead6b9337f4c08a94 | c24922e692a52121e853a84ead6b9337f4c08a94 | after | false | c24922e692a52121e853a84ead6b9337f4c08a94 | containers/c2/c24922e692a52121e853a84ead6b9337f4c08a94_after.sif | sha256:928578f6fca31eccbaa5488a3f2b6279eceb1b79246dc117f87d5c18648cf345 | sha256:36602d0cd1d86cb8b77de10cf6d70a7485b587464636e389fbac6ec4d95c139c | rx_cache_insert | rx_cache_insert(netdissect_options *ndo,
const u_char *bp, const struct ip *ip, int dport)
{
struct rx_cache_entry *rxent;
const struct rx_header *rxh = (const struct rx_header *) bp;
if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t)))
return;
rxent = &rx_cache[rx_c... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | print-rx.c | [
"CVE-2018-14466"
] | The Rx parser in tcpdump before 4.9.3 has a buffer over-read in print-rx.c:rx_cache_find() and rx_cache_insert(). | [
"CWE-125"
] | null | null | rx_cache_insert(netdissect_options *ndo,
const u_char *bp, const struct ip *ip, int dport)
{
struct rx_cache_entry *rxent;
const struct rx_header *rxh = (const struct rx_header *) bp;
if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t)))
return;
rxent = &rx_cache[rx_c... | rx_cache_insert(netdissect_options *ndo,
const u_char *bp, const struct ip *ip, int dport)
{
struct rx_cache_entry *rxent;
const struct rx_header *rxh = (const struct rx_header *) bp;
if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t)))
return;
rxent = &rx_cache[rx_c... | (for 4.9.3) CVE-2018-14466/Rx: fix an over-read bug
In rx_cache_insert() and rx_cache_find() properly read the serviceId
field of the rx_header structure as a 16-bit integer. When those
functions tried to read 32 bits the extra 16 bits could be outside of
the bounds checked in rx_print() for the rx_header structure, a... |
00d3a44c7acdf26df6d8d909 | openvul | train | train:2256 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | exiv2 | https://github.com/Exiv2/exiv2 | https://github.com/Exiv2/exiv2 | https://github.com/Exiv2/exiv2/commit/1647908e00a4df7246d76678e59587e62c690dcd | 1647908e00a4df7246d76678e59587e62c690dcd | before | true | 4be065595e4b81e876e32c9c4705f8313f896d43 | containers/16/1647908e00a4df7246d76678e59587e62c690dcd_before.sif | sha256:a581f801efabf67b2950739dfacbfd05f1c4350e3cd85ab9372778e41031dfb8 | sha256:0c11e75bf0b19b4f98a9b94aeee43fda5e876e16b42824ba4c7b9716b69580df | readHeader | Header readHeader(BasicIo& io)
{
byte header[2];
io.read(header, 2);
ByteOrder byteOrder = invalidByteOrder;
if (header[0] == 'I' && header[1] == 'I')
byteOrder = littleEndian;
else if (header[0] == 'M' && header[1] == 'M')
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | src/bigtiffimage.cpp | [
"CVE-2017-17722"
] | In Exiv2 0.26, there is a reachable assertion in the readHeader function in bigtiffimage.cpp, which will lead to a remote denial of service attack via a crafted TIFF file. | [
"CWE-617"
] | null | null | Header readHeader(BasicIo& io)
{
byte header[2];
io.read(header, 2);
ByteOrder byteOrder = invalidByteOrder;
if (header[0] == 'I' && header[1] == 'I')
byteOrder = littleEndian;
else if (header[0] == 'M' && header[1] == 'M')
... | Header readHeader(BasicIo& io)
{
byte header[2];
io.read(header, 2);
ByteOrder byteOrder = invalidByteOrder;
if (header[0] == 'I' && header[1] == 'I')
byteOrder = littleEndian;
else if (header[0] == 'M' && header[1] == 'M')
... | fix for crash in bigtiff (issue #208) |
00d3a44c7acdf26df6d8d909 | openvul | train | train:2256 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | exiv2 | https://github.com/Exiv2/exiv2 | https://github.com/Exiv2/exiv2 | https://github.com/Exiv2/exiv2/commit/1647908e00a4df7246d76678e59587e62c690dcd | 1647908e00a4df7246d76678e59587e62c690dcd | after | false | 1647908e00a4df7246d76678e59587e62c690dcd | containers/16/1647908e00a4df7246d76678e59587e62c690dcd_after.sif | sha256:56e99a5dea731909f51b44527e95da50eed7b32141fd9f59d7d862abbe6a76ab | sha256:8e3ecf1c29c8bf785d07e22869961ca4b508bf12cbbbd6d8a1a8bd06f276cd01 | readHeader | Header readHeader(BasicIo& io)
{
byte header[2];
io.read(header, 2);
ByteOrder byteOrder = invalidByteOrder;
if (header[0] == 'I' && header[1] == 'I')
byteOrder = littleEndian;
else if (header[0] == 'M' && header[1] == 'M')
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | src/bigtiffimage.cpp | [
"CVE-2017-17722"
] | In Exiv2 0.26, there is a reachable assertion in the readHeader function in bigtiffimage.cpp, which will lead to a remote denial of service attack via a crafted TIFF file. | [
"CWE-617"
] | null | null | Header readHeader(BasicIo& io)
{
byte header[2];
io.read(header, 2);
ByteOrder byteOrder = invalidByteOrder;
if (header[0] == 'I' && header[1] == 'I')
byteOrder = littleEndian;
else if (header[0] == 'M' && header[1] == 'M')
... | Header readHeader(BasicIo& io)
{
byte header[2];
io.read(header, 2);
ByteOrder byteOrder = invalidByteOrder;
if (header[0] == 'I' && header[1] == 'I')
byteOrder = littleEndian;
else if (header[0] == 'M' && header[1] == 'M')
... | fix for crash in bigtiff (issue #208) |
00da7d5c25b0bbc89179420a | openvul | train | train:1990 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | gst-plugins-base | https://github.com/GStreamer/gst-plugins-base | https://gitlab.freedesktop.org/gstreamer/gst-plugins-base | https://github.com/GStreamer/gst-plugins-base/commit/81d3ba3fa212bb25fe2ac661993887c4b69af6f1 | 81d3ba3fa212bb25fe2ac661993887c4b69af6f1 | before | true | 3bf38e4e1beee72b97fd3d08c43f513b3886a780 | containers/81/81d3ba3fa212bb25fe2ac661993887c4b69af6f1_before.sif | sha256:ff596b7d845de3dec5b5caa72f54040cab2571c02408b029ac304b633992a483 | sha256:b9be409f7d4ca7942cb16a69ae35a3902faf352539282508c44f8866e2d14da2 | gst_riff_create_audio_caps | gst_riff_create_audio_caps (guint16 codec_id,
gst_riff_strh * strh, gst_riff_strf_auds * strf,
GstBuffer * strf_data, GstBuffer * strd_data, char **codec_name,
gint channel_reorder_map[18])
{
gboolean block_align = FALSE, rate_chan = TRUE;
GstCaps *caps = NULL;
gint i;
if (channel_reorder_map)
f... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | gst-libs/gst/riff/riff-media.c | [
"CVE-2017-5837"
] | The gst_riff_create_audio_caps function in gst-libs/gst/riff/riff-media.c in gst-plugins-base in GStreamer before 1.10.3 allows remote attackers to cause a denial of service (floating point exception and crash) via a crafted video file. | [
"CWE-369"
] | null | null | gst_riff_create_audio_caps (guint16 codec_id,
gst_riff_strh * strh, gst_riff_strf_auds * strf,
GstBuffer * strf_data, GstBuffer * strd_data, char **codec_name,
gint channel_reorder_map[18])
{
gboolean block_align = FALSE, rate_chan = TRUE;
GstCaps *caps = NULL;
gint i;
if (channel_reorder_map)
f... | gst_riff_create_audio_caps (guint16 codec_id,
gst_riff_strh * strh, gst_riff_strf_auds * strf,
GstBuffer * strf_data, GstBuffer * strd_data, char **codec_name,
gint channel_reorder_map[18])
{
gboolean block_align = FALSE, rate_chan = TRUE;
GstCaps *caps = NULL;
gint i;
if (channel_reorder_map)
f... | riff-media: Check for valid channels/rate before using the values
Otherwise we might divide by zero or otherwise create invalid caps.
https://bugzilla.gnome.org/show_bug.cgi?id=777262 |
00da7d5c25b0bbc89179420a | openvul | train | train:1990 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | gst-plugins-base | https://github.com/GStreamer/gst-plugins-base | https://gitlab.freedesktop.org/gstreamer/gst-plugins-base | https://github.com/GStreamer/gst-plugins-base/commit/81d3ba3fa212bb25fe2ac661993887c4b69af6f1 | 81d3ba3fa212bb25fe2ac661993887c4b69af6f1 | after | false | 81d3ba3fa212bb25fe2ac661993887c4b69af6f1 | containers/81/81d3ba3fa212bb25fe2ac661993887c4b69af6f1_after.sif | sha256:09821aa3bd7e262538f75a53494dcc1cb287355e30c97427fe6b14f4b5770c4a | sha256:525d3bddd55eedbe3be9cf2cc77b9662f6e9f1f1c9292645a3bb1176eae78c1c | gst_riff_create_audio_caps | gst_riff_create_audio_caps (guint16 codec_id,
gst_riff_strh * strh, gst_riff_strf_auds * strf,
GstBuffer * strf_data, GstBuffer * strd_data, char **codec_name,
gint channel_reorder_map[18])
{
gboolean block_align = FALSE, rate_chan = TRUE;
GstCaps *caps = NULL;
gint i;
if (channel_reorder_map)
f... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | gst-libs/gst/riff/riff-media.c | [
"CVE-2017-5837"
] | The gst_riff_create_audio_caps function in gst-libs/gst/riff/riff-media.c in gst-plugins-base in GStreamer before 1.10.3 allows remote attackers to cause a denial of service (floating point exception and crash) via a crafted video file. | [
"CWE-369"
] | null | null | gst_riff_create_audio_caps (guint16 codec_id,
gst_riff_strh * strh, gst_riff_strf_auds * strf,
GstBuffer * strf_data, GstBuffer * strd_data, char **codec_name,
gint channel_reorder_map[18])
{
gboolean block_align = FALSE, rate_chan = TRUE;
GstCaps *caps = NULL;
gint i;
if (channel_reorder_map)
f... | gst_riff_create_audio_caps (guint16 codec_id,
gst_riff_strh * strh, gst_riff_strf_auds * strf,
GstBuffer * strf_data, GstBuffer * strd_data, char **codec_name,
gint channel_reorder_map[18])
{
gboolean block_align = FALSE, rate_chan = TRUE;
GstCaps *caps = NULL;
gint i;
if (channel_reorder_map)
f... | riff-media: Check for valid channels/rate before using the values
Otherwise we might divide by zero or otherwise create invalid caps.
https://bugzilla.gnome.org/show_bug.cgi?id=777262 |
00ee47bff6191e1a04943405 | openvul | train | train:8064 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4ef1b2869447411ad3ef91ad7d4891a83c1a509a | 4ef1b2869447411ad3ef91ad7d4891a83c1a509a | before | true | 8605330aac5a5785630aec8f64378a54891937cc | containers/4e/4ef1b2869447411ad3ef91ad7d4891a83c1a509a_before.sif | sha256:fb46e8e089a66918d2b88c734dcd0d232523dbdfc531d94d2f6b9e6287e844f7 | sha256:5d0fdd309eb4a57cb3e10715a494b513fc34143d2a69117f230febd170541e41 | __skb_tstamp_tx | void __skb_tstamp_tx(struct sk_buff *orig_skb,
struct skb_shared_hwtstamps *hwtstamps,
struct sock *sk, int tstype)
{
struct sk_buff *skb;
bool tsonly;
if (!sk)
return;
tsonly = sk->sk_tsflags & SOF_TIMESTAMPING_OPT_TSONLY;
if (!skb_may_tx_timestamp(sk, tsonly))
return;
if (tsonly) {
#ifdef CONF... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/core/skbuff.c | [
"CVE-2017-7277"
] | The TCP stack in the Linux kernel through 4.10.6 mishandles the SCM_TIMESTAMPING_OPT_STATS feature, which allows local users to obtain sensitive information from the kernel's internal socket data structures or cause a denial of service (out-of-bounds read) via crafted system calls, related to net/core/skbuff.c and net/... | [
"CWE-125"
] | null | null | void __skb_tstamp_tx(struct sk_buff *orig_skb,
struct skb_shared_hwtstamps *hwtstamps,
struct sock *sk, int tstype)
{
struct sk_buff *skb;
bool tsonly;
if (!sk)
return;
tsonly = sk->sk_tsflags & SOF_TIMESTAMPING_OPT_TSONLY;
if (!skb_may_tx_timestamp(sk, tsonly))
return;
if (tsonly) {
#ifdef CONF... | void __skb_tstamp_tx(struct sk_buff *orig_skb,
struct skb_shared_hwtstamps *hwtstamps,
struct sock *sk, int tstype)
{
struct sk_buff *skb;
bool tsonly, opt_stats = false;
if (!sk)
return;
tsonly = sk->sk_tsflags & SOF_TIMESTAMPING_OPT_TSONLY;
if (!skb_may_tx_timestamp(sk, tsonly))
return;
if (ts... | tcp: mark skbs with SCM_TIMESTAMPING_OPT_STATS
SOF_TIMESTAMPING_OPT_STATS can be enabled and disabled
while packets are collected on the error queue.
So, checking SOF_TIMESTAMPING_OPT_STATS in sk->sk_tsflags
is not enough to safely assume that the skb contains
OPT_STATS data.
Add a bit in sock_exterr_skb to indicate ... |
00ee47bff6191e1a04943405 | openvul | train | train:8064 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4ef1b2869447411ad3ef91ad7d4891a83c1a509a | 4ef1b2869447411ad3ef91ad7d4891a83c1a509a | after | false | 4ef1b2869447411ad3ef91ad7d4891a83c1a509a | containers/4e/4ef1b2869447411ad3ef91ad7d4891a83c1a509a_after.sif | sha256:03c0334b38dade258efe3806f82015a5ff3c8c28e0fd754522e297fe73cf41bb | sha256:1651036b867355b7a779382e86baf227dca46ec49a31318a1a88447c3567ffc8 | __skb_tstamp_tx | void __skb_tstamp_tx(struct sk_buff *orig_skb,
struct skb_shared_hwtstamps *hwtstamps,
struct sock *sk, int tstype)
{
struct sk_buff *skb;
bool tsonly, opt_stats = false;
if (!sk)
return;
tsonly = sk->sk_tsflags & SOF_TIMESTAMPING_OPT_TSONLY;
if (!skb_may_tx_timestamp(sk, tsonly))
return;
if (ts... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/core/skbuff.c | [
"CVE-2017-7277"
] | The TCP stack in the Linux kernel through 4.10.6 mishandles the SCM_TIMESTAMPING_OPT_STATS feature, which allows local users to obtain sensitive information from the kernel's internal socket data structures or cause a denial of service (out-of-bounds read) via crafted system calls, related to net/core/skbuff.c and net/... | [
"CWE-125"
] | null | null | void __skb_tstamp_tx(struct sk_buff *orig_skb,
struct skb_shared_hwtstamps *hwtstamps,
struct sock *sk, int tstype)
{
struct sk_buff *skb;
bool tsonly;
if (!sk)
return;
tsonly = sk->sk_tsflags & SOF_TIMESTAMPING_OPT_TSONLY;
if (!skb_may_tx_timestamp(sk, tsonly))
return;
if (tsonly) {
#ifdef CONF... | void __skb_tstamp_tx(struct sk_buff *orig_skb,
struct skb_shared_hwtstamps *hwtstamps,
struct sock *sk, int tstype)
{
struct sk_buff *skb;
bool tsonly, opt_stats = false;
if (!sk)
return;
tsonly = sk->sk_tsflags & SOF_TIMESTAMPING_OPT_TSONLY;
if (!skb_may_tx_timestamp(sk, tsonly))
return;
if (ts... | tcp: mark skbs with SCM_TIMESTAMPING_OPT_STATS
SOF_TIMESTAMPING_OPT_STATS can be enabled and disabled
while packets are collected on the error queue.
So, checking SOF_TIMESTAMPING_OPT_STATS in sk->sk_tsflags
is not enough to safely assume that the skb contains
OPT_STATS data.
Add a bit in sock_exterr_skb to indicate ... |
00f6b40d35fb6e27a9b7ffe1 | openvul | train | train:19556 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | Android | https://android.googlesource.com/platform/system/core/+/268068f25673242d1d5130d96202d3288c91b700 | https://android.googlesource.com/platform/system/core | https://android.googlesource.com/platform/system/core/+/268068f25673242d1d5130d96202d3288c91b700%5E%21/#F0 | 268068f25673242d1d5130d96202d3288c91b700 | before | true | 63760409ad833cf803482e098367f49741b5f6d3 | containers/26/268068f25673242d1d5130d96202d3288c91b700_before.sif | sha256:be9d207069e39c8e0314e50bfcb717fa83ea83b07d47c6297cce7330dd7bdeaa | sha256:06b06c6538742c1d40a455687ca8667a93c93bae59b423e00a2835694c6c2c9e | install_local_socket | void install_local_socket(asocket* s) {
adb_mutex_lock(&socket_list_lock);
s->id = local_socket_next_id++;
if (local_socket_next_id == 0) {
local_socket_next_id = 1;
}
insert_local_socket(s, &local_socket_list);
adb_mutex_unlock(&socket_list_lock);
} | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | adb/sockets.cpp | [
"CVE-2016-3890"
] | The Java Debug Wire Protocol (JDWP) implementation in adb/sockets.cpp in Android 4.x before 4.4.4, 5.0.x before 5.0.2, 5.1.x before 5.1.1, and 6.x before 2016-09-01 mishandles socket close operations, which allows attackers to gain privileges via a crafted application, aka internal bug 28347842. | [
"CWE-833"
] | null | null | void install_local_socket(asocket* s) {
adb_mutex_lock(&socket_list_lock);
s->id = local_socket_next_id++;
if (local_socket_next_id == 0) {
local_socket_next_id = 1;
}
insert_local_socket(s, &local_socket_list);
adb_mutex_unlock(&socket_list_lock);
} | void install_local_socket(asocket* s) {
std::lock_guard<std::recursive_mutex> lock(local_socket_list_lock);
s->id = local_socket_next_id++;
if (local_socket_next_id == 0) {
fatal("local socket id overflow");
}
insert_local_socket(s, &local_socket_list);
} | adb: switch the socket list mutex to a recursive_mutex.
sockets.cpp was branching on whether a socket close function was
local_socket_close in order to avoid a potential deadlock if the socket
list lock was held while closing a peer socket.
Bug: http://b/28347842
Change-Id: I5e56f17fa54275284787f0f1dc150d1960256ab3
(... |
00f6b40d35fb6e27a9b7ffe1 | openvul | train | train:19556 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | Android | https://android.googlesource.com/platform/system/core/+/268068f25673242d1d5130d96202d3288c91b700 | https://android.googlesource.com/platform/system/core | https://android.googlesource.com/platform/system/core/+/268068f25673242d1d5130d96202d3288c91b700%5E%21/#F0 | 268068f25673242d1d5130d96202d3288c91b700 | after | false | 268068f25673242d1d5130d96202d3288c91b700 | containers/26/268068f25673242d1d5130d96202d3288c91b700_after.sif | sha256:0b2bc9113da8a5e0550730c09f01e91ce25e40a01d8a04b49214769031ff3e80 | sha256:1854a2aad2dffaadee467adb79fe784bc5d264e5b38f03b613359376bad4ca16 | install_local_socket | void install_local_socket(asocket* s) {
std::lock_guard<std::recursive_mutex> lock(local_socket_list_lock);
s->id = local_socket_next_id++;
if (local_socket_next_id == 0) {
fatal("local socket id overflow");
}
insert_local_socket(s, &local_socket_list);
} | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | adb/sockets.cpp | [
"CVE-2016-3890"
] | The Java Debug Wire Protocol (JDWP) implementation in adb/sockets.cpp in Android 4.x before 4.4.4, 5.0.x before 5.0.2, 5.1.x before 5.1.1, and 6.x before 2016-09-01 mishandles socket close operations, which allows attackers to gain privileges via a crafted application, aka internal bug 28347842. | [
"CWE-833"
] | null | null | void install_local_socket(asocket* s) {
adb_mutex_lock(&socket_list_lock);
s->id = local_socket_next_id++;
if (local_socket_next_id == 0) {
local_socket_next_id = 1;
}
insert_local_socket(s, &local_socket_list);
adb_mutex_unlock(&socket_list_lock);
} | void install_local_socket(asocket* s) {
std::lock_guard<std::recursive_mutex> lock(local_socket_list_lock);
s->id = local_socket_next_id++;
if (local_socket_next_id == 0) {
fatal("local socket id overflow");
}
insert_local_socket(s, &local_socket_list);
} | adb: switch the socket list mutex to a recursive_mutex.
sockets.cpp was branching on whether a socket close function was
local_socket_close in order to avoid a potential deadlock if the socket
list lock was held while closing a peer socket.
Bug: http://b/28347842
Change-Id: I5e56f17fa54275284787f0f1dc150d1960256ab3
(... |
01028338c2aee4907e9f9c8d | openvul | train | train:4128 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4b81ccebaeee885ab1aa1438133f2991e3a2b6ea | 4b81ccebaeee885ab1aa1438133f2991e3a2b6ea | before | true | 049c4e13714ecbca567b4d5f6d563f05d431c80e | containers/4b/4b81ccebaeee885ab1aa1438133f2991e3a2b6ea_before.sif | sha256:9961c51f56f8a9c0f31df2a653e49d667812c376a49d866c547186e3b709cb4f | sha256:0556a9da2a92eab1a9b88f8d16f0bb1000c258d1e22bbfa063a9bd55c552744b | __bpf_ringbuf_reserve | static void *__bpf_ringbuf_reserve(struct bpf_ringbuf *rb, u64 size)
{
unsigned long cons_pos, prod_pos, new_prod_pos, flags;
u32 len, pg_off;
struct bpf_ringbuf_hdr *hdr;
if (unlikely(size > RINGBUF_MAX_RECORD_SZ))
return NULL;
len = round_up(size + BPF_RINGBUF_HDR_SZ, 8);
cons_pos = smp_load_acquire(&rb->cons... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | kernel/bpf/ringbuf.c | [
"CVE-2021-3489"
] | The eBPF RINGBUF bpf_ringbuf_reserve() function in the Linux kernel did not check that the allocated size was smaller than the ringbuf size, allowing an attacker to perform out-of-bounds writes within the kernel and therefore, arbitrary code execution. This issue was fixed via commit 4b81ccebaeee ("bpf, ringbuf: Deny r... | [
"CWE-787, CWE-119"
] | null | null | static void *__bpf_ringbuf_reserve(struct bpf_ringbuf *rb, u64 size)
{
unsigned long cons_pos, prod_pos, new_prod_pos, flags;
u32 len, pg_off;
struct bpf_ringbuf_hdr *hdr;
if (unlikely(size > RINGBUF_MAX_RECORD_SZ))
return NULL;
len = round_up(size + BPF_RINGBUF_HDR_SZ, 8);
cons_pos = smp_load_acquire(&rb->cons... | static void *__bpf_ringbuf_reserve(struct bpf_ringbuf *rb, u64 size)
{
unsigned long cons_pos, prod_pos, new_prod_pos, flags;
u32 len, pg_off;
struct bpf_ringbuf_hdr *hdr;
if (unlikely(size > RINGBUF_MAX_RECORD_SZ))
return NULL;
len = round_up(size + BPF_RINGBUF_HDR_SZ, 8);
if (len > rb->mask + 1)
return NULL... | bpf, ringbuf: Deny reserve of buffers larger than ringbuf
A BPF program might try to reserve a buffer larger than the ringbuf size.
If the consumer pointer is way ahead of the producer, that would be
successfully reserved, allowing the BPF program to read or write out of
the ringbuf allocated area.
Reported-by: Ryota... |
01028338c2aee4907e9f9c8d | openvul | train | train:4128 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/4b81ccebaeee885ab1aa1438133f2991e3a2b6ea | 4b81ccebaeee885ab1aa1438133f2991e3a2b6ea | after | false | 4b81ccebaeee885ab1aa1438133f2991e3a2b6ea | containers/4b/4b81ccebaeee885ab1aa1438133f2991e3a2b6ea_after.sif | sha256:a71961e5dfa0ff47d08b702d774b85dfc7bbd921d059da6904a6810ef542be32 | sha256:a3da431eb50e9b5dd7713461e9d04cf88e06e886c16c9de9f2a5bff869f3880d | __bpf_ringbuf_reserve | static void *__bpf_ringbuf_reserve(struct bpf_ringbuf *rb, u64 size)
{
unsigned long cons_pos, prod_pos, new_prod_pos, flags;
u32 len, pg_off;
struct bpf_ringbuf_hdr *hdr;
if (unlikely(size > RINGBUF_MAX_RECORD_SZ))
return NULL;
len = round_up(size + BPF_RINGBUF_HDR_SZ, 8);
if (len > rb->mask + 1)
return NULL... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | kernel/bpf/ringbuf.c | [
"CVE-2021-3489"
] | The eBPF RINGBUF bpf_ringbuf_reserve() function in the Linux kernel did not check that the allocated size was smaller than the ringbuf size, allowing an attacker to perform out-of-bounds writes within the kernel and therefore, arbitrary code execution. This issue was fixed via commit 4b81ccebaeee ("bpf, ringbuf: Deny r... | [
"CWE-787, CWE-119"
] | null | null | static void *__bpf_ringbuf_reserve(struct bpf_ringbuf *rb, u64 size)
{
unsigned long cons_pos, prod_pos, new_prod_pos, flags;
u32 len, pg_off;
struct bpf_ringbuf_hdr *hdr;
if (unlikely(size > RINGBUF_MAX_RECORD_SZ))
return NULL;
len = round_up(size + BPF_RINGBUF_HDR_SZ, 8);
cons_pos = smp_load_acquire(&rb->cons... | static void *__bpf_ringbuf_reserve(struct bpf_ringbuf *rb, u64 size)
{
unsigned long cons_pos, prod_pos, new_prod_pos, flags;
u32 len, pg_off;
struct bpf_ringbuf_hdr *hdr;
if (unlikely(size > RINGBUF_MAX_RECORD_SZ))
return NULL;
len = round_up(size + BPF_RINGBUF_HDR_SZ, 8);
if (len > rb->mask + 1)
return NULL... | bpf, ringbuf: Deny reserve of buffers larger than ringbuf
A BPF program might try to reserve a buffer larger than the ringbuf size.
If the consumer pointer is way ahead of the producer, that would be
successfully reserved, allowing the BPF program to read or write out of
the ringbuf allocated area.
Reported-by: Ryota... |
0104094151d3188625e0e142 | openvul | train | train:19500 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | Android | https://android.googlesource.com/platform/external/libxaac/+/04e8cd58f075bec5892e369c8deebca9c67e855c | https://android.googlesource.com/platform/external/libxaac | https://android.googlesource.com/platform/external/libxaac/+/04e8cd58f075bec5892e369c8deebca9c67e855c%5E%21/#F0 | 04e8cd58f075bec5892e369c8deebca9c67e855c | before | true | e98460acfcb61a5519979f029221a91424320124 | containers/04/04e8cd58f075bec5892e369c8deebca9c67e855c_before.sif | sha256:e5ef2b27bed0e6724d6b352ed379bb08a4991aa20f105022d0226ed7bd6ee7eb | sha256:ff87067a9a4847103a06c67836ba473103dfae0572dbb0cf347d809d6a3af8dc | ixheaacd_qmf_hbe_data_reinit | WORD32 ixheaacd_qmf_hbe_data_reinit(ia_esbr_hbe_txposer_struct *ptr_hbe_txposer,
WORD16 *p_freq_band_tab[2],
WORD16 *p_num_sfb, WORD32 upsamp_4_flag) {
WORD32 synth_size, sfb, patch, stop_patch;
if (ptr_hbe_txposer != NULL) {
ptr_hbe_txposer... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | decoder/ixheaacd_hbe_trans.c | [
"CVE-2018-9496"
] | In ixheaacd_real_synth_fft_p3 of ixheaacd_esbr_fft.c there is a possible out of bounds write due to a missing bounds check. This could lead to remote code execution with no additional execution privileges needed. User interaction is needed for exploitation. Product: Android Versions: Android-9.0 Android ID: A-110769924 | [
"CWE-787"
] | null | null | WORD32 ixheaacd_qmf_hbe_data_reinit(ia_esbr_hbe_txposer_struct *ptr_hbe_txposer,
WORD16 *p_freq_band_tab[2],
WORD16 *p_num_sfb, WORD32 upsamp_4_flag) {
WORD32 synth_size, sfb, patch, stop_patch;
if (ptr_hbe_txposer != NULL) {
ptr_hbe_txposer... | WORD32 ixheaacd_qmf_hbe_data_reinit(ia_esbr_hbe_txposer_struct *ptr_hbe_txposer,
WORD16 *p_freq_band_tab[2],
WORD16 *p_num_sfb, WORD32 upsamp_4_flag) {
WORD32 synth_size, sfb, patch, stop_patch;
if (ptr_hbe_txposer != NULL) {
ptr_hbe_txposer... | Fix for stack corruption in esbr
Bug: 110769924
Test: poc from bug before/after
Change-Id: I99c6e89902064849ea1310c271064bdeccf7f20e
(cherry picked from commit 7e90d745c22695236437297cd8167a9312427a4a)
(cherry picked from commit 5464927f0c1fc721fa03d1c5be77b0b43dfffc50) |
0104094151d3188625e0e142 | openvul | train | train:19500 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | Android | https://android.googlesource.com/platform/external/libxaac/+/04e8cd58f075bec5892e369c8deebca9c67e855c | https://android.googlesource.com/platform/external/libxaac | https://android.googlesource.com/platform/external/libxaac/+/04e8cd58f075bec5892e369c8deebca9c67e855c%5E%21/#F0 | 04e8cd58f075bec5892e369c8deebca9c67e855c | after | false | 04e8cd58f075bec5892e369c8deebca9c67e855c | containers/04/04e8cd58f075bec5892e369c8deebca9c67e855c_after.sif | sha256:14eeee973efc0c8b8a0cdd045efb8d124e26dcd5261eddde30e1bbb0fa5c0e7d | sha256:9ef744286457455a5d0ffb71caafe77028510d06f17747aed4eec8b0a114ad6d | ixheaacd_qmf_hbe_data_reinit | WORD32 ixheaacd_qmf_hbe_data_reinit(ia_esbr_hbe_txposer_struct *ptr_hbe_txposer,
WORD16 *p_freq_band_tab[2],
WORD16 *p_num_sfb, WORD32 upsamp_4_flag) {
WORD32 synth_size, sfb, patch, stop_patch;
if (ptr_hbe_txposer != NULL) {
ptr_hbe_txposer... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | decoder/ixheaacd_hbe_trans.c | [
"CVE-2018-9496"
] | In ixheaacd_real_synth_fft_p3 of ixheaacd_esbr_fft.c there is a possible out of bounds write due to a missing bounds check. This could lead to remote code execution with no additional execution privileges needed. User interaction is needed for exploitation. Product: Android Versions: Android-9.0 Android ID: A-110769924 | [
"CWE-787"
] | null | null | WORD32 ixheaacd_qmf_hbe_data_reinit(ia_esbr_hbe_txposer_struct *ptr_hbe_txposer,
WORD16 *p_freq_band_tab[2],
WORD16 *p_num_sfb, WORD32 upsamp_4_flag) {
WORD32 synth_size, sfb, patch, stop_patch;
if (ptr_hbe_txposer != NULL) {
ptr_hbe_txposer... | WORD32 ixheaacd_qmf_hbe_data_reinit(ia_esbr_hbe_txposer_struct *ptr_hbe_txposer,
WORD16 *p_freq_band_tab[2],
WORD16 *p_num_sfb, WORD32 upsamp_4_flag) {
WORD32 synth_size, sfb, patch, stop_patch;
if (ptr_hbe_txposer != NULL) {
ptr_hbe_txposer... | Fix for stack corruption in esbr
Bug: 110769924
Test: poc from bug before/after
Change-Id: I99c6e89902064849ea1310c271064bdeccf7f20e
(cherry picked from commit 7e90d745c22695236437297cd8167a9312427a4a)
(cherry picked from commit 5464927f0c1fc721fa03d1c5be77b0b43dfffc50) |
01058e3fbf869e544e1cdbfd | openvul | train | train:14734 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | asylo | https://github.com/google/asylo | https://github.com/google/asylo | https://github.com/google/asylo/commit/299f804acbb95a612ab7c504d25ab908aa59ae93 | 299f804acbb95a612ab7c504d25ab908aa59ae93 | before | true | e582f36ac49ee11a21d23ad6a30c333092e0a94e | containers/29/299f804acbb95a612ab7c504d25ab908aa59ae93_before.sif | sha256:7fe81ad9c589b21f8aa505de4638f355a40c40f8cf0979d6f57b377226b5ff89 | sha256:db61449eb5dd0ba46bdd0b6c8c890d09226d8a6c22ff1c17240552fdea32f6b6 | enc_untrusted_recvfrom | ssize_t enc_untrusted_recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen) {
int klinux_flags = TokLinuxRecvSendFlag(flags);
if (klinux_flags == 0 && flags != 0) {
errno = EINVAL;
return -1;
}
MessageWriter input;
input.Pu... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | asylo/platform/host_call/trusted/host_calls.cc | [
"CVE-2020-8905"
] | A buffer length validation vulnerability in Asylo versions prior to 0.6.0 allows an attacker to read data they should not have access to. The 'enc_untrusted_recvfrom' function generates a return value which is deserialized by 'MessageReader', and copied into three different 'extents'. The length of the third 'extents' ... | [
"CWE-120"
] | null | null | ssize_t enc_untrusted_recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen) {
int klinux_flags = TokLinuxRecvSendFlag(flags);
if (klinux_flags == 0 && flags != 0) {
errno = EINVAL;
return -1;
}
MessageWriter input;
input.Pu... | ssize_t enc_untrusted_recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen) {
int klinux_flags = TokLinuxRecvSendFlag(flags);
if (klinux_flags == 0 && flags != 0) {
errno = EINVAL;
return -1;
}
MessageWriter input;
input.Pu... | Fix vulnerability in enc_untrusted_recvfrom
Change recvfrom memcpy to check for received_buffer size to avoid
copying extra buffer.
This issue was reported by Qinkun Bao, Zhaofeng Chen, Mingshen Sun, and
Kang Li from Baidu Security.
PiperOrigin-RevId: 322476299
Change-Id: I3606ff9ec51ec7cc4312c7555c645a2fc6e09b21 |
01058e3fbf869e544e1cdbfd | openvul | train | train:14734 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | asylo | https://github.com/google/asylo | https://github.com/google/asylo | https://github.com/google/asylo/commit/299f804acbb95a612ab7c504d25ab908aa59ae93 | 299f804acbb95a612ab7c504d25ab908aa59ae93 | after | false | 299f804acbb95a612ab7c504d25ab908aa59ae93 | containers/29/299f804acbb95a612ab7c504d25ab908aa59ae93_after.sif | sha256:775c68aeca5b6ed0952401a398e2d73483643ab0667d85a5f4cd274c3409c262 | sha256:68a37d5292056a3a82bab199d52d6431e4f9e4a96550a82df655956021314ac3 | enc_untrusted_recvfrom | ssize_t enc_untrusted_recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen) {
int klinux_flags = TokLinuxRecvSendFlag(flags);
if (klinux_flags == 0 && flags != 0) {
errno = EINVAL;
return -1;
}
MessageWriter input;
input.Pu... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | asylo/platform/host_call/trusted/host_calls.cc | [
"CVE-2020-8905"
] | A buffer length validation vulnerability in Asylo versions prior to 0.6.0 allows an attacker to read data they should not have access to. The 'enc_untrusted_recvfrom' function generates a return value which is deserialized by 'MessageReader', and copied into three different 'extents'. The length of the third 'extents' ... | [
"CWE-120"
] | null | null | ssize_t enc_untrusted_recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen) {
int klinux_flags = TokLinuxRecvSendFlag(flags);
if (klinux_flags == 0 && flags != 0) {
errno = EINVAL;
return -1;
}
MessageWriter input;
input.Pu... | ssize_t enc_untrusted_recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen) {
int klinux_flags = TokLinuxRecvSendFlag(flags);
if (klinux_flags == 0 && flags != 0) {
errno = EINVAL;
return -1;
}
MessageWriter input;
input.Pu... | Fix vulnerability in enc_untrusted_recvfrom
Change recvfrom memcpy to check for received_buffer size to avoid
copying extra buffer.
This issue was reported by Qinkun Bao, Zhaofeng Chen, Mingshen Sun, and
Kang Li from Baidu Security.
PiperOrigin-RevId: 322476299
Change-Id: I3606ff9ec51ec7cc4312c7555c645a2fc6e09b21 |
0109968f0b206614d5977aa6 | openvul | train | train:13286 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | pdfresurrect | https://github.com/enferex/pdfresurrect | https://github.com/enferex/pdfresurrect | https://github.com/enferex/pdfresurrect/commit/0c4120fffa3dffe97b95c486a120eded82afe8a6 | 0c4120fffa3dffe97b95c486a120eded82afe8a6 | before | true | 43339ca3fd32537c5218e560599252278245f517 | containers/0c/0c4120fffa3dffe97b95c486a120eded82afe8a6_before.sif | sha256:6662d844629260d0442d610e0fc5f53df0e5adfb82a2a7201570db398c1bfe66 | sha256:d9f43474a89d15495984c0f3b996ef7041d499486c03938c4d7c4049bc8e1b22 | get_object | static char *get_object(
FILE *fp,
int obj_id,
const xref_t *xref,
size_t *size,
int *is_stream)
{
static const int blk_sz = 256;
int i, total_sz, read_sz, n_blks, search, stream;
size_t obj_sz;
char *c, *... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | pdf.c | [
"CVE-2019-14934"
] | An issue was discovered in PDFResurrect before 0.18. pdf_load_pages_kids in pdf.c doesn't validate a certain size value, which leads to a malloc failure and out-of-bounds write. | [
"CWE-787"
] | null | null | static char *get_object(
FILE *fp,
int obj_id,
const xref_t *xref,
size_t *size,
int *is_stream)
{
static const int blk_sz = 256;
int i, total_sz, read_sz, n_blks, search, stream;
size_t obj_sz;
char *c, *... | static char *get_object(
FILE *fp,
int obj_id,
const xref_t *xref,
size_t *size,
int *is_stream)
{
static const int blk_sz = 256;
int i, total_sz, read_sz, n_blks, search, stream;
size_t obj_sz;
char *c, *... | Zero and sanity check all dynamic allocs.
This addresses the memory issues in Issue #6 expressed in
calloc_some.pdf and malloc_some.pdf |
0109968f0b206614d5977aa6 | openvul | train | train:13286 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | pdfresurrect | https://github.com/enferex/pdfresurrect | https://github.com/enferex/pdfresurrect | https://github.com/enferex/pdfresurrect/commit/0c4120fffa3dffe97b95c486a120eded82afe8a6 | 0c4120fffa3dffe97b95c486a120eded82afe8a6 | after | false | 0c4120fffa3dffe97b95c486a120eded82afe8a6 | containers/0c/0c4120fffa3dffe97b95c486a120eded82afe8a6_after.sif | sha256:56cb44086748b0573b4fe5fc9eb510abbda8629dbda63d80010b7e4c7a0195b5 | sha256:5b9010691d69d4d48bda308979d2a51f6cd2decc1c58eeed250f4b1801f05409 | get_object | static char *get_object(
FILE *fp,
int obj_id,
const xref_t *xref,
size_t *size,
int *is_stream)
{
static const int blk_sz = 256;
int i, total_sz, read_sz, n_blks, search, stream;
size_t obj_sz;
char *c, *... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | pdf.c | [
"CVE-2019-14934"
] | An issue was discovered in PDFResurrect before 0.18. pdf_load_pages_kids in pdf.c doesn't validate a certain size value, which leads to a malloc failure and out-of-bounds write. | [
"CWE-787"
] | null | null | static char *get_object(
FILE *fp,
int obj_id,
const xref_t *xref,
size_t *size,
int *is_stream)
{
static const int blk_sz = 256;
int i, total_sz, read_sz, n_blks, search, stream;
size_t obj_sz;
char *c, *... | static char *get_object(
FILE *fp,
int obj_id,
const xref_t *xref,
size_t *size,
int *is_stream)
{
static const int blk_sz = 256;
int i, total_sz, read_sz, n_blks, search, stream;
size_t obj_sz;
char *c, *... | Zero and sanity check all dynamic allocs.
This addresses the memory issues in Issue #6 expressed in
calloc_some.pdf and malloc_some.pdf |
010b8b1b5add652e2638b397 | openvul | train | train:4550 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d407b071dc369c26a38398326ee2be53651cfe4 | 5d407b071dc369c26a38398326ee2be53651cfe4 | before | true | 52ea992cfac357b73180d5c051dca43bc8d20c2a | containers/5d/5d407b071dc369c26a38398326ee2be53651cfe4_before.sif | sha256:8229ba0f8aa9142f09636a34205375831fdb39a4fd766f92b0fcacc0646f5b94 | sha256:8b7652f6950775296d0b98ba3d30c1e9f9baaf303e672337159d7626b2168556 | ip_frag_reasm | static int ip_frag_reasm(struct ipq *qp, struct sk_buff *skb,
struct sk_buff *prev_tail, struct net_device *dev)
{
struct net *net = container_of(qp->q.net, struct net, ipv4.frags);
struct iphdr *iph;
struct sk_buff *fp, *head = skb_rb_first(&qp->q.rb_fragments);
struct sk_buff **nextp;
struct rb_node *rbn;
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/ipv4/ip_fragment.c | [
"CVE-2018-14641"
] | A security flaw was found in the ip_frag_reasm() function in net/ipv4/ip_fragment.c in the Linux kernel from 4.19-rc1 to 4.19-rc3 inclusive, which can cause a later system crash in ip_do_fragment(). With certain non-default, but non-rare, configuration of a victim host, an attacker can trigger this crash remotely, thus... | [
"CWE-20"
] | null | null | static int ip_frag_reasm(struct ipq *qp, struct sk_buff *skb,
struct sk_buff *prev_tail, struct net_device *dev)
{
struct net *net = container_of(qp->q.net, struct net, ipv4.frags);
struct iphdr *iph;
struct sk_buff *fp, *head = skb_rb_first(&qp->q.rb_fragments);
struct sk_buff **nextp;
struct rb_node *rbn;
... | static int ip_frag_reasm(struct ipq *qp, struct sk_buff *skb,
struct sk_buff *prev_tail, struct net_device *dev)
{
struct net *net = container_of(qp->q.net, struct net, ipv4.frags);
struct iphdr *iph;
struct sk_buff *fp, *head = skb_rb_first(&qp->q.rb_fragments);
struct sk_buff **nextp;
struct rb_node *rbn;
... | ip: frags: fix crash in ip_do_fragment()
A kernel crash occurrs when defragmented packet is fragmented
in ip_do_fragment().
In defragment routine, skb_orphan() is called and
skb->ip_defrag_offset is set. but skb->sk and
skb->ip_defrag_offset are same union member. so that
frag->sk is not NULL.
Hence crash occurrs in s... |
010b8b1b5add652e2638b397 | openvul | train | train:4550 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5d407b071dc369c26a38398326ee2be53651cfe4 | 5d407b071dc369c26a38398326ee2be53651cfe4 | after | false | 5d407b071dc369c26a38398326ee2be53651cfe4 | containers/5d/5d407b071dc369c26a38398326ee2be53651cfe4_after.sif | sha256:8f6338e559e419cb5c0e215946d5317b1a16df6666201f6e222802a2e1f8ccbb | sha256:e1e2d0debb1146b7e85b526270abcf015f2d18abfacb50b737693c181be660a6 | ip_frag_reasm | static int ip_frag_reasm(struct ipq *qp, struct sk_buff *skb,
struct sk_buff *prev_tail, struct net_device *dev)
{
struct net *net = container_of(qp->q.net, struct net, ipv4.frags);
struct iphdr *iph;
struct sk_buff *fp, *head = skb_rb_first(&qp->q.rb_fragments);
struct sk_buff **nextp;
struct rb_node *rbn;
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/ipv4/ip_fragment.c | [
"CVE-2018-14641"
] | A security flaw was found in the ip_frag_reasm() function in net/ipv4/ip_fragment.c in the Linux kernel from 4.19-rc1 to 4.19-rc3 inclusive, which can cause a later system crash in ip_do_fragment(). With certain non-default, but non-rare, configuration of a victim host, an attacker can trigger this crash remotely, thus... | [
"CWE-20"
] | null | null | static int ip_frag_reasm(struct ipq *qp, struct sk_buff *skb,
struct sk_buff *prev_tail, struct net_device *dev)
{
struct net *net = container_of(qp->q.net, struct net, ipv4.frags);
struct iphdr *iph;
struct sk_buff *fp, *head = skb_rb_first(&qp->q.rb_fragments);
struct sk_buff **nextp;
struct rb_node *rbn;
... | static int ip_frag_reasm(struct ipq *qp, struct sk_buff *skb,
struct sk_buff *prev_tail, struct net_device *dev)
{
struct net *net = container_of(qp->q.net, struct net, ipv4.frags);
struct iphdr *iph;
struct sk_buff *fp, *head = skb_rb_first(&qp->q.rb_fragments);
struct sk_buff **nextp;
struct rb_node *rbn;
... | ip: frags: fix crash in ip_do_fragment()
A kernel crash occurrs when defragmented packet is fragmented
in ip_do_fragment().
In defragment routine, skb_orphan() is called and
skb->ip_defrag_offset is set. but skb->sk and
skb->ip_defrag_offset are same union member. so that
frag->sk is not NULL.
Hence crash occurrs in s... |
0130e4b6697e9dfdb2b3e885 | openvul | train | train:3610 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow/commit/0ab290774f91a23bebe30a358fde4e53ab4876a0 | 0ab290774f91a23bebe30a358fde4e53ab4876a0 | before | true | 327ef310be67923824814e85e13007e9699f4e0d | containers/0a/0ab290774f91a23bebe30a358fde4e53ab4876a0_before.sif | sha256:56b6b8ffa3e95ce6575bf0c80c03b9598fa2d03bbbd0f772040311c20b7a3474 | sha256:77dd72f8b67ce1544e66107e4a42dee07b40da447267fe82b93e9b6f3eaa8040 | Compute | void Compute(OpKernelContext* ctx) override {
const Tensor& in0 = ctx->input(0);
const Tensor& in1 = ctx->input(1);
ValidateInputTensors(ctx, in0, in1);
MatMulBCast bcast(in0.shape().dim_sizes(), in1.shape().dim_sizes());
OP_REQUIRES(
ctx, bcast.IsValid(),
errors::InvalidArgument(
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | tensorflow/core/kernels/linalg/banded_triangular_solve_op.cc | [
"CVE-2021-29612"
] | TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a heap buffer overflow in Eigen implementation of `tf.raw_ops.BandedTriangularSolve`. The implementation(https://github.com/tensorflow/tensorflow/blob/eccb7ec454e6617738554a255d77f08e60ee0808/tensorflow/core/kernels/linalg/ba... | [
"CWE-787"
] | null | null | void Compute(OpKernelContext* ctx) override {
const Tensor& in0 = ctx->input(0);
const Tensor& in1 = ctx->input(1);
ValidateInputTensors(ctx, in0, in1);
MatMulBCast bcast(in0.shape().dim_sizes(), in1.shape().dim_sizes());
OP_REQUIRES(
ctx, bcast.IsValid(),
errors::InvalidArgument(
... | void Compute(OpKernelContext* ctx) override {
const Tensor& in0 = ctx->input(0);
const Tensor& in1 = ctx->input(1);
ValidateInputTensors(ctx, in0, in1);
if (!ctx->status().ok()) return;
MatMulBCast bcast(in0.shape().dim_sizes(), in1.shape().dim_sizes());
OP_REQUIRES(
ctx, bcast.IsValid... | Ensure validation sticks in banded_triangular_solve_op
PiperOrigin-RevId: 373275480
Change-Id: Id7717cf275b2d6fdb9441fbbe166d555182d2e79 |
0130e4b6697e9dfdb2b3e885 | openvul | train | train:3610 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow/commit/0ab290774f91a23bebe30a358fde4e53ab4876a0 | 0ab290774f91a23bebe30a358fde4e53ab4876a0 | after | false | 0ab290774f91a23bebe30a358fde4e53ab4876a0 | containers/0a/0ab290774f91a23bebe30a358fde4e53ab4876a0_after.sif | sha256:1e3bdbd33face6451e999f9227edde4105e516cd9481ed07242e2fbf6b0f29b3 | sha256:7f2296787bcec289b57ea43b1cb39e270df9fef921a8b484597031a57cb2b5b4 | Compute | void Compute(OpKernelContext* ctx) override {
const Tensor& in0 = ctx->input(0);
const Tensor& in1 = ctx->input(1);
ValidateInputTensors(ctx, in0, in1);
if (!ctx->status().ok()) return;
MatMulBCast bcast(in0.shape().dim_sizes(), in1.shape().dim_sizes());
OP_REQUIRES(
ctx, bcast.IsValid... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | tensorflow/core/kernels/linalg/banded_triangular_solve_op.cc | [
"CVE-2021-29612"
] | TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a heap buffer overflow in Eigen implementation of `tf.raw_ops.BandedTriangularSolve`. The implementation(https://github.com/tensorflow/tensorflow/blob/eccb7ec454e6617738554a255d77f08e60ee0808/tensorflow/core/kernels/linalg/ba... | [
"CWE-787"
] | null | null | void Compute(OpKernelContext* ctx) override {
const Tensor& in0 = ctx->input(0);
const Tensor& in1 = ctx->input(1);
ValidateInputTensors(ctx, in0, in1);
MatMulBCast bcast(in0.shape().dim_sizes(), in1.shape().dim_sizes());
OP_REQUIRES(
ctx, bcast.IsValid(),
errors::InvalidArgument(
... | void Compute(OpKernelContext* ctx) override {
const Tensor& in0 = ctx->input(0);
const Tensor& in1 = ctx->input(1);
ValidateInputTensors(ctx, in0, in1);
if (!ctx->status().ok()) return;
MatMulBCast bcast(in0.shape().dim_sizes(), in1.shape().dim_sizes());
OP_REQUIRES(
ctx, bcast.IsValid... | Ensure validation sticks in banded_triangular_solve_op
PiperOrigin-RevId: 373275480
Change-Id: Id7717cf275b2d6fdb9441fbbe166d555182d2e79 |
01536d550ad023d5124ce5b8 | openvul | train | train:4196 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a5cc68f3d63306d0d288f31edfc2ae6ef8ecd887 | a5cc68f3d63306d0d288f31edfc2ae6ef8ecd887 | before | true | a963a37d384d71ad43b3e9e79d68d42fbe0901f3 | containers/a5/a5cc68f3d63306d0d288f31edfc2ae6ef8ecd887_before.sif | sha256:fd6044cefcee4238b30de258c02dda57d564ae651fb79bcbbf962f853753ed20 | sha256:2549e1f4203138d34c65127b3abe263ff7d4c14e5179722708b689cf2dacc095 | key_notify_sa_flush | static int key_notify_sa_flush(const struct km_event *c)
{
struct sk_buff *skb;
struct sadb_msg *hdr;
skb = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
if (!skb)
return -ENOBUFS;
hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
hdr->sadb_msg_satype = pfkey_proto2satype(c->data.proto);
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/key/af_key.c | [
"CVE-2013-2234"
] | The (1) key_notify_sa_flush and (2) key_notify_policy_flush functions in net/key/af_key.c in the Linux kernel before 3.10 do not initialize certain structure members, which allows local users to obtain sensitive information from kernel heap memory by reading a broadcast message from the notify interface of an IPSec key... | [
"CWE-119"
] | null | null | static int key_notify_sa_flush(const struct km_event *c)
{
struct sk_buff *skb;
struct sadb_msg *hdr;
skb = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
if (!skb)
return -ENOBUFS;
hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
hdr->sadb_msg_satype = pfkey_proto2satype(c->data.proto);
... | static int key_notify_sa_flush(const struct km_event *c)
{
struct sk_buff *skb;
struct sadb_msg *hdr;
skb = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
if (!skb)
return -ENOBUFS;
hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
hdr->sadb_msg_satype = pfkey_proto2satype(c->data.proto);
... | af_key: fix info leaks in notify messages
key_notify_sa_flush() and key_notify_policy_flush() miss to initialize
the sadb_msg_reserved member of the broadcasted message and thereby
leak 2 bytes of heap memory to listeners. Fix that.
Signed-off-by: Mathias Krause <minipli@googlemail.com>
Cc: Steffen Klassert <steffen.... |
01536d550ad023d5124ce5b8 | openvul | train | train:4196 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/a5cc68f3d63306d0d288f31edfc2ae6ef8ecd887 | a5cc68f3d63306d0d288f31edfc2ae6ef8ecd887 | after | false | a5cc68f3d63306d0d288f31edfc2ae6ef8ecd887 | containers/a5/a5cc68f3d63306d0d288f31edfc2ae6ef8ecd887_after.sif | sha256:252848f6ff0377c1bbeea614000c3040a5ceee6c165220ddad96fab69a42f9a3 | sha256:c420fff42f6a1f4ef273513dcfffb9a0269bdb83fa899a93a113c4661b0e23cc | key_notify_sa_flush | static int key_notify_sa_flush(const struct km_event *c)
{
struct sk_buff *skb;
struct sadb_msg *hdr;
skb = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
if (!skb)
return -ENOBUFS;
hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
hdr->sadb_msg_satype = pfkey_proto2satype(c->data.proto);
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/key/af_key.c | [
"CVE-2013-2234"
] | The (1) key_notify_sa_flush and (2) key_notify_policy_flush functions in net/key/af_key.c in the Linux kernel before 3.10 do not initialize certain structure members, which allows local users to obtain sensitive information from kernel heap memory by reading a broadcast message from the notify interface of an IPSec key... | [
"CWE-119"
] | null | null | static int key_notify_sa_flush(const struct km_event *c)
{
struct sk_buff *skb;
struct sadb_msg *hdr;
skb = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
if (!skb)
return -ENOBUFS;
hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
hdr->sadb_msg_satype = pfkey_proto2satype(c->data.proto);
... | static int key_notify_sa_flush(const struct km_event *c)
{
struct sk_buff *skb;
struct sadb_msg *hdr;
skb = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
if (!skb)
return -ENOBUFS;
hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
hdr->sadb_msg_satype = pfkey_proto2satype(c->data.proto);
... | af_key: fix info leaks in notify messages
key_notify_sa_flush() and key_notify_policy_flush() miss to initialize
the sadb_msg_reserved member of the broadcasted message and thereby
leak 2 bytes of heap memory to listeners. Fix that.
Signed-off-by: Mathias Krause <minipli@googlemail.com>
Cc: Steffen Klassert <steffen.... |
015a7fd043d0a5883a54c1c3 | openvul | train | train:5420 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/7f582b248d0a86bae5788c548d7bb5bca6f7691a | 7f582b248d0a86bae5788c548d7bb5bca6f7691a | before | true | e3ca34880652250f524022ad89e516f8ba9a805b | containers/7f/7f582b248d0a86bae5788c548d7bb5bca6f7691a_before.sif | sha256:5615a0d55708040e1aeffe5bda30559c6caec26b4f2f307205592dfa7975fb98 | sha256:2ffeef97fdba7080260223a689f001accdba27ba89a2c906691970b4cfd23e73 | __tcp_retransmit_skb | int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
{
struct inet_connection_sock *icsk = inet_csk(sk);
struct tcp_sock *tp = tcp_sk(sk);
unsigned int cur_mss;
int diff, len, err;
if (icsk->icsk_mtup.probe_size)
icsk->icsk_mtup.probe_size = 0;
if (refcount_read(&sk->sk_wmem_alloc) >
mi... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/ipv4/tcp_output.c | [
"CVE-2019-15239"
] | In the Linux kernel, a certain net/ipv4/tcp_output.c change, which was properly incorporated into 4.16.12, was incorrectly backported to the earlier longterm kernels, introducing a new vulnerability that was potentially more severe than the issue that was intended to be fixed by backporting. Specifically, by adding to ... | [
"CWE-416"
] | null | null | int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
{
struct inet_connection_sock *icsk = inet_csk(sk);
struct tcp_sock *tp = tcp_sk(sk);
unsigned int cur_mss;
int diff, len, err;
if (icsk->icsk_mtup.probe_size)
icsk->icsk_mtup.probe_size = 0;
if (refcount_read(&sk->sk_wmem_alloc) >
mi... | int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
{
struct inet_connection_sock *icsk = inet_csk(sk);
struct tcp_sock *tp = tcp_sk(sk);
unsigned int cur_mss;
int diff, len, err;
if (icsk->icsk_mtup.probe_size)
icsk->icsk_mtup.probe_size = 0;
if (refcount_read(&sk->sk_wmem_alloc) >
mi... | tcp: purge write queue in tcp_connect_init()
syzkaller found a reliable way to crash the host, hitting a BUG()
in __tcp_retransmit_skb()
Malicous MSG_FASTOPEN is the root cause. We need to purge write queue
in tcp_connect_init() at the point we init snd_una/write_seq.
This patch also replaces the BUG() by a less int... |
015a7fd043d0a5883a54c1c3 | openvul | train | train:5420 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/7f582b248d0a86bae5788c548d7bb5bca6f7691a | 7f582b248d0a86bae5788c548d7bb5bca6f7691a | after | false | 7f582b248d0a86bae5788c548d7bb5bca6f7691a | containers/7f/7f582b248d0a86bae5788c548d7bb5bca6f7691a_after.sif | sha256:975ad91114af17d20022f0372b87fc3ab107d1ee296fcffbacafd0a0403a645d | sha256:d3c6aae369b29e74a51ccb7977f145c1d77fe57263b832d3a41cd046fa355f81 | __tcp_retransmit_skb | int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
{
struct inet_connection_sock *icsk = inet_csk(sk);
struct tcp_sock *tp = tcp_sk(sk);
unsigned int cur_mss;
int diff, len, err;
if (icsk->icsk_mtup.probe_size)
icsk->icsk_mtup.probe_size = 0;
if (refcount_read(&sk->sk_wmem_alloc) >
mi... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/ipv4/tcp_output.c | [
"CVE-2019-15239"
] | In the Linux kernel, a certain net/ipv4/tcp_output.c change, which was properly incorporated into 4.16.12, was incorrectly backported to the earlier longterm kernels, introducing a new vulnerability that was potentially more severe than the issue that was intended to be fixed by backporting. Specifically, by adding to ... | [
"CWE-416"
] | null | null | int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
{
struct inet_connection_sock *icsk = inet_csk(sk);
struct tcp_sock *tp = tcp_sk(sk);
unsigned int cur_mss;
int diff, len, err;
if (icsk->icsk_mtup.probe_size)
icsk->icsk_mtup.probe_size = 0;
if (refcount_read(&sk->sk_wmem_alloc) >
mi... | int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
{
struct inet_connection_sock *icsk = inet_csk(sk);
struct tcp_sock *tp = tcp_sk(sk);
unsigned int cur_mss;
int diff, len, err;
if (icsk->icsk_mtup.probe_size)
icsk->icsk_mtup.probe_size = 0;
if (refcount_read(&sk->sk_wmem_alloc) >
mi... | tcp: purge write queue in tcp_connect_init()
syzkaller found a reliable way to crash the host, hitting a BUG()
in __tcp_retransmit_skb()
Malicous MSG_FASTOPEN is the root cause. We need to purge write queue
in tcp_connect_init() at the point we init snd_una/write_seq.
This patch also replaces the BUG() by a less int... |
015ee2ad92e9e3912c3da744 | openvul | train | train:7528 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | before | true | f873042093c0b418d2351fe142222b625c740149 | containers/f3/f3d3342602f8bcbf37d7c46641cb9bca7618eb1c_before.sif | sha256:2ae8bb1387ec96885931cbda3bef3d5a42227e7c5de68f331ff0a23e20bfa302 | sha256:30391c7a37ceaa659425d946655b5365884840854d4ab8d41cd8841cd482c82b | bt_sock_recvmsg | int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
int noblock = flags & MSG_DONTWAIT;
struct sock *sk = sock->sk;
struct sk_buff *skb;
size_t copied;
int err;
BT_DBG("sock %p sk %p len %zu", sock, sk, len);
if (flags & (MSG_OOB))
return -EOPNOTSUPP;
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/bluetooth/af_bluetooth.c | [
"CVE-2013-7270"
] | The packet_recvmsg function in net/packet/af_packet.c in the Linux kernel before 3.12.4 updates a certain length value before ensuring that an associated data structure has been initialized, which allows local users to obtain sensitive information from kernel memory via a (1) recvfrom, (2) recvmmsg, or (3) recvmsg syst... | [
"CWE-20"
] | null | null | int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
int noblock = flags & MSG_DONTWAIT;
struct sock *sk = sock->sk;
struct sk_buff *skb;
size_t copied;
int err;
BT_DBG("sock %p sk %p len %zu", sock, sk, len);
if (flags & (MSG_OOB))
return -EOPNOTSUPP;
... | int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
int noblock = flags & MSG_DONTWAIT;
struct sock *sk = sock->sk;
struct sk_buff *skb;
size_t copied;
int err;
BT_DBG("sock %p sk %p len %zu", sock, sk, len);
if (flags & (MSG_OOB))
return -EOPNOTSUPP;
... | net: rework recvmsg handler msg_name and msg_namelen logic
This patch now always passes msg->msg_namelen as 0. recvmsg handlers must
set msg_namelen to the proper size <= sizeof(struct sockaddr_storage)
to return msg_name to the user.
This prevents numerous uninitialized memory leaks we had in the
recvmsg handlers an... |
015ee2ad92e9e3912c3da744 | openvul | train | train:7528 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | after | false | f3d3342602f8bcbf37d7c46641cb9bca7618eb1c | containers/f3/f3d3342602f8bcbf37d7c46641cb9bca7618eb1c_after.sif | sha256:020af4ce1a84f3dc3c890594ae316e1e1eea1c814767092e9c6db80b0ce61847 | sha256:63b1dfecd0dd9c21c0b4f83cc1f7fc5184d441886a6400615f8a6509e4dccbe0 | bt_sock_recvmsg | int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
int noblock = flags & MSG_DONTWAIT;
struct sock *sk = sock->sk;
struct sk_buff *skb;
size_t copied;
int err;
BT_DBG("sock %p sk %p len %zu", sock, sk, len);
if (flags & (MSG_OOB))
return -EOPNOTSUPP;
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/bluetooth/af_bluetooth.c | [
"CVE-2013-7270"
] | The packet_recvmsg function in net/packet/af_packet.c in the Linux kernel before 3.12.4 updates a certain length value before ensuring that an associated data structure has been initialized, which allows local users to obtain sensitive information from kernel memory via a (1) recvfrom, (2) recvmmsg, or (3) recvmsg syst... | [
"CWE-20"
] | null | null | int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
int noblock = flags & MSG_DONTWAIT;
struct sock *sk = sock->sk;
struct sk_buff *skb;
size_t copied;
int err;
BT_DBG("sock %p sk %p len %zu", sock, sk, len);
if (flags & (MSG_OOB))
return -EOPNOTSUPP;
... | int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len, int flags)
{
int noblock = flags & MSG_DONTWAIT;
struct sock *sk = sock->sk;
struct sk_buff *skb;
size_t copied;
int err;
BT_DBG("sock %p sk %p len %zu", sock, sk, len);
if (flags & (MSG_OOB))
return -EOPNOTSUPP;
... | net: rework recvmsg handler msg_name and msg_namelen logic
This patch now always passes msg->msg_namelen as 0. recvmsg handlers must
set msg_namelen to the proper size <= sizeof(struct sockaddr_storage)
to return msg_name to the user.
This prevents numerous uninitialized memory leaks we had in the
recvmsg handlers an... |
0163d1efb353d561f7553ac3 | openvul | train | train:3642 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow/commit/7bdf50bb4f5c54a4997c379092888546c97c3ebd | 7bdf50bb4f5c54a4997c379092888546c97c3ebd | before | true | a21a1226a1dbc08e257e4344324d5881fbd95d4e | containers/7b/7bdf50bb4f5c54a4997c379092888546c97c3ebd_before.sif | sha256:c3b386e2256118fefe90c2d84d52a75fd645e2444aeb6ab00e6fe824af484bb4 | sha256:3a169ef2a16ed6072dd53e1b3936219603d40fa60b3040a3a773efe421771dc9 | UncompressElementOp::Compute | void UncompressElementOp::Compute(OpKernelContext* ctx) {
Tensor tensor = ctx->input(0);
const Variant& variant = tensor.scalar<Variant>()();
const CompressedElement* compressed = variant.get<CompressedElement>();
std::vector<Tensor> components;
OP_REQUIRES_OK(ctx, UncompressElement(*compressed, &components))... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | tensorflow/core/kernels/data/experimental/compression_ops.cc | [
"CVE-2021-37649"
] | TensorFlow is an end-to-end open source platform for machine learning. The code for `tf.raw_ops.UncompressElement` can be made to trigger a null pointer dereference. The [implementation](https://github.com/tensorflow/tensorflow/blob/f24faa153ad31a4b51578f8181d3aaab77a1ddeb/tensorflow/core/kernels/data/experimental/comp... | [
"CWE-476"
] | null | null | void UncompressElementOp::Compute(OpKernelContext* ctx) {
Tensor tensor = ctx->input(0);
const Variant& variant = tensor.scalar<Variant>()();
const CompressedElement* compressed = variant.get<CompressedElement>();
std::vector<Tensor> components;
OP_REQUIRES_OK(ctx, UncompressElement(*compressed, &components))... | void UncompressElementOp::Compute(OpKernelContext* ctx) {
Tensor tensor = ctx->input(0);
const Variant& variant = tensor.scalar<Variant>()();
const CompressedElement* compressed = variant.get<CompressedElement>();
OP_REQUIRES(
ctx, compressed != nullptr,
errors::InvalidArgument(
"Input doe... | Ensure non-empty compressed input in tf.raw_ops.UncompressElement
PiperOrigin-RevId: 383955815
Change-Id: I072a84fd02738dd2f51b3f42836ed80067dba4a8 |
0163d1efb353d561f7553ac3 | openvul | train | train:3642 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow | https://github.com/tensorflow/tensorflow/commit/7bdf50bb4f5c54a4997c379092888546c97c3ebd | 7bdf50bb4f5c54a4997c379092888546c97c3ebd | after | false | 7bdf50bb4f5c54a4997c379092888546c97c3ebd | containers/7b/7bdf50bb4f5c54a4997c379092888546c97c3ebd_after.sif | sha256:f6ec7619cc2ca2a43b60719bffd78666622eabde850e9bc003685da87165a351 | sha256:1244ef933fcd8810f2b3d0a6530faaf7832dedaf8640caeb611566e5c46e400f | UncompressElementOp::Compute | void UncompressElementOp::Compute(OpKernelContext* ctx) {
Tensor tensor = ctx->input(0);
const Variant& variant = tensor.scalar<Variant>()();
const CompressedElement* compressed = variant.get<CompressedElement>();
OP_REQUIRES(
ctx, compressed != nullptr,
errors::InvalidArgument(
"Input doe... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | tensorflow/core/kernels/data/experimental/compression_ops.cc | [
"CVE-2021-37649"
] | TensorFlow is an end-to-end open source platform for machine learning. The code for `tf.raw_ops.UncompressElement` can be made to trigger a null pointer dereference. The [implementation](https://github.com/tensorflow/tensorflow/blob/f24faa153ad31a4b51578f8181d3aaab77a1ddeb/tensorflow/core/kernels/data/experimental/comp... | [
"CWE-476"
] | null | null | void UncompressElementOp::Compute(OpKernelContext* ctx) {
Tensor tensor = ctx->input(0);
const Variant& variant = tensor.scalar<Variant>()();
const CompressedElement* compressed = variant.get<CompressedElement>();
std::vector<Tensor> components;
OP_REQUIRES_OK(ctx, UncompressElement(*compressed, &components))... | void UncompressElementOp::Compute(OpKernelContext* ctx) {
Tensor tensor = ctx->input(0);
const Variant& variant = tensor.scalar<Variant>()();
const CompressedElement* compressed = variant.get<CompressedElement>();
OP_REQUIRES(
ctx, compressed != nullptr,
errors::InvalidArgument(
"Input doe... | Ensure non-empty compressed input in tf.raw_ops.UncompressElement
PiperOrigin-RevId: 383955815
Change-Id: I072a84fd02738dd2f51b3f42836ed80067dba4a8 |
01671babdceb08e0994c323a | openvul | train | train:18532 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/0660e08731fd42076d7242068e9eaed1482b14d5 | 0660e08731fd42076d7242068e9eaed1482b14d5 | before | true | 1ad0791810d6bde1bac5faa11380836caddbc944 | containers/06/0660e08731fd42076d7242068e9eaed1482b14d5_before.sif | sha256:d0801d72ee61cb1a8b5d63142e4cd22f1931a206591b746574e4ad60b5b1cf39 | sha256:bf72b0a4a4d43f7625ce8b94d075d4acc309d68b86dfb1fb298083422f809371 | TabsCaptureVisibleTabFunction::GetWebContentsForID | WebContents* TabsCaptureVisibleTabFunction::GetWebContentsForID(
int window_id,
std::string* error) {
Browser* browser = NULL;
if (!GetBrowserFromWindowID(chrome_details_, window_id, &browser, error))
return nullptr;
WebContents* contents = browser->tab_strip_model()->GetActiveWebContents();
if (!co... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | chrome/browser/extensions/api/tabs/tabs_api.cc | [
"CVE-2019-5838"
] | Insufficient policy enforcement in extensions API in Google Chrome prior to 75.0.3770.80 allowed an attacker who convinced a user to install a malicious extension to bypass restrictions on file URIs via a crafted Chrome Extension. | [
"CWE-20"
] | null | null | WebContents* TabsCaptureVisibleTabFunction::GetWebContentsForID(
int window_id,
std::string* error) {
Browser* browser = NULL;
if (!GetBrowserFromWindowID(chrome_details_, window_id, &browser, error))
return nullptr;
WebContents* contents = browser->tab_strip_model()->GetActiveWebContents();
if (!co... | WebContents* TabsCaptureVisibleTabFunction::GetWebContentsForID(
int window_id,
std::string* error) {
Browser* browser = NULL;
if (!GetBrowserFromWindowID(chrome_details_, window_id, &browser, error))
return nullptr;
WebContents* contents = browser->tab_strip_model()->GetActiveWebContents();
if (!co... | Call CanCaptureVisiblePage in page capture API.
Currently the pageCapture permission allows access
to arbitrary local files and chrome:// pages which
can be a security concern. In order to address this,
the page capture API needs to be changed similar to
the captureVisibleTab API. The API will now only allow
extension... |
01671babdceb08e0994c323a | openvul | train | train:18532 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/0660e08731fd42076d7242068e9eaed1482b14d5 | 0660e08731fd42076d7242068e9eaed1482b14d5 | after | false | 0660e08731fd42076d7242068e9eaed1482b14d5 | containers/06/0660e08731fd42076d7242068e9eaed1482b14d5_after.sif | sha256:5a410e4a56cf5c647070a9d0438c66079a4d15cc4c20f2bb66af062f1394e5ea | sha256:3940f7e522129c49382b111da28ee4579e7cebcda3b1b431ffa6e14062ec8f60 | TabsCaptureVisibleTabFunction::GetWebContentsForID | WebContents* TabsCaptureVisibleTabFunction::GetWebContentsForID(
int window_id,
std::string* error) {
Browser* browser = NULL;
if (!GetBrowserFromWindowID(chrome_details_, window_id, &browser, error))
return nullptr;
WebContents* contents = browser->tab_strip_model()->GetActiveWebContents();
if (!co... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | chrome/browser/extensions/api/tabs/tabs_api.cc | [
"CVE-2019-5838"
] | Insufficient policy enforcement in extensions API in Google Chrome prior to 75.0.3770.80 allowed an attacker who convinced a user to install a malicious extension to bypass restrictions on file URIs via a crafted Chrome Extension. | [
"CWE-20"
] | null | null | WebContents* TabsCaptureVisibleTabFunction::GetWebContentsForID(
int window_id,
std::string* error) {
Browser* browser = NULL;
if (!GetBrowserFromWindowID(chrome_details_, window_id, &browser, error))
return nullptr;
WebContents* contents = browser->tab_strip_model()->GetActiveWebContents();
if (!co... | WebContents* TabsCaptureVisibleTabFunction::GetWebContentsForID(
int window_id,
std::string* error) {
Browser* browser = NULL;
if (!GetBrowserFromWindowID(chrome_details_, window_id, &browser, error))
return nullptr;
WebContents* contents = browser->tab_strip_model()->GetActiveWebContents();
if (!co... | Call CanCaptureVisiblePage in page capture API.
Currently the pageCapture permission allows access
to arbitrary local files and chrome:// pages which
can be a security concern. In order to address this,
the page capture API needs to be changed similar to
the captureVisibleTab API. The API will now only allow
extension... |
017551280b240445e07a2e09 | openvul | train | train:18848 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | Android | https://android.googlesource.com/platform/frameworks/base/+/4cff1f49ff95d990d6c2614da5d5a23d02145885 | https://android.googlesource.com/platform/frameworks/base | https://android.googlesource.com/platform/frameworks/base/+/4cff1f49ff95d990d6c2614da5d5a23d02145885%5E%21/#F0 | 4cff1f49ff95d990d6c2614da5d5a23d02145885 | before | true | a5e904e7eb3aaec532de83ca52e24af18e0496b4 | containers/4c/4cff1f49ff95d990d6c2614da5d5a23d02145885_before.sif | sha256:efc5e5b84ee568e66fa71ccc4e4c00deb3a07e8b6b9faab0dfff42df7fb20f47 | sha256:9df52b819a29e1019567bdf22821f3236cd1fd4fa3e3115972ea9b57bb7b7b8b | Region_createFromParcel | static jlong Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel)
{
if (parcel == NULL) {
return NULL;
}
android::Parcel* p = android::parcelForJavaObject(env, parcel);
SkRegion* region = new SkRegion;
size_t size = p->readInt32();
region->readFromMemory(p->readInplace(size), size);
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | core/jni/android/graphics/Region.cpp | [
"CVE-2015-3849"
] | The Region_createFromParcel function in core/jni/android/graphics/Region.cpp in Region in Android before 5.1.1 LMY48M does not check the return values of certain read operations, which allows attackers to execute arbitrary code via an application that sends a crafted message to a service, aka internal bug 21585255. | [
"CWE-690"
] | null | null | static jlong Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel)
{
if (parcel == NULL) {
return NULL;
}
android::Parcel* p = android::parcelForJavaObject(env, parcel);
SkRegion* region = new SkRegion;
size_t size = p->readInt32();
region->readFromMemory(p->readInplace(size), size);
... | static jlong Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel)
{
if (parcel == NULL) {
return NULL;
}
android::Parcel* p = android::parcelForJavaObject(env, parcel);
const size_t size = p->readInt32();
const void* regionData = p->readInplace(size);
if (regionData == NULL) {
... | Check that the parcel contained the expected amount of region data. DO NOT MERGE
bug:20883006
Change-Id: Ib47a8ec8696dbc37e958b8dbceb43fcbabf6605b |
017551280b240445e07a2e09 | openvul | train | train:18848 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | Android | https://android.googlesource.com/platform/frameworks/base/+/4cff1f49ff95d990d6c2614da5d5a23d02145885 | https://android.googlesource.com/platform/frameworks/base | https://android.googlesource.com/platform/frameworks/base/+/4cff1f49ff95d990d6c2614da5d5a23d02145885%5E%21/#F0 | 4cff1f49ff95d990d6c2614da5d5a23d02145885 | after | false | 4cff1f49ff95d990d6c2614da5d5a23d02145885 | containers/4c/4cff1f49ff95d990d6c2614da5d5a23d02145885_after.sif | sha256:734c4dd1389a97d84cc753fcc4936d27f9e8fc0826feec91d3396be9be31cc56 | sha256:69a701f87bc36dd5cb7926bfc0f428919808286702e4d176410b1ebd8172ca44 | Region_createFromParcel | static jlong Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel)
{
if (parcel == NULL) {
return NULL;
}
android::Parcel* p = android::parcelForJavaObject(env, parcel);
const size_t size = p->readInt32();
const void* regionData = p->readInplace(size);
if (regionData == NULL) {
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | core/jni/android/graphics/Region.cpp | [
"CVE-2015-3849"
] | The Region_createFromParcel function in core/jni/android/graphics/Region.cpp in Region in Android before 5.1.1 LMY48M does not check the return values of certain read operations, which allows attackers to execute arbitrary code via an application that sends a crafted message to a service, aka internal bug 21585255. | [
"CWE-690"
] | null | null | static jlong Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel)
{
if (parcel == NULL) {
return NULL;
}
android::Parcel* p = android::parcelForJavaObject(env, parcel);
SkRegion* region = new SkRegion;
size_t size = p->readInt32();
region->readFromMemory(p->readInplace(size), size);
... | static jlong Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel)
{
if (parcel == NULL) {
return NULL;
}
android::Parcel* p = android::parcelForJavaObject(env, parcel);
const size_t size = p->readInt32();
const void* regionData = p->readInplace(size);
if (regionData == NULL) {
... | Check that the parcel contained the expected amount of region data. DO NOT MERGE
bug:20883006
Change-Id: Ib47a8ec8696dbc37e958b8dbceb43fcbabf6605b |
0180048e8e260c5ba7685342 | openvul | train | train:4336 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5872331b3d91820e14716632ebb56b1399b34fe1 | 5872331b3d91820e14716632ebb56b1399b34fe1 | before | true | 24dc9864914eb5813173cfa53313fcd02e4aea7d | containers/58/5872331b3d91820e14716632ebb56b1399b34fe1_before.sif | sha256:e01dc18654aaa9e4ae707113a608bf499eaa71d3f77ceefe23f962e409954c11 | sha256:9b1b3f263eb093b42e7fb5ab2da8e7bf576aa10a2aaf9bce46ea44ee13be98d3 | do_split | static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
struct buffer_head **bh,struct dx_frame *frame,
struct dx_hash_info *hinfo)
{
unsigned blocksize = dir->i_sb->s_blocksize;
unsigned count, continued;
struct buffer_head *bh2;
ext4_lblk_t newblock;
u32 hash2;
struct dx_map_entry *m... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | fs/ext4/namei.c | [
"CVE-2020-14314"
] | A memory out-of-bounds read flaw was found in the Linux kernel before 5.9-rc2 with the ext3/ext4 file system, in the way it accesses a directory with broken indexing. This flaw allows a local user to crash the system if the directory exists. The highest threat from this vulnerability is to system availability. | [
"CWE-125"
] | null | null | static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
struct buffer_head **bh,struct dx_frame *frame,
struct dx_hash_info *hinfo)
{
unsigned blocksize = dir->i_sb->s_blocksize;
unsigned count, continued;
struct buffer_head *bh2;
ext4_lblk_t newblock;
u32 hash2;
struct dx_map_entry *m... | static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
struct buffer_head **bh,struct dx_frame *frame,
struct dx_hash_info *hinfo)
{
unsigned blocksize = dir->i_sb->s_blocksize;
unsigned count, continued;
struct buffer_head *bh2;
ext4_lblk_t newblock;
u32 hash2;
struct dx_map_entry *m... | ext4: fix potential negative array index in do_split()
If for any reason a directory passed to do_split() does not have enough
active entries to exceed half the size of the block, we can end up
iterating over all "count" entries without finding a split point.
In this case, count == move, and split will be zero, and w... |
0180048e8e260c5ba7685342 | openvul | train | train:4336 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/5872331b3d91820e14716632ebb56b1399b34fe1 | 5872331b3d91820e14716632ebb56b1399b34fe1 | after | false | 5872331b3d91820e14716632ebb56b1399b34fe1 | containers/58/5872331b3d91820e14716632ebb56b1399b34fe1_after.sif | sha256:83fa9d93d7107063ee1830f91d7002471773398b00833e208476dfcb70bbd666 | sha256:c7c4aa120af81b92679fcfeebdb0b5cf6f73a014649680c2ea8e9ed2af5ca73d | do_split | static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
struct buffer_head **bh,struct dx_frame *frame,
struct dx_hash_info *hinfo)
{
unsigned blocksize = dir->i_sb->s_blocksize;
unsigned count, continued;
struct buffer_head *bh2;
ext4_lblk_t newblock;
u32 hash2;
struct dx_map_entry *m... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | fs/ext4/namei.c | [
"CVE-2020-14314"
] | A memory out-of-bounds read flaw was found in the Linux kernel before 5.9-rc2 with the ext3/ext4 file system, in the way it accesses a directory with broken indexing. This flaw allows a local user to crash the system if the directory exists. The highest threat from this vulnerability is to system availability. | [
"CWE-125"
] | null | null | static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
struct buffer_head **bh,struct dx_frame *frame,
struct dx_hash_info *hinfo)
{
unsigned blocksize = dir->i_sb->s_blocksize;
unsigned count, continued;
struct buffer_head *bh2;
ext4_lblk_t newblock;
u32 hash2;
struct dx_map_entry *m... | static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
struct buffer_head **bh,struct dx_frame *frame,
struct dx_hash_info *hinfo)
{
unsigned blocksize = dir->i_sb->s_blocksize;
unsigned count, continued;
struct buffer_head *bh2;
ext4_lblk_t newblock;
u32 hash2;
struct dx_map_entry *m... | ext4: fix potential negative array index in do_split()
If for any reason a directory passed to do_split() does not have enough
active entries to exceed half the size of the block, we can end up
iterating over all "count" entries without finding a split point.
In this case, count == move, and split will be zero, and w... |
0187589d6911799146b187c6 | openvul | train | train:13082 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | leptonica | https://github.com/DanBloomberg/leptonica | https://github.com/DanBloomberg/leptonica | https://github.com/DanBloomberg/leptonica/commit/3c18c43b6a3f753f0dfff99610d46ad46b8bfac4 | 3c18c43b6a3f753f0dfff99610d46ad46b8bfac4 | before | true | cf6ba577e1af60e88034b8090a9a5d82e7f88298 | containers/3c/3c18c43b6a3f753f0dfff99610d46ad46b8bfac4_before.sif | sha256:1f8631f9bb903ada5e68f9c382b40f21961f61090fcb875aa9051d6561be3835 | sha256:37b3b8ab27ea6e96d82c64279cebda8f9973e65351ee421ccd8fbd7b85e98178 | main | int main(int argc,
char **argv)
{
l_int32 w, h;
PIX *pixs, *pixg, *pixim, *pixgm, *pixmi, *pix1, *pix2;
PIX *pixmr, *pixmg, *pixmb, *pixmri, *pixmgi, *pixmbi;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/adapt"); ... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | prog/adaptmap_reg.c | [
"CVE-2020-36279"
] | Leptonica before 1.80.0 allows a heap-based buffer over-read in rasteropGeneralLow, related to adaptmap_reg.c and adaptmap.c. | [
"CWE-125"
] | null | null | int main(int argc,
char **argv)
{
l_int32 w, h;
PIX *pixs, *pixg, *pixim, *pixgm, *pixmi, *pix1, *pix2;
PIX *pixmr, *pixmg, *pixmb, *pixmri, *pixmgi, *pixmbi;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/adapt"); ... | int main(int argc,
char **argv)
{
l_int32 w, h;
PIX *pixs, *pixg, *pixim, *pixgm, *pixmi, *pix1, *pix2;
PIX *pixmr, *pixmg, *pixmb, *pixmri, *pixmgi, *pixmbi;
PIXA *pixa, *pixa2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/a... | Fixing oss-fuzz issue 22512: Heap-buffer-overflow in rasteropGeneralLow()
* Simplified the hole-filling function
` |
0187589d6911799146b187c6 | openvul | train | train:13082 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | leptonica | https://github.com/DanBloomberg/leptonica | https://github.com/DanBloomberg/leptonica | https://github.com/DanBloomberg/leptonica/commit/3c18c43b6a3f753f0dfff99610d46ad46b8bfac4 | 3c18c43b6a3f753f0dfff99610d46ad46b8bfac4 | after | false | 3c18c43b6a3f753f0dfff99610d46ad46b8bfac4 | containers/3c/3c18c43b6a3f753f0dfff99610d46ad46b8bfac4_after.sif | sha256:59c6b3cec7daa9a8011c237d535cd7e70ecf452be6d5c701c71b055033c3c78e | sha256:7102a9b2475a4489551176ef6dfdd5d8968c66368225f430d2a34755ffa2beac | main | int main(int argc,
char **argv)
{
l_int32 w, h;
PIX *pixs, *pixg, *pixim, *pixgm, *pixmi, *pix1, *pix2;
PIX *pixmr, *pixmg, *pixmb, *pixmri, *pixmgi, *pixmbi;
PIXA *pixa, *pixa2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/a... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | prog/adaptmap_reg.c | [
"CVE-2020-36279"
] | Leptonica before 1.80.0 allows a heap-based buffer over-read in rasteropGeneralLow, related to adaptmap_reg.c and adaptmap.c. | [
"CWE-125"
] | null | null | int main(int argc,
char **argv)
{
l_int32 w, h;
PIX *pixs, *pixg, *pixim, *pixgm, *pixmi, *pix1, *pix2;
PIX *pixmr, *pixmg, *pixmb, *pixmri, *pixmgi, *pixmbi;
PIXA *pixa;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/adapt"); ... | int main(int argc,
char **argv)
{
l_int32 w, h;
PIX *pixs, *pixg, *pixim, *pixgm, *pixmi, *pix1, *pix2;
PIX *pixmr, *pixmg, *pixmb, *pixmri, *pixmgi, *pixmbi;
PIXA *pixa, *pixa2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/a... | Fixing oss-fuzz issue 22512: Heap-buffer-overflow in rasteropGeneralLow()
* Simplified the hole-filling function
` |
0194d1522ea00bf599c507be | openvul | train | train:14040 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | openenclave | https://github.com/openenclave/openenclave | https://github.com/openenclave/openenclave | https://github.com/openenclave/openenclave/commit/bcac8e7acb514429fee9e0b5d0c7a0308fd4d76b | bcac8e7acb514429fee9e0b5d0c7a0308fd4d76b | before | true | 10186a4db8e0ec187a404366c9af142c2e4a9d25 | containers/bc/bcac8e7acb514429fee9e0b5d0c7a0308fd4d76b_before.sif | sha256:24bb2a777e964382daffcd41412dc70ca2c9897b363e445bb26b533bd4aae2c8 | sha256:d4caf3a2b16778c2777f1cce3b67689611a75569eaf0ccb5e402b3af16291d03 | _hostfs_write | static ssize_t _hostfs_write(oe_fd_t* desc, const void* buf, size_t count)
{
ssize_t ret = -1;
file_t* file = _cast_file(desc);
if (!file || (count && !buf))
OE_RAISE_ERRNO(OE_EINVAL);
if (oe_syscall_write_ocall(&ret, file->host_fd, buf, count) != OE_OK)
OE_RAISE_ERRNO(OE_EINVAL);
done:
... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | syscall/devices/hostfs/hostfs.c | [
"CVE-2020-15224"
] | In Open Enclave before version 0.12.0, an information disclosure vulnerability exists when an enclave application using the syscalls provided by the sockets.edl is loaded by a malicious host application. An attacker who successfully exploited the vulnerability could read privileged data from the enclave heap across tru... | [
"CWE-125"
] | null | null | static ssize_t _hostfs_write(oe_fd_t* desc, const void* buf, size_t count)
{
ssize_t ret = -1;
file_t* file = _cast_file(desc);
if (!file || (count && !buf))
OE_RAISE_ERRNO(OE_EINVAL);
if (oe_syscall_write_ocall(&ret, file->host_fd, buf, count) != OE_OK)
OE_RAISE_ERRNO(OE_EINVAL);
done:
... | static ssize_t _hostfs_write(oe_fd_t* desc, const void* buf, size_t count)
{
ssize_t ret = -1;
file_t* file = _cast_file(desc);
if (!file || (count && !buf) || count > OE_SSIZE_MAX)
OE_RAISE_ERRNO(OE_EINVAL);
if (oe_syscall_write_ocall(&ret, file->host_fd, buf, count) != OE_OK)
OE_RAISE_... | Merge pull request from GHSA-525h-wxcc-f66m
Signed-off-by: Ming-Wei Shih <mishih@microsoft.com> |
0194d1522ea00bf599c507be | openvul | train | train:14040 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | openenclave | https://github.com/openenclave/openenclave | https://github.com/openenclave/openenclave | https://github.com/openenclave/openenclave/commit/bcac8e7acb514429fee9e0b5d0c7a0308fd4d76b | bcac8e7acb514429fee9e0b5d0c7a0308fd4d76b | after | false | bcac8e7acb514429fee9e0b5d0c7a0308fd4d76b | containers/bc/bcac8e7acb514429fee9e0b5d0c7a0308fd4d76b_after.sif | sha256:3b0c8fd5d4be148fe0adc97755975a7dddd89d3002f30395efc44902043fed0e | sha256:6393ca144dd929c5662a5eb9d24dce3f38f6921830ac67f9d0aba7f5a474ad64 | _hostfs_write | static ssize_t _hostfs_write(oe_fd_t* desc, const void* buf, size_t count)
{
ssize_t ret = -1;
file_t* file = _cast_file(desc);
if (!file || (count && !buf) || count > OE_SSIZE_MAX)
OE_RAISE_ERRNO(OE_EINVAL);
if (oe_syscall_write_ocall(&ret, file->host_fd, buf, count) != OE_OK)
OE_RAISE_... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | syscall/devices/hostfs/hostfs.c | [
"CVE-2020-15224"
] | In Open Enclave before version 0.12.0, an information disclosure vulnerability exists when an enclave application using the syscalls provided by the sockets.edl is loaded by a malicious host application. An attacker who successfully exploited the vulnerability could read privileged data from the enclave heap across tru... | [
"CWE-125"
] | null | null | static ssize_t _hostfs_write(oe_fd_t* desc, const void* buf, size_t count)
{
ssize_t ret = -1;
file_t* file = _cast_file(desc);
if (!file || (count && !buf))
OE_RAISE_ERRNO(OE_EINVAL);
if (oe_syscall_write_ocall(&ret, file->host_fd, buf, count) != OE_OK)
OE_RAISE_ERRNO(OE_EINVAL);
done:
... | static ssize_t _hostfs_write(oe_fd_t* desc, const void* buf, size_t count)
{
ssize_t ret = -1;
file_t* file = _cast_file(desc);
if (!file || (count && !buf) || count > OE_SSIZE_MAX)
OE_RAISE_ERRNO(OE_EINVAL);
if (oe_syscall_write_ocall(&ret, file->host_fd, buf, count) != OE_OK)
OE_RAISE_... | Merge pull request from GHSA-525h-wxcc-f66m
Signed-off-by: Ming-Wei Shih <mishih@microsoft.com> |
0195de656c3614f1120b85cb | openvul | train | train:16188 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | ImageMagick | https://github.com/ImageMagick/ImageMagick | https://github.com/ImageMagick/ImageMagick | https://github.com/ImageMagick/ImageMagick/commit/d4ec73f866a7c42a2e7f301fcd696e5cb7a7d3ab | d4ec73f866a7c42a2e7f301fcd696e5cb7a7d3ab | before | true | eadf2e4228c9d6d304be077414817fe6335c7e14 | containers/d4/d4ec73f866a7c42a2e7f301fcd696e5cb7a7d3ab_before.sif | sha256:db196a24c18c3a8c6ad8fb14630156692212d48027525ff9e2bb4f48da2719f3 | sha256:4d323e7ff7f5c248a7c44a6310d9ede2de1d2da4ad50d44fdb07e74f9e82c8ca | WritePSDChannels | static size_t WritePSDChannels(const PSDInfo *psd_info,
const ImageInfo *image_info,Image *image,Image *next_image,
MagickOffsetType size_offset,const MagickBooleanType separate,
ExceptionInfo *exception)
{
Image
*mask;
MagickOffsetType
rows_offset;
size_t
channels,
count,
length,
of... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | coders/psd.c | [
"CVE-2017-5509"
] | coders/psd.c in ImageMagick allows remote attackers to have unspecified impact via a crafted PSD file, which triggers an out-of-bounds write. | [
"CWE-787"
] | null | null | static size_t WritePSDChannels(const PSDInfo *psd_info,
const ImageInfo *image_info,Image *image,Image *next_image,
MagickOffsetType size_offset,const MagickBooleanType separate,
ExceptionInfo *exception)
{
Image
*mask;
MagickOffsetType
rows_offset;
size_t
channels,
count,
length,
of... | static size_t WritePSDChannels(const PSDInfo *psd_info,
const ImageInfo *image_info,Image *image,Image *next_image,
MagickOffsetType size_offset,const MagickBooleanType separate,
ExceptionInfo *exception)
{
Image
*mask;
MagickOffsetType
rows_offset;
size_t
channels,
count,
length,
of... | https://github.com/ImageMagick/ImageMagick/issues/350 |
0195de656c3614f1120b85cb | openvul | train | train:16188 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | ImageMagick | https://github.com/ImageMagick/ImageMagick | https://github.com/ImageMagick/ImageMagick | https://github.com/ImageMagick/ImageMagick/commit/d4ec73f866a7c42a2e7f301fcd696e5cb7a7d3ab | d4ec73f866a7c42a2e7f301fcd696e5cb7a7d3ab | after | false | d4ec73f866a7c42a2e7f301fcd696e5cb7a7d3ab | containers/d4/d4ec73f866a7c42a2e7f301fcd696e5cb7a7d3ab_after.sif | sha256:51e810bfeaf861e5c9f6e1a6fe091d34a2689a3183ea68a6168da31ab92729bd | sha256:ea83cc7ad13f4ae0b8aee967e6426be09fc9a1c79a790cdcacb9dcb1af496a0e | WritePSDChannels | static size_t WritePSDChannels(const PSDInfo *psd_info,
const ImageInfo *image_info,Image *image,Image *next_image,
MagickOffsetType size_offset,const MagickBooleanType separate,
ExceptionInfo *exception)
{
Image
*mask;
MagickOffsetType
rows_offset;
size_t
channels,
count,
length,
of... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | coders/psd.c | [
"CVE-2017-5509"
] | coders/psd.c in ImageMagick allows remote attackers to have unspecified impact via a crafted PSD file, which triggers an out-of-bounds write. | [
"CWE-787"
] | null | null | static size_t WritePSDChannels(const PSDInfo *psd_info,
const ImageInfo *image_info,Image *image,Image *next_image,
MagickOffsetType size_offset,const MagickBooleanType separate,
ExceptionInfo *exception)
{
Image
*mask;
MagickOffsetType
rows_offset;
size_t
channels,
count,
length,
of... | static size_t WritePSDChannels(const PSDInfo *psd_info,
const ImageInfo *image_info,Image *image,Image *next_image,
MagickOffsetType size_offset,const MagickBooleanType separate,
ExceptionInfo *exception)
{
Image
*mask;
MagickOffsetType
rows_offset;
size_t
channels,
count,
length,
of... | https://github.com/ImageMagick/ImageMagick/issues/350 |
0197402fa8bcea0850de0b70 | openvul | train | train:18558 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/2f81d000fdb5331121cba7ff81dfaaec25b520a5 | 2f81d000fdb5331121cba7ff81dfaaec25b520a5 | before | true | 6aff2928bf6a19ea5069ae38405704c377aff56e | containers/2f/2f81d000fdb5331121cba7ff81dfaaec25b520a5_before.sif | sha256:e80fbf54a92990c6606c307e52cd730be1b6db8a00e0cb75a99ea328e7616f80 | sha256:96ad85529fddb02c5fd7340bea311e6d5f98012bdf062754029d7aa366c0598b | DownloadManagerImpl::BeginDownloadRequest | download::DownloadInterruptReason DownloadManagerImpl::BeginDownloadRequest(
std::unique_ptr<net::URLRequest> url_request,
ResourceContext* resource_context,
download::DownloadUrlParameters* params) {
if (ResourceDispatcherHostImpl::Get()->is_shutdown())
return download::DOWNLOAD_INTERRUPT_REASON_USER... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | content/browser/download/download_manager_impl.cc | [
"CVE-2019-5822"
] | Inappropriate implementation in Blink in Google Chrome prior to 74.0.3729.108 allowed a remote attacker to bypass same origin policy via a crafted HTML page. | [
"CWE-284"
] | null | null | download::DownloadInterruptReason DownloadManagerImpl::BeginDownloadRequest(
std::unique_ptr<net::URLRequest> url_request,
ResourceContext* resource_context,
download::DownloadUrlParameters* params) {
if (ResourceDispatcherHostImpl::Get()->is_shutdown())
return download::DOWNLOAD_INTERRUPT_REASON_USER... | download::DownloadInterruptReason DownloadManagerImpl::BeginDownloadRequest(
std::unique_ptr<net::URLRequest> url_request,
ResourceContext* resource_context,
download::DownloadUrlParameters* params) {
if (ResourceDispatcherHostImpl::Get()->is_shutdown())
return download::DOWNLOAD_INTERRUPT_REASON_USER... | When turning a download into a navigation, navigate the right frame
Code changes from Nate Chapin <japhet@chromium.org>
Bug: 926105
Change-Id: I098599394e6ebe7d2fce5af838014297a337d294
Reviewed-on: https://chromium-review.googlesource.com/c/1454962
Reviewed-by: Camille Lamy <clamy@chromium.org>
Commit-Queue: Jochen E... |
0197402fa8bcea0850de0b70 | openvul | train | train:18558 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/2f81d000fdb5331121cba7ff81dfaaec25b520a5 | 2f81d000fdb5331121cba7ff81dfaaec25b520a5 | after | false | 2f81d000fdb5331121cba7ff81dfaaec25b520a5 | containers/2f/2f81d000fdb5331121cba7ff81dfaaec25b520a5_after.sif | sha256:d3c016526a119aea41c6690a0d5f93bffd51e74b6a8db02e4ac820f248de6a16 | sha256:d3d20da146c02b79e73d0cc5e2f94a3ff9a51b95bc21376f19035bbf0c09d30d | DownloadManagerImpl::BeginDownloadRequest | download::DownloadInterruptReason DownloadManagerImpl::BeginDownloadRequest(
std::unique_ptr<net::URLRequest> url_request,
ResourceContext* resource_context,
download::DownloadUrlParameters* params) {
if (ResourceDispatcherHostImpl::Get()->is_shutdown())
return download::DOWNLOAD_INTERRUPT_REASON_USER... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | content/browser/download/download_manager_impl.cc | [
"CVE-2019-5822"
] | Inappropriate implementation in Blink in Google Chrome prior to 74.0.3729.108 allowed a remote attacker to bypass same origin policy via a crafted HTML page. | [
"CWE-284"
] | null | null | download::DownloadInterruptReason DownloadManagerImpl::BeginDownloadRequest(
std::unique_ptr<net::URLRequest> url_request,
ResourceContext* resource_context,
download::DownloadUrlParameters* params) {
if (ResourceDispatcherHostImpl::Get()->is_shutdown())
return download::DOWNLOAD_INTERRUPT_REASON_USER... | download::DownloadInterruptReason DownloadManagerImpl::BeginDownloadRequest(
std::unique_ptr<net::URLRequest> url_request,
ResourceContext* resource_context,
download::DownloadUrlParameters* params) {
if (ResourceDispatcherHostImpl::Get()->is_shutdown())
return download::DOWNLOAD_INTERRUPT_REASON_USER... | When turning a download into a navigation, navigate the right frame
Code changes from Nate Chapin <japhet@chromium.org>
Bug: 926105
Change-Id: I098599394e6ebe7d2fce5af838014297a337d294
Reviewed-on: https://chromium-review.googlesource.com/c/1454962
Reviewed-by: Camille Lamy <clamy@chromium.org>
Commit-Queue: Jochen E... |
019aa599e90b450e07e901a8 | openvul | train | train:9804 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | git | https://github.com/git/git | https://github.com/git/git | https://github.com/git/git/commit/de1e67d0703894cb6ea782e36abb63976ab07e60 | de1e67d0703894cb6ea782e36abb63976ab07e60 | before | true | bd64516aca4d4e22acb33c71429d293a14d355cf | containers/de/de1e67d0703894cb6ea782e36abb63976ab07e60_before.sif | sha256:81e928857e16a468d398a0a30942d2438c7855a908864104c4f3ae67770c4e01 | sha256:5fe0b15467bde5fa7765d9b228b0907b8fdd73d77e5cd047f0c05b2ef21e9082 | traverse_commit_list | void traverse_commit_list(struct rev_info *revs,
show_commit_fn show_commit,
show_object_fn show_object,
void *data)
{
int i;
struct commit *commit;
struct strbuf base;
strbuf_init(&base, PATH_MAX);
while ((commit = get_revision(revs)) != NULL) {
if (commit->tree)
add_pending_tree(revs, commit-... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | list-objects.c | [
"CVE-2016-2315"
] | revision.c in git before 2.7.4 uses an incorrect integer data type, which allows remote attackers to execute arbitrary code via a (1) long filename or (2) many nested trees, leading to a heap-based buffer overflow. | [
"CWE-119"
] | null | null | void traverse_commit_list(struct rev_info *revs,
show_commit_fn show_commit,
show_object_fn show_object,
void *data)
{
int i;
struct commit *commit;
struct strbuf base;
strbuf_init(&base, PATH_MAX);
while ((commit = get_revision(revs)) != NULL) {
if (commit->tree)
add_pending_tree(revs, commit-... | void traverse_commit_list(struct rev_info *revs,
show_commit_fn show_commit,
show_object_fn show_object,
void *data)
{
int i;
struct commit *commit;
struct strbuf base;
strbuf_init(&base, PATH_MAX);
while ((commit = get_revision(revs)) != NULL) {
if (commit->tree)
add_pending_tree(revs, commit-... | list-objects: pass full pathname to callbacks
When we find a blob at "a/b/c", we currently pass this to
our show_object_fn callbacks as two components: "a/b/" and
"c". Callbacks which want the full value then call
path_name(), which concatenates the two. But this is an
inefficient interface; the path is a strbuf, and ... |
019aa599e90b450e07e901a8 | openvul | train | train:9804 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | git | https://github.com/git/git | https://github.com/git/git | https://github.com/git/git/commit/de1e67d0703894cb6ea782e36abb63976ab07e60 | de1e67d0703894cb6ea782e36abb63976ab07e60 | after | false | de1e67d0703894cb6ea782e36abb63976ab07e60 | containers/de/de1e67d0703894cb6ea782e36abb63976ab07e60_after.sif | sha256:9b339be1279c402be6821be557a4dcc0cdc34099ac629999739da51f13b97f0d | sha256:ae32cf0c5b5f57ffbb1c7dc76b0f70d1cf60093a55643c3a43dd76d3f3e78d6b | traverse_commit_list | void traverse_commit_list(struct rev_info *revs,
show_commit_fn show_commit,
show_object_fn show_object,
void *data)
{
int i;
struct commit *commit;
struct strbuf base;
strbuf_init(&base, PATH_MAX);
while ((commit = get_revision(revs)) != NULL) {
if (commit->tree)
add_pending_tree(revs, commit-... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | list-objects.c | [
"CVE-2016-2315"
] | revision.c in git before 2.7.4 uses an incorrect integer data type, which allows remote attackers to execute arbitrary code via a (1) long filename or (2) many nested trees, leading to a heap-based buffer overflow. | [
"CWE-119"
] | null | null | void traverse_commit_list(struct rev_info *revs,
show_commit_fn show_commit,
show_object_fn show_object,
void *data)
{
int i;
struct commit *commit;
struct strbuf base;
strbuf_init(&base, PATH_MAX);
while ((commit = get_revision(revs)) != NULL) {
if (commit->tree)
add_pending_tree(revs, commit-... | void traverse_commit_list(struct rev_info *revs,
show_commit_fn show_commit,
show_object_fn show_object,
void *data)
{
int i;
struct commit *commit;
struct strbuf base;
strbuf_init(&base, PATH_MAX);
while ((commit = get_revision(revs)) != NULL) {
if (commit->tree)
add_pending_tree(revs, commit-... | list-objects: pass full pathname to callbacks
When we find a blob at "a/b/c", we currently pass this to
our show_object_fn callbacks as two components: "a/b/" and
"c". Callbacks which want the full value then call
path_name(), which concatenates the two. But this is an
inefficient interface; the path is a strbuf, and ... |
01a1ac22b0fae61af2e5b1d6 | openvul | train | train:17290 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/7f0126ff011142c8619b10a6e64d04d1745c503a | 7f0126ff011142c8619b10a6e64d04d1745c503a | before | true | 2d19039332a6c5abe0f023da096a2e5f6fd60028 | containers/7f/7f0126ff011142c8619b10a6e64d04d1745c503a_before.sif | sha256:c034ed549acadf13a9c9027a41b3ab943b5ef722617aa07c8749e7b895d57e55 | sha256:5668cb68580d8e3ebf87b3077ba1d48c50e1883b9ff8ca4747a599428011d2ba | SerializerMarkupAccumulator::appendText | void SerializerMarkupAccumulator::appendText(StringBuilder& result, Text* text)
{
Element* parent = text->parentElement();
if (parent && !shouldIgnoreElement(parent))
MarkupAccumulator::appendText(result, text);
} | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | third_party/WebKit/Source/core/page/PageSerializer.cpp | [
"CVE-2012-5157"
] | Google Chrome before 24.0.1312.52 does not properly handle image data in PDF documents, which allows remote attackers to cause a denial of service (out-of-bounds read) via a crafted document. | [
"CWE-119"
] | null | null | void SerializerMarkupAccumulator::appendText(StringBuilder& result, Text* text)
{
Element* parent = text->parentElement();
if (parent && !shouldIgnoreElement(parent))
MarkupAccumulator::appendText(result, text);
} | void SerializerMarkupAccumulator::appendText(StringBuilder& result, Text* text)
void SerializerMarkupAccumulator::appendText(StringBuilder& out, Text* text)
{
Element* parent = text->parentElement();
if (parent && !shouldIgnoreElement(parent))
MarkupAccumulator::appendText(out, text);
} | Revert 162155 "This review merges the two existing page serializ..."
Change r162155 broke the world even though it was landed using the CQ.
> This review merges the two existing page serializers, WebPageSerializerImpl and
> PageSerializer, into one, PageSerializer. In addition to this it moves all
> the old tests fro... |
01a1ac22b0fae61af2e5b1d6 | openvul | train | train:17290 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/7f0126ff011142c8619b10a6e64d04d1745c503a | 7f0126ff011142c8619b10a6e64d04d1745c503a | after | false | 7f0126ff011142c8619b10a6e64d04d1745c503a | containers/7f/7f0126ff011142c8619b10a6e64d04d1745c503a_after.sif | sha256:d9c5a1c79eb5ad4689d17a36bdfbb8e9140a57865f3d46a5933a69dd168b889e | sha256:908e7820b43fea354c74c05b7f43ecd1dcd7ecd5e1033e76ab0615bcff8cc78a | SerializerMarkupAccumulator::appendText | void SerializerMarkupAccumulator::appendText(StringBuilder& result, Text* text)
void SerializerMarkupAccumulator::appendText(StringBuilder& out, Text* text)
{
Element* parent = text->parentElement();
if (parent && !shouldIgnoreElement(parent))
MarkupAccumulator::appendText(out, text);
} | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | third_party/WebKit/Source/core/page/PageSerializer.cpp | [
"CVE-2012-5157"
] | Google Chrome before 24.0.1312.52 does not properly handle image data in PDF documents, which allows remote attackers to cause a denial of service (out-of-bounds read) via a crafted document. | [
"CWE-119"
] | null | null | void SerializerMarkupAccumulator::appendText(StringBuilder& result, Text* text)
{
Element* parent = text->parentElement();
if (parent && !shouldIgnoreElement(parent))
MarkupAccumulator::appendText(result, text);
} | void SerializerMarkupAccumulator::appendText(StringBuilder& result, Text* text)
void SerializerMarkupAccumulator::appendText(StringBuilder& out, Text* text)
{
Element* parent = text->parentElement();
if (parent && !shouldIgnoreElement(parent))
MarkupAccumulator::appendText(out, text);
} | Revert 162155 "This review merges the two existing page serializ..."
Change r162155 broke the world even though it was landed using the CQ.
> This review merges the two existing page serializers, WebPageSerializerImpl and
> PageSerializer, into one, PageSerializer. In addition to this it moves all
> the old tests fro... |
01a2703b2180ac10cf7a83c3 | openvul | train | train:7690 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/df4d92549f23e1c037e83323aff58a21b3de7fe0 | df4d92549f23e1c037e83323aff58a21b3de7fe0 | before | true | 412d2907c41531b60c7ea1f38cfe1116daf2a229 | containers/df/df4d92549f23e1c037e83323aff58a21b3de7fe0_before.sif | sha256:a31ad18f5676f51f8c58af6b14621b403e977ab0b3e5f020eedebb3d92e94bd1 | sha256:6b9a034946b455ee470bb924ed33bf2e350bd10256661bc5b4f54faf916be6ca | __mkroute_input | static int __mkroute_input(struct sk_buff *skb,
const struct fib_result *res,
struct in_device *in_dev,
__be32 daddr, __be32 saddr, u32 tos)
{
struct fib_nh_exception *fnhe;
struct rtable *rth;
int err;
struct in_device *out_dev;
unsigned int flags = 0;
bool do_cache;
u32 itag = 0;
out_dev = _... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/ipv4/route.c | [
"CVE-2015-1465"
] | The IPv4 implementation in the Linux kernel before 3.18.8 does not properly consider the length of the Read-Copy Update (RCU) grace period for redirecting lookups in the absence of caching, which allows remote attackers to cause a denial of service (memory consumption or system crash) via a flood of packets. | [
"CWE-770"
] | null | null | static int __mkroute_input(struct sk_buff *skb,
const struct fib_result *res,
struct in_device *in_dev,
__be32 daddr, __be32 saddr, u32 tos)
{
struct fib_nh_exception *fnhe;
struct rtable *rth;
int err;
struct in_device *out_dev;
unsigned int flags = 0;
bool do_cache;
u32 itag = 0;
out_dev = _... | static int __mkroute_input(struct sk_buff *skb,
const struct fib_result *res,
struct in_device *in_dev,
__be32 daddr, __be32 saddr, u32 tos)
{
struct fib_nh_exception *fnhe;
struct rtable *rth;
int err;
struct in_device *out_dev;
unsigned int flags = 0;
bool do_cache;
u32 itag = 0;
out_dev = _... | ipv4: try to cache dst_entries which would cause a redirect
Not caching dst_entries which cause redirects could be exploited by hosts
on the same subnet, causing a severe DoS attack. This effect aggravated
since commit f88649721268999 ("ipv4: fix dst race in sk_dst_get()").
Lookups causing redirects will be allocated... |
01a2703b2180ac10cf7a83c3 | openvul | train | train:7690 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux | https://github.com/torvalds/linux/commit/df4d92549f23e1c037e83323aff58a21b3de7fe0 | df4d92549f23e1c037e83323aff58a21b3de7fe0 | after | false | df4d92549f23e1c037e83323aff58a21b3de7fe0 | containers/df/df4d92549f23e1c037e83323aff58a21b3de7fe0_after.sif | sha256:1727349fac1ed8951a02d7c9bf729eecf63fc4e3ec82d622cb9114a0b0ef95e3 | sha256:8f9986444c5d63f4ed66dc3003f8ebcbe873c6da008f4dd852f432b64deb277a | __mkroute_input | static int __mkroute_input(struct sk_buff *skb,
const struct fib_result *res,
struct in_device *in_dev,
__be32 daddr, __be32 saddr, u32 tos)
{
struct fib_nh_exception *fnhe;
struct rtable *rth;
int err;
struct in_device *out_dev;
unsigned int flags = 0;
bool do_cache;
u32 itag = 0;
out_dev = _... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | net/ipv4/route.c | [
"CVE-2015-1465"
] | The IPv4 implementation in the Linux kernel before 3.18.8 does not properly consider the length of the Read-Copy Update (RCU) grace period for redirecting lookups in the absence of caching, which allows remote attackers to cause a denial of service (memory consumption or system crash) via a flood of packets. | [
"CWE-770"
] | null | null | static int __mkroute_input(struct sk_buff *skb,
const struct fib_result *res,
struct in_device *in_dev,
__be32 daddr, __be32 saddr, u32 tos)
{
struct fib_nh_exception *fnhe;
struct rtable *rth;
int err;
struct in_device *out_dev;
unsigned int flags = 0;
bool do_cache;
u32 itag = 0;
out_dev = _... | static int __mkroute_input(struct sk_buff *skb,
const struct fib_result *res,
struct in_device *in_dev,
__be32 daddr, __be32 saddr, u32 tos)
{
struct fib_nh_exception *fnhe;
struct rtable *rth;
int err;
struct in_device *out_dev;
unsigned int flags = 0;
bool do_cache;
u32 itag = 0;
out_dev = _... | ipv4: try to cache dst_entries which would cause a redirect
Not caching dst_entries which cause redirects could be exploited by hosts
on the same subnet, causing a severe DoS attack. This effect aggravated
since commit f88649721268999 ("ipv4: fix dst race in sk_dst_get()").
Lookups causing redirects will be allocated... |
01a2bfa49ce25cba22da3446 | openvul | train | train:17762 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/f6ac1dba5e36f338a490752a2cbef3339096d9fe | f6ac1dba5e36f338a490752a2cbef3339096d9fe | before | true | a9563a849fc62ce0be68cb60fe740d48eff397a3 | containers/f6/f6ac1dba5e36f338a490752a2cbef3339096d9fe_before.sif | sha256:e9b5d647c2bab72543649423e753b3f8316037b95d36dd9fbf7db85f42351cbf | sha256:19cf5c32eae19b86402ab86bf449895a88c11159cc5b551babef7ca97d3c82db | DrawingBuffer::RestoreAllState | void DrawingBuffer::RestoreAllState() {
client_->DrawingBufferClientRestoreScissorTest();
client_->DrawingBufferClientRestoreMaskAndClearValues();
client_->DrawingBufferClientRestorePixelPackAlignment();
client_->DrawingBufferClientRestoreTexture2DBinding();
client_->DrawingBufferClientRestoreRenderbuffe... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | third_party/WebKit/Source/platform/graphics/gpu/DrawingBuffer.cpp | [
"CVE-2017-5112"
] | Heap buffer overflow in WebGL in Google Chrome prior to 61.0.3163.79 for Windows allowed a remote attacker to execute arbitrary code inside a sandbox via a crafted HTML page. | [
"CWE-119"
] | null | null | void DrawingBuffer::RestoreAllState() {
client_->DrawingBufferClientRestoreScissorTest();
client_->DrawingBufferClientRestoreMaskAndClearValues();
client_->DrawingBufferClientRestorePixelPackAlignment();
client_->DrawingBufferClientRestoreTexture2DBinding();
client_->DrawingBufferClientRestoreRenderbuffe... | void DrawingBuffer::RestoreAllState() {
client_->DrawingBufferClientRestoreScissorTest();
client_->DrawingBufferClientRestoreMaskAndClearValues();
client_->DrawingBufferClientRestorePixelPackParameters();
client_->DrawingBufferClientRestoreTexture2DBinding();
client_->DrawingBufferClientRestoreRenderbuff... | Reset ES3 pixel pack parameters and PIXEL_PACK_BUFFER binding in DrawingBuffer before ReadPixels() and recover them later.
BUG=740603
TEST=new conformance test
R=kbr@chromium.org,piman@chromium.org
Change-Id: I3ea54c6cc34f34e249f7c8b9f792d93c5e1958f4
Reviewed-on: https://chromium-review.googlesource.com/570840
Review... |
01a2bfa49ce25cba22da3446 | openvul | train | train:17762 | 2da129c70b7d36c41a968dcce074aeb419c0e464 | chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium | https://github.com/chromium/chromium/commit/f6ac1dba5e36f338a490752a2cbef3339096d9fe | f6ac1dba5e36f338a490752a2cbef3339096d9fe | after | false | f6ac1dba5e36f338a490752a2cbef3339096d9fe | containers/f6/f6ac1dba5e36f338a490752a2cbef3339096d9fe_after.sif | sha256:3170bec2fd0407bf5cebc7b2872ef5a30f4656f1b00029cd5b14481be9f9e6ba | sha256:b3a370df66c9a9c7cd50a77f89ed0eab1d5297e023c7fbbcc4dab6c8ee25a7af | DrawingBuffer::RestoreAllState | void DrawingBuffer::RestoreAllState() {
client_->DrawingBufferClientRestoreScissorTest();
client_->DrawingBufferClientRestoreMaskAndClearValues();
client_->DrawingBufferClientRestorePixelPackParameters();
client_->DrawingBufferClientRestoreTexture2DBinding();
client_->DrawingBufferClientRestoreRenderbuff... | [
{
"role": "system",
"content": "You are a vulnerability detection expert specializing in identifying security flaws in C/C++ code, with a focus on Common Weakness Enumeration (CWE) standards. You provide precise, evidence-based analysis without speculation, and clearly label any vulnerabilities you detect."... | third_party/WebKit/Source/platform/graphics/gpu/DrawingBuffer.cpp | [
"CVE-2017-5112"
] | Heap buffer overflow in WebGL in Google Chrome prior to 61.0.3163.79 for Windows allowed a remote attacker to execute arbitrary code inside a sandbox via a crafted HTML page. | [
"CWE-119"
] | null | null | void DrawingBuffer::RestoreAllState() {
client_->DrawingBufferClientRestoreScissorTest();
client_->DrawingBufferClientRestoreMaskAndClearValues();
client_->DrawingBufferClientRestorePixelPackAlignment();
client_->DrawingBufferClientRestoreTexture2DBinding();
client_->DrawingBufferClientRestoreRenderbuffe... | void DrawingBuffer::RestoreAllState() {
client_->DrawingBufferClientRestoreScissorTest();
client_->DrawingBufferClientRestoreMaskAndClearValues();
client_->DrawingBufferClientRestorePixelPackParameters();
client_->DrawingBufferClientRestoreTexture2DBinding();
client_->DrawingBufferClientRestoreRenderbuff... | Reset ES3 pixel pack parameters and PIXEL_PACK_BUFFER binding in DrawingBuffer before ReadPixels() and recover them later.
BUG=740603
TEST=new conformance test
R=kbr@chromium.org,piman@chromium.org
Change-Id: I3ea54c6cc34f34e249f7c8b9f792d93c5e1958f4
Reviewed-on: https://chromium-review.googlesource.com/570840
Review... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.