Dataset Viewer
Auto-converted to Parquet Duplicate
id
stringlengths
19
22
source_name
stringclasses
2 values
source_type
stringclasses
1 value
source_split
stringclasses
2 values
original_id
unknown
language
stringclasses
2 values
framework
stringclasses
1 value
task
stringclasses
2 values
cwe_id
stringclasses
15 values
owasp_category
stringclasses
6 values
severity
stringclasses
3 values
is_vulnerable
bool
2 classes
vulnerability_name
stringclasses
15 values
input_code
stringlengths
26
142k
fixed_code
stringclasses
1 value
explanation
stringclasses
2 values
secure_pattern
stringclasses
1 value
tags
listlengths
4
4
metadata
unknown
codexglue_train_007726
CodeXGLUE Defect Detection
public_dataset
train
9603
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed) { if (get_rac(c, state + 0)) return 0; else { int i, e, a; e = 0; while (get_rac(c, state + 1 + FFMIN(e, 9))) { // 1..10 ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "8630b2cd36c57918acfe18302fe77d1ceefbd676", "normalized_at": "2026-06-20T05:17:39.120243Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_014476
CodeXGLUE Defect Detection
public_dataset
train
18073
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static int get_last_needed_nal(H264Context *h) { int nals_needed = 0; int i; for (i = 0; i < h->pkt.nb_nals; i++) { H2645NAL *nal = &h->pkt.nals[i]; GetBitContext gb; /* packets can sometimes contain multiple PPS/SPS, * e.g. two PAFF field pictures in one packet,...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "76f7e70aa04fc5dbef5242b11cbf8fe4499f61d4", "normalized_at": "2026-06-20T05:17:39.290098Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_015862
CodeXGLUE Defect Detection
public_dataset
train
19817
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
void pcie_aer_root_init(PCIDevice *dev) { uint16_t pos = dev->exp.aer_cap; pci_set_long(dev->wmask + pos + PCI_ERR_ROOT_COMMAND, PCI_ERR_ROOT_CMD_EN_MASK); pci_set_long(dev->w1cmask + pos + PCI_ERR_ROOT_STATUS, PCI_ERR_ROOT_STATUS_REPORT_MASK); }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "0e180d9c8a7429c55d23d2e7855f1e490a063aaa", "normalized_at": "2026-06-20T05:17:39.328199Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_004458
CodeXGLUE Defect Detection
public_dataset
train
5522
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static int event_qdev_exit(DeviceState *qdev) { SCLPEvent *event = DO_UPCAST(SCLPEvent, qdev, qdev); SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event); if (child->exit) { child->exit(event); } return 0; }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "c804c2a71752dd1e150cde768d8c54b02fa8bad9", "normalized_at": "2026-06-20T05:17:39.036982Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_018881
CodeXGLUE Defect Detection
public_dataset
train
23588
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static void pci_spapr_set_irq(void *opaque, int irq_num, int level) { /* * Here we use the number returned by pci_spapr_map_irq to find a * corresponding qemu_irq. */ sPAPRPHBState *phb = opaque; qemu_set_irq(phb->lsi_table[irq_num].qirq, level); }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "a307d59434ba78b97544b42b8cfd24a1b62e39a6", "normalized_at": "2026-06-20T05:17:39.411028Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_000702
CodeXGLUE Defect Detection
public_dataset
train
866
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static inline void RENAME(rgb16to15)(const uint8_t *src,uint8_t *dst,long src_size) { register const uint8_t* s=src; register uint8_t* d=dst; register const uint8_t *end; const uint8_t *mm_end; end = s + src_size; #ifdef HAVE_MMX __asm __volatile(PREFETCH" %0"::"m"(*s)); __asm __volatile("movq %0...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "6e42e6c4b410dbef8b593c2d796a5dad95f89ee4", "normalized_at": "2026-06-20T05:17:38.934955Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_008529
CodeXGLUE Defect Detection
public_dataset
train
10616
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end) { const uint8_t *buf_ptr; unsigned int v, v2; int val; int skipped = 0; buf_ptr = *pbuf_ptr; while (buf_ptr < buf_end) { v = *buf_ptr++; v2 = *buf_ptr; if ((v == 0xff) && (v2 >= 0xc0) &&...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "16a0d75c769a7df6f457b2200dbc9a7cc73798c6", "normalized_at": "2026-06-20T05:17:39.138662Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_001067
CodeXGLUE Defect Detection
public_dataset
train
1304
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static void slirp_init_once(void) { static int initialized; struct hostent *he; char our_name[256]; #ifdef _WIN32 WSADATA Data; #endif if (initialized) { return; } initialized = 1; #ifdef _WIN32 WSAStartup(MAKEWORD(2,0), &Data); atexit(winsock_cleanup); #en...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "ce0bd027df9c62766a5417521d0f08f27359d43f", "normalized_at": "2026-06-20T05:17:38.946549Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_003905
CodeXGLUE Defect Detection
public_dataset
train
4811
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
void usb_ep_combine_input_packets(USBEndpoint *ep) { USBPacket *p, *u, *next, *prev = NULL, *first = NULL; USBPort *port = ep->dev->port; int ret; assert(ep->pipeline); assert(ep->pid == USB_TOKEN_IN); QTAILQ_FOREACH_SAFE(p, &ep->queue, queue, next) { /* Empty the queue on a ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "579967bea69bf1b32faee13ff76b19ba641a2618", "normalized_at": "2026-06-20T05:17:39.023667Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_007081
CodeXGLUE Defect Detection
public_dataset
train
8795
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void write_section_data(MpegTSContext *ts, MpegTSFilter *tss1, const uint8_t *buf, int buf_size, int is_start) { MpegTSSectionFilter *tss = &tss1->u.section_filter; int len; if (is_start) { memcpy(tss->section_buf, buf, buf_size); tss->section_i...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "4b6be54bed27eb7fc8f005505ff38e71b3c86cec", "normalized_at": "2026-06-20T05:17:39.104681Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_011869
CodeXGLUE Defect Detection
public_dataset
train
14766
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static int gif_parse_next_image(GifState *s) { ByteIOContext *f = s->f; int ret, code; for (;;) { code = url_fgetc(f); #ifdef DEBUG printf("gif: code=%02x '%c'\n", code, code); #endif switch (code) { case ',': if (gif_read_image(s) < 0) ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "0b54f3c0878a3acaa9142e4f24942e762d97e350", "normalized_at": "2026-06-20T05:17:39.225716Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
owasp_python_000547
OWASP Benchmark Python
public_dataset
processed
547
python
generic
security_review
CWE-643
A03: Injection
high
false
XPath Injection
''' OWASP Benchmark for Python v0.1 This file is part of the Open Web Application Security Project (OWASP) Benchmark Project. For details, please see https://owasp.org/www-project-benchmark. The OWASP Benchmark is free software: you can redistribute it and/or modify it under the terms of the GNU General Public Licens...
This example was normalized from OWASP Benchmark Python. It is intended for security review and vulnerability detection. A secure repair is not included in this source-specific normalized record.
[ "owasp", "benchmark-python", "python", "cwe-643" ]
{ "raw_path": "testcode/BenchmarkTest00547.py", "label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv", "normalized_at": "2026-06-20T05:21:00.704388Z", "name_fixed_at": "2026-06-20T05:22:49.834530Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_018947
CodeXGLUE Defect Detection
public_dataset
train
23670
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
iscsi_aio_read16_cb(struct iscsi_context *iscsi, int status, void *command_data, void *opaque) { IscsiAIOCB *acb = opaque; trace_iscsi_aio_read16_cb(iscsi, status, acb, acb->canceled); if (acb->canceled) { qemu_aio_release(acb); return; } acb->statu...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "b20909195745c34a819aed14ae996b60ab0f591f", "normalized_at": "2026-06-20T05:17:39.412600Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_014257
CodeXGLUE Defect Detection
public_dataset
train
17799
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
void FUNCC(ff_h264_idct8_add)(uint8_t *_dst, int16_t *_block, int stride){ int i; pixel *dst = (pixel*)_dst; dctcoef *block = (dctcoef*)_block; stride >>= sizeof(pixel)-1; block[0] += 32; for( i = 0; i < 8; i++ ) { const int a0 = block[i+0*8] + block[i+4*8]; con...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "0ba22831e1fcc88c755190b08a9cfc235df3a9a9", "normalized_at": "2026-06-20T05:17:39.284038Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_014987
CodeXGLUE Defect Detection
public_dataset
train
18734
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
void ff_avg_h264_qpel16_mc11_msa(uint8_t *dst, const uint8_t *src, ptrdiff_t stride) { avc_luma_hv_qrt_and_aver_dst_16x16_msa(src - 2, src - (stride * 2), stride, dst, stride); }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "1181d93231e9b807965724587d363c1cfd5a1d0d", "normalized_at": "2026-06-20T05:17:39.303960Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_021048
CodeXGLUE Defect Detection
public_dataset
train
26308
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
void net_rx_pkt_attach_iovec_ex(struct NetRxPkt *pkt, const struct iovec *iov, int iovcnt, size_t iovoff, bool strip_vlan, uint16_t vet) { uint16_t tci = 0; uint16_t ploff = iovoff; assert(pkt); pkt->...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "df8bf7a7fe75eb5d5caffa55f5cd4292b757aea6", "normalized_at": "2026-06-20T05:17:39.468110Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_014088
CodeXGLUE Defect Detection
public_dataset
train
17570
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static void net_socket_receive(void *opaque, const uint8_t *buf, size_t size) { NetSocketState *s = opaque; uint32_t len; len = htonl(size); send_all(s->fd, (const uint8_t *)&len, sizeof(len)); send_all(s->fd, buf, size); }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "e3f5ec2b5e92706e3b807059f79b1fb5d936e567", "normalized_at": "2026-06-20T05:17:39.280284Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_017521
CodeXGLUE Defect Detection
public_dataset
train
21886
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
av_cold int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation) { const int isRgb = c->dstFormat == AV_PIX_FMT_RGB32 || c->dstFormat == AV...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "1dd797e3c9f179f957316a0becbec048b42df8aa", "normalized_at": "2026-06-20T05:17:39.373777Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_019465
CodeXGLUE Defect Detection
public_dataset
train
24322
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static int qemu_gluster_parseuri(GlusterConf *gconf, const char *filename) { URI *uri; QueryParams *qp = NULL; bool is_unix = false; int ret = 0; uri = uri_parse(filename); if (!uri) { return -EINVAL; } /* transport */ if (!strcmp(uri->scheme, "gluster")) { ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "24897a767bd778fc6a050537d024565f9272cd06", "normalized_at": "2026-06-20T05:17:39.427960Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_017540
CodeXGLUE Defect Detection
public_dataset
train
21908
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void net_socket_accept(void *opaque) { NetSocketListenState *s = opaque; NetSocketState *s1; struct sockaddr_in saddr; socklen_t len; int fd; for(;;) { len = sizeof(saddr); fd = qemu_accept(s->fd, (struct sockaddr *)&saddr, &len); if (fd < 0 && errno !=...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "e5d1fca0f20babbe355957b9ba536fe6187691cc", "normalized_at": "2026-06-20T05:17:39.374286Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_002777
CodeXGLUE Defect Detection
public_dataset
train
3395
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp, const uint8_t *buf, unsigned int substr) { SubStream *s = &m->substream[substr]; unsigned int ch; int sync_word, tmp; uint8_t checksum; uint8_t lossless_check; int start_count = get_bit...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "a9cd12ee2afb3f3aad783c396816b23d8513f472", "normalized_at": "2026-06-20T05:17:38.993546Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_014951
CodeXGLUE Defect Detection
public_dataset
train
18690
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
void ppc_store_sdr1(CPUPPCState *env, target_ulong value) { LOG_MMU("%s: " TARGET_FMT_lx "\n", __func__, value); if (env->spr[SPR_SDR1] != value) { env->spr[SPR_SDR1] = value; #if defined(TARGET_PPC64) if (env->mmu_model & POWERPC_MMU_64) { target_ulong htabsize = value & SDR_...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "f3c75d42adbba553eaf218a832d4fbea32c8f7b8", "normalized_at": "2026-06-20T05:17:39.303009Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_020134
CodeXGLUE Defect Detection
public_dataset
train
25174
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static int qxl_init_secondary(PCIDevice *dev) { static int device_id = 1; PCIQXLDevice *qxl = DO_UPCAST(PCIQXLDevice, pci, dev); ram_addr_t ram_size = msb_mask(qxl->vga.vram_size * 2 - 1); qxl->id = device_id++; if (ram_size < 16 * 1024 * 1024) { ram_size = 16 * 1024 * 1024; ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "96c05abc904c6f74b60981d956cee531920e4cdf", "normalized_at": "2026-06-20T05:17:39.445240Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_014251
CodeXGLUE Defect Detection
public_dataset
train
17791
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
real_parse_asm_rulebook(AVFormatContext *s, AVStream *orig_st, const char *p) { const char *end; int n_rules, odd = 0; AVStream *st; /** * The ASMRuleBook contains a list of comma-separated strings per rule, * and each rule is separated by a ;. The last one al...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "dfdb353cd565efbd1f64105ce7519ec809ad338d", "normalized_at": "2026-06-20T05:17:39.283885Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_004116
CodeXGLUE Defect Detection
public_dataset
train
5082
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static int usb_qdev_exit(DeviceState *qdev) { USBDevice *dev = USB_DEVICE(qdev); if (dev->attached) { usb_device_detach(dev); } usb_device_handle_destroy(dev); if (dev->port) { usb_release_port(dev); } return 0; }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "7d553f27fce284805d7f94603932045ee3bbb979", "normalized_at": "2026-06-20T05:17:39.028726Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_020047
CodeXGLUE Defect Detection
public_dataset
train
25065
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
int ff_thread_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt) { FrameThreadContext *fctx = avctx->internal->thread_ctx; int finished = fctx->next_finished; PerThreadContext *p; int err; /* re...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "1269cd5b6f540bef5913bf134d2f461aac50d70b", "normalized_at": "2026-06-20T05:17:39.443110Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_020071
CodeXGLUE Defect Detection
public_dataset
train
25099
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
float32 helper_fdtos(CPUSPARCState *env, float64 src) { float32 ret; clear_float_exceptions(env); ret = float64_to_float32(src, &env->fp_status); check_ieee_exceptions(env); return ret; }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "7385aed20db5d83979f683b9d0048674411e963c", "normalized_at": "2026-06-20T05:17:39.443782Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_007902
CodeXGLUE Defect Detection
public_dataset
train
9839
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void *acpi_add_rom_blob(AcpiBuildState *build_state, GArray *blob, const char *name) { return rom_add_blob(name, blob->data, acpi_data_len(blob), -1, name, acpi_build_update, build_state); }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "ad5b88b1f198182642b6cbf3dacb4cade0c80fb9", "normalized_at": "2026-06-20T05:17:39.124526Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_001409
CodeXGLUE Defect Detection
public_dataset
train
1727
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt) { IVI45DecContext *ctx = avctx->priv_data; const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; int result, p, b; init_get_bits(&ctx->gb, bu...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "b146d74730ab9ec5abede9066f770ad851e45fbc", "normalized_at": "2026-06-20T05:17:38.955708Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_002849
CodeXGLUE Defect Detection
public_dataset
train
3486
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static av_cold int mov_text_encode_init(AVCodecContext *avctx) { /* * For now, we'll use a fixed default style. When we add styling * support, this will be generated from the ASS style. */ static const uint8_t text_sample_entry[] = { 0x00, 0x00, 0x00, 0x00, // uint32_t displayFlags...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "f95c81ce104554b6860d94724a681a1bac0c4fbd", "normalized_at": "2026-06-20T05:17:38.995494Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_000065
CodeXGLUE Defect Detection
public_dataset
train
78
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
SwsContext *sws_alloc_context(void) { SwsContext *c = av_mallocz(sizeof(SwsContext)); c->av_class = &sws_context_class; av_opt_set_defaults(c); return c; }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "f73f76fd202b310e8e1d0215b2e0cf038cd18c4a", "normalized_at": "2026-06-20T05:17:38.916511Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_004320
CodeXGLUE Defect Detection
public_dataset
train
5343
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static int find_debugfs(char *debugfs) { char type[100]; FILE *fp; fp = fopen("/proc/mounts", "r"); if (fp == NULL) { return 0; } while (fscanf(fp, "%*s %" STR(PATH_MAX) "s %99s %*s %*d %*d\n", debugfs, type) == 2) { if (strcmp(type, "debugfs") == ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "5070570c9089b905dd9efae30ee4318033c6ccd6", "normalized_at": "2026-06-20T05:17:39.033903Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_009968
CodeXGLUE Defect Detection
public_dataset
train
12437
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
long do_sigreturn(CPUS390XState *env) { sigframe *frame; abi_ulong frame_addr = env->regs[15]; qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__, (unsigned long long)frame_addr); target_sigset_t target_set; sigset_t set; if (!lock_user_struct(VERIFY_READ, frame, frame_addr,...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "1c275925bfbbc2de84a8f0e09d1dd70bbefb6da3", "normalized_at": "2026-06-20T05:17:39.175847Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_017522
CodeXGLUE Defect Detection
public_dataset
train
21887
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static int vp3_decode_init(AVCodecContext *avctx) { Vp3DecodeContext *s = avctx->priv_data; int i; s->avctx = avctx; s->width = avctx->width; s->height = avctx->height; avctx->pix_fmt = PIX_FMT_YUV420P; avctx->has_b_frames = 0; dsputil_init(&s->dsp, avctx); /* initializ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "892fc83e88a20f9543c6c5be3626712be7a2e6f2", "normalized_at": "2026-06-20T05:17:39.373838Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_019988
CodeXGLUE Defect Detection
public_dataset
train
24999
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static void qemu_input_transform_abs_rotate(InputEvent *evt) { InputMoveEvent *move = evt->u.abs; switch (graphic_rotate) { case 90: if (move->axis == INPUT_AXIS_X) { move->axis = INPUT_AXIS_Y; } else if (move->axis == INPUT_AXIS_Y) { move->axis = INPUT_AXIS_X...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "32bafa8fdd098d52fbf1102d5a5e48d29398c0aa", "normalized_at": "2026-06-20T05:17:39.441853Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_006974
CodeXGLUE Defect Detection
public_dataset
train
8672
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags) { BlockDriverState *bs; int ret; bs = bdrv_new(""); if (!bs) return -ENOMEM; ret = bdrv_open2(bs, filename, flags | BDRV_O_FILE, NULL); if (ret < 0) { bdrv_delete(bs); return ret; ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "51d7c00c14550334ec140ce8f40e04ed4c88de57", "normalized_at": "2026-06-20T05:17:39.101373Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_019617
CodeXGLUE Defect Detection
public_dataset
train
24515
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
void *laio_init(void) { struct qemu_laio_state *s; s = qemu_mallocz(sizeof(*s)); QLIST_INIT(&s->completed_reqs); s->efd = eventfd(0, 0); if (s->efd == -1) goto out_free_state; fcntl(s->efd, F_SETFL, O_NONBLOCK); if (io_setup(MAX_EVENTS, &s->ctx) != 0) goto out_c...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "384acbf46b70edf0d2c1648aa1a92a90bcf7057d", "normalized_at": "2026-06-20T05:17:39.432171Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_017773
CodeXGLUE Defect Detection
public_dataset
train
22206
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static void mm_decode_inter(MmContext * s, int half_horiz, int half_vert, const uint8_t *buf, int buf_size) { const int data_ptr = 2 + AV_RL16(&buf[0]); int d, r, y; d = data_ptr; r = 2; y = 0; while(r < data_ptr) { int i, j; int length = buf[r] & 0x7f; int x = buf[r+1]...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "091bc6ca8c643bfece2c70ff2404c7b31574e1f1", "normalized_at": "2026-06-20T05:17:39.381586Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_009505
CodeXGLUE Defect Detection
public_dataset
train
11822
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static int flv_read_header(AVFormatContext *s) { int flags; FLVContext *flv = s->priv_data; int offset; avio_skip(s->pb, 4); flags = avio_r8(s->pb); flv->missing_streams = flags & (FLV_HEADER_FLAG_HASVIDEO | FLV_HEADER_FLAG_HASAUDIO); s->ctx_flags |= AVFMTCTX_NOHEADER; o...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "c0628919b8c5761d64b1169e8de7584544d15ebf", "normalized_at": "2026-06-20T05:17:39.164039Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_013058
CodeXGLUE Defect Detection
public_dataset
train
16261
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static int net_tap_init(VLANState *vlan, const char *model, const char *name, const char *ifname1, const char *setup_script, const char *down_script) { TAPState *s; int fd; char ifname[128]; if (ifname1 != NULL) pstrcpy(ifname, sizeof(ifn...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "973cbd37ce6d4c33dea7f4ed6b8e0e602fa50d25", "normalized_at": "2026-06-20T05:17:39.255626Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_013367
CodeXGLUE Defect Detection
public_dataset
train
16653
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void test_tco2_status_bits(void) { TestData d; uint16_t ticks = 8; uint16_t val; int ret; d.args = NULL; d.noreboot = true; test_init(&d); stop_tco(&d); clear_tco_status(&d); reset_on_second_timeout(true); set_tco_timeout(&d, ticks); load_tco(&d); ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "b4ba67d9a702507793c2724e56f98e9b0f7be02b", "normalized_at": "2026-06-20T05:17:39.262224Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_005543
CodeXGLUE Defect Detection
public_dataset
train
6887
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
void *av_malloc(unsigned int size) { void *ptr; #if defined (HAVE_MEMALIGN) ptr = memalign(16,size); /* Why 64? Indeed, we should align it: on 4 for 386 on 16 for 486 on 32 for 586, PPro - k6-III on 64 for K7 (maybe for P3 too). Because L1 and L2 caches ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "da9b170c6f06184a5114dc66afb8385cd0ffff83", "normalized_at": "2026-06-20T05:17:39.065468Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_000605
CodeXGLUE Defect Detection
public_dataset
train
745
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void compute_frame_duration(int *pnum, int *pden, AVStream *st, AVCodecParserContext *pc, AVPacket *pkt) { int frame_size; *pnum = 0; *pden = 0; switch(st->codec.codec_type) { case CODEC_TYPE_VIDEO: if(st->time_base.num*1000 > st->time_bas...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "1677155df8ee2dbf6c99738b289e27c2237506bd", "normalized_at": "2026-06-20T05:17:38.932106Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_002801
CodeXGLUE Defect Detection
public_dataset
train
3424
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void encode_quant_matrix(VC2EncContext *s) { int level, custom_quant_matrix = 0; if (s->wavelet_depth > 4 || s->quant_matrix != VC2_QM_DEF) custom_quant_matrix = 1; put_bits(&s->pb, 1, custom_quant_matrix); if (custom_quant_matrix) { init_custom_qm(s); put_vc2_ue_u...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "b88be742fac7a77a8095e8155ba8790db4b77568", "normalized_at": "2026-06-20T05:17:38.994146Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_010222
CodeXGLUE Defect Detection
public_dataset
train
12743
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static CharDriverState *qmp_chardev_open_parallel(const char *id, ChardevBackend *backend, ChardevReturn *ret, Error **errp) { ChardevHostdev *parallel = backend...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "d0d7708ba29cbcc343364a46bff981e0ff88366f", "normalized_at": "2026-06-20T05:17:39.182692Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_017750
CodeXGLUE Defect Detection
public_dataset
train
22177
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static void niagara_init(MachineState *machine) { NiagaraBoardState *s = g_new(NiagaraBoardState, 1); DriveInfo *dinfo = drive_get_next(IF_PFLASH); MemoryRegion *sysmem = get_system_memory(); /* init CPUs */ sparc64_cpu_devinit(machine->cpu_model, "Sun UltraSparc T1", ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "a5a08302d44a8b1a8c5819b1411002f85bb5f847", "normalized_at": "2026-06-20T05:17:39.381161Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_013907
CodeXGLUE Defect Detection
public_dataset
train
17343
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
int attribute_align_arg av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags) { BufferSinkContext *buf = ctx->priv; AVFilterLink *inlink = ctx->inputs[0]; int ret; AVFrame *cur_frame; /* no picref available, fetch it from the filterchain */ if (!av_fifo_size(buf...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "807d4b635567e51108ea3a6a774336321c3250e5", "normalized_at": "2026-06-20T05:17:39.275405Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_003562
CodeXGLUE Defect Detection
public_dataset
train
4376
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void imx_eth_write(void *opaque, hwaddr offset, uint64_t value, unsigned size) { IMXFECState *s = IMX_FEC(opaque); uint32_t index = offset >> 2; FEC_PRINTF("reg[%s] <= 0x%" PRIx32 "\n", imx_eth_reg_name(s, index), (uint32_t)value); switch (ind...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "b2b012afdd9c03ba8a1619f45301d34f358d367b", "normalized_at": "2026-06-20T05:17:39.015127Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_019942
CodeXGLUE Defect Detection
public_dataset
train
24945
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block, int component, int dc_index, uint16_t *quant_matrix, int Al) { int val; s->bdsp.clear_block(block); val = mjpeg_decode_dc(s, dc_index); if (val == 0xfffff) { ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "40fa6a2fa2c255293a780a194eecae5df52644a1", "normalized_at": "2026-06-20T05:17:39.440898Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_015196
CodeXGLUE Defect Detection
public_dataset
train
18987
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static SocketAddressLegacy *sd_socket_address(const char *path, const char *host, const char *port) { SocketAddressLegacy *addr = g_new0(SocketAddressLegacy, 1); if (path) { addr->type = SOCKET_ADDRESS_LEGACY_KIND_UNIX; addr->u.q_unix.data = g_new0...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "bd269ebc82fbaa5fe7ce5bc7c1770ac8acecd884", "normalized_at": "2026-06-20T05:17:39.309349Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_020647
CodeXGLUE Defect Detection
public_dataset
train
25818
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static int ftp_get_line(FTPContext *s, char *line, int line_size) { int ch; char *q = line; int ori_block_flag = s->conn_control_block_flag; for (;;) { ch = ftp_getc(s); if (ch < 0) { s->conn_control_block_flag = ori_block_flag; return ch; } ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "247e658784ead984f96021acb9c95052ba599f26", "normalized_at": "2026-06-20T05:17:39.456915Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_005188
CodeXGLUE Defect Detection
public_dataset
train
6435
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void rm_read_metadata(AVFormatContext *s, int wide) { char buf[1024]; int i; for (i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) { int len = wide ? avio_rb16(s->pb) : avio_r8(s->pb); get_strl(s->pb, buf, sizeof(buf), len); av_dict_set(&s->metadata, ff_rm_metadata[i], buf, ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "bf87908cd8da31e8f8fe75c06577170928ea70a8", "normalized_at": "2026-06-20T05:17:39.056129Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_016067
CodeXGLUE Defect Detection
public_dataset
train
20081
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static ObjectClass *alpha_cpu_class_by_name(const char *cpu_model) { ObjectClass *oc = NULL; char *typename; int i; if (cpu_model == NULL) { return NULL; } oc = object_class_by_name(cpu_model); if (oc != NULL && object_class_dynamic_cast(oc, TYPE_ALPHA_CPU) != NULL && ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "82a3d1f81f8e401c6c34cba541970197aba2bb9a", "normalized_at": "2026-06-20T05:17:39.333275Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_021077
CodeXGLUE Defect Detection
public_dataset
train
26343
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
int ff_mov_add_hinted_packet(AVFormatContext *s, AVPacket *pkt, int track_index, int sample) { MOVMuxContext *mov = s->priv_data; MOVTrack *trk = &mov->tracks[track_index]; AVFormatContext *rtp_ctx = trk->rtp_ctx; uint8_t *buf = NULL; int size; AVIOContext *h...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "403ee835e7913eb9536b22c2b22edfdd700166a9", "normalized_at": "2026-06-20T05:17:39.469213Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_002615
CodeXGLUE Defect Detection
public_dataset
train
3185
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static int convert_sub_to_old_ass_form(AVSubtitle *sub, const AVPacket *pkt, AVRational tb) { int i; AVBPrint buf; av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED); for (i = 0; i < sub->num_rects; i++) { char *final_dialog; const char *dialog; AVSubtitleRect *rect = ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "2b7a61cbd8ae134f839c4347a4c289e1e11475a3", "normalized_at": "2026-06-20T05:17:38.989270Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_006144
CodeXGLUE Defect Detection
public_dataset
train
7638
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void update_error_limit(WavpackFrameContext *ctx) { int i, br[2], sl[2]; for (i = 0; i <= ctx->stereo_in; i++) { ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta; br[i] = ctx->ch[i].bitrate_acc >> 16; sl[i] = LEVEL_DECAY(ctx->ch[i].slo...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "d03d38616278bf209e6c860d8f9f564cbc6c1780", "normalized_at": "2026-06-20T05:17:39.080661Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_021343
CodeXGLUE Defect Detection
public_dataset
train
26688
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static inline PageDesc *page_find(target_ulong index) { PageDesc *p; p = l1_map[index >> L2_BITS]; if (!p) return 0; return p + (index & (L2_SIZE - 1)); }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "434929bf11f0573d953c24287badbc2431a042ef", "normalized_at": "2026-06-20T05:17:39.476778Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_008295
CodeXGLUE Defect Detection
public_dataset
train
10324
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static av_cold int vaapi_encode_h265_init_internal(AVCodecContext *avctx) { static const VAConfigAttrib default_config_attributes[] = { { .type = VAConfigAttribRTFormat, .value = VA_RT_FORMAT_YUV420 }, { .type = VAConfigAttribEncPackedHeaders, .value = (VA_ENC_PACKED_HEAD...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "c8241e730f116f1c9cfc0b34110aa7f052e05332", "normalized_at": "2026-06-20T05:17:39.133130Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_017284
CodeXGLUE Defect Detection
public_dataset
train
21595
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static int spapr_msicfg_find(sPAPRPHBState *phb, uint32_t config_addr, bool alloc_new) { int i; for (i = 0; i < SPAPR_MSIX_MAX_DEVS; ++i) { if (!phb->msi_table[i].nvec) { break; } if (phb->msi_table[i].config_addr == config_addr) { ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "9a321e92343891e30f6fe8bfaad40454ae358bfb", "normalized_at": "2026-06-20T05:17:39.365690Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_000926
CodeXGLUE Defect Detection
public_dataset
train
1141
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
void qpci_iounmap(QPCIDevice *dev, void *data) { /* FIXME */ }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "b4ba67d9a702507793c2724e56f98e9b0f7be02b", "normalized_at": "2026-06-20T05:17:38.942762Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_017547
CodeXGLUE Defect Detection
public_dataset
train
21916
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void vmdk_free_last_extent(BlockDriverState *bs) { BDRVVmdkState *s = bs->opaque; if (s->num_extents == 0) { return; } s->num_extents--; s->extents = g_realloc(s->extents, s->num_extents * sizeof(VmdkExtent)); }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "5839e53bbc0fec56021d758aab7610df421ed8c8", "normalized_at": "2026-06-20T05:17:39.374449Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_005706
CodeXGLUE Defect Detection
public_dataset
train
7088
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static void add_codec(FFStream *stream, AVCodecContext *av) { AVStream *st; if(stream->nb_streams >= FF_ARRAY_ELEMS(stream->streams)) return; /* compute default parameters */ switch(av->codec_type) { case AVMEDIA_TYPE_AUDIO: if (av->bit_rate == 0) av->bit_rat...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "e85771f26814ae192f511a1b01b17ae0d62d62ab", "normalized_at": "2026-06-20T05:17:39.070448Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_002156
CodeXGLUE Defect Detection
public_dataset
train
2629
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static void bitband_writel(void *opaque, target_phys_addr_t offset, uint32_t value) { uint32_t addr; uint32_t mask; uint32_t v; addr = bitband_addr(opaque, offset) & ~3; mask = (1 << ((offset >> 2) & 31)); mask = tswap32(mask); cpu_physical_memory_read(add...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "a8170e5e97ad17ca169c64ba87ae2f53850dab4c", "normalized_at": "2026-06-20T05:17:38.975358Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_007376
CodeXGLUE Defect Detection
public_dataset
train
9159
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs, BlockCompletionFunc *completion_cb, void *opaque) { Error *local_err = NULL; int err; bdrv_add_key(bs, NULL, &local_err); if (!local_err) { if (completion...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "988e0f06621fde11ec0d319a6fd0ab3ccef0602f", "normalized_at": "2026-06-20T05:17:39.111844Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_012705
CodeXGLUE Defect Detection
public_dataset
train
15812
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
void usb_test_hotplug(const char *hcd_id, const int port, void (*port_check)(void)) { QDict *response; char *cmd; cmd = g_strdup_printf("{'execute': 'device_add'," " 'arguments': {" " 'driver': 'usb-tablet'," ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "acd80015fbe28f4f513e036ad1db2a76738d1f53", "normalized_at": "2026-06-20T05:17:39.246807Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_015462
CodeXGLUE Defect Detection
public_dataset
train
19328
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
void nbd_client_session_close(NbdClientSession *client) { struct nbd_request request = { .type = NBD_CMD_DISC, .from = 0, .len = 0 }; if (!client->bs) { return; } if (client->sock == -1) { return; } nbd_send_request(client->sock, &requ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "f53a829bb9ef14be800556cbc02d8b20fc1050a7", "normalized_at": "2026-06-20T05:17:39.316135Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_016849
CodeXGLUE Defect Detection
public_dataset
train
21056
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static ExitStatus gen_call_pal(DisasContext *ctx, int palcode) { /* We're emulating OSF/1 PALcode. Many of these are trivial access to internal cpu registers. */ /* Unprivileged PAL call */ if (palcode >= 0x80 && palcode < 0xC0) { switch (palcode) { case 0x86: ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "06ef8604e92964cbf30084b7d31091aa7cbbb62f", "normalized_at": "2026-06-20T05:17:39.353127Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_004071
CodeXGLUE Defect Detection
public_dataset
train
5022
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts, void (*init)(struct CharDriverState *s), Error **errp) { Error *local_err = NULL; CharDriver *cd; CharDriverState *chr; GSList *i; ChardevReturn *ret = NULL; C...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "130257dc443574a9da91dc293665be2cfc40245a", "normalized_at": "2026-06-20T05:17:39.027814Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_003514
CodeXGLUE Defect Detection
public_dataset
train
4313
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static uint64_t imx_avic_read(void *opaque, target_phys_addr_t offset, unsigned size) { IMXAVICState *s = (IMXAVICState *)opaque; DPRINTF("read(offset = 0x%x)\n", offset >> 2); switch (offset >> 2) { case 0: /* INTCNTL */ return s->intcntl; case 1: ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "a8170e5e97ad17ca169c64ba87ae2f53850dab4c", "normalized_at": "2026-06-20T05:17:39.013488Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_020547
CodeXGLUE Defect Detection
public_dataset
train
25688
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void icp_pit_write(void *opaque, hwaddr offset, uint64_t value, unsigned size) { icp_pit_state *s = (icp_pit_state *)opaque; int n; n = offset >> 8; if (n > 2) { qemu_log_mask(LOG_GUEST_ERROR, "%s: Bad timer %d\n", __func__, n); } arm_timer_...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "cba933b2257ef0ad241756a0ff86bc0acda685ca", "normalized_at": "2026-06-20T05:17:39.454751Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_012229
CodeXGLUE Defect Detection
public_dataset
train
15233
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void gen_tlbiva(DisasContext *ctx) { #if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); #else TCGv t0; if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); return; } t0 = tcg_temp_new(); gen_addr_reg_index(ctx, t0...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "9b2fadda3e0196ffd485adde4fe9cdd6fae35300", "normalized_at": "2026-06-20T05:17:39.233904Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_018202
CodeXGLUE Defect Detection
public_dataset
train
22735
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static uint32_t intel_hda_mmio_readl(void *opaque, target_phys_addr_t addr) { IntelHDAState *d = opaque; const IntelHDAReg *reg = intel_hda_reg_find(d, addr); return intel_hda_reg_read(d, reg, 0xffffffff); }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "a8170e5e97ad17ca169c64ba87ae2f53850dab4c", "normalized_at": "2026-06-20T05:17:39.393827Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
owasp_python_000147
OWASP Benchmark Python
public_dataset
processed
147
python
generic
security_review
CWE-328
A02: Cryptographic Failures
medium
false
Weak Hashing Algorithm
''' OWASP Benchmark for Python v0.1 This file is part of the Open Web Application Security Project (OWASP) Benchmark Project. For details, please see https://owasp.org/www-project-benchmark. The OWASP Benchmark is free software: you can redistribute it and/or modify it under the terms of the GNU General Public Licens...
This example was normalized from OWASP Benchmark Python. It is intended for security review and vulnerability detection. A secure repair is not included in this source-specific normalized record.
[ "owasp", "benchmark-python", "python", "cwe-328" ]
{ "raw_path": "testcode/BenchmarkTest00147.py", "label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv", "normalized_at": "2026-06-20T05:21:00.687068Z", "name_fixed_at": "2026-06-20T05:22:49.827688Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_018741
CodeXGLUE Defect Detection
public_dataset
train
23415
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static void hb_regs_write(void *opaque, hwaddr offset, uint64_t value, unsigned size) { uint32_t *regs = opaque; if (offset == 0xf00) { if (value == 1 || value == 2) { qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET); } else if (value == 3) { ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "c5c752af8cddad3e4e51acef40a46db998638144", "normalized_at": "2026-06-20T05:17:39.407055Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_006980
CodeXGLUE Defect Detection
public_dataset
train
8679
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static bool tb_invalidate_phys_page(tb_page_addr_t addr, uintptr_t pc) { TranslationBlock *tb; PageDesc *p; int n; #ifdef TARGET_HAS_PRECISE_SMC TranslationBlock *current_tb = NULL; CPUState *cpu = current_cpu; CPUArchState *env = NULL; int current_tb_modified = 0; target_ulong...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "9b990ee5a3cc6aa38f81266fb0c6ef37a36c45b9", "normalized_at": "2026-06-20T05:17:39.101470Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_004827
CodeXGLUE Defect Detection
public_dataset
train
5987
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
void ahci_hba_enable(AHCIQState *ahci) { /* Bits of interest in this section: * GHC.AE Global Host Control / AHCI Enable * PxCMD.ST Port Command: Start * PxCMD.SUD "Spin Up Device" * PxCMD.POD "Power On Device" * PxCMD.FRE "FIS Receive Enable" * PxCMD.FR "FIS Receive...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "e7c8526b2a1482a9b14319fda9f8ad4bfda5b958", "normalized_at": "2026-06-20T05:17:39.046564Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_000523
CodeXGLUE Defect Detection
public_dataset
train
641
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
int qemu_chr_fe_get_msgfd(CharDriverState *s) { int fd; return (qemu_chr_fe_get_msgfds(s, &fd, 1) >= 0) ? fd : -1; }
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "4f8586144161d5e680fdef3e09b7e8e9111c2929", "normalized_at": "2026-06-20T05:17:38.930235Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_002393
CodeXGLUE Defect Detection
public_dataset
train
2910
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static int decode_coeffs(WMAProDecodeCtx *s, int c) { /* Integers 0..15 as single-precision floats. The table saves a costly int to float conversion, and storing the values as integers allows fast sign-flipping. */ static const int fval_tab[16] = { 0x00000000, 0x3f800000, 0x40000000...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "1db6437f6ce88be241981b78f776b14404bb14fe", "normalized_at": "2026-06-20T05:17:38.983194Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_012593
CodeXGLUE Defect Detection
public_dataset
train
15681
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
static void h261_decode_init_vlc(H261Context *h){ static int done = 0; if(!done){ done = 1; init_vlc(&h261_mba_vlc, H261_MBA_VLC_BITS, 35, h261_mba_bits, 1, 1, h261_mba_code, 1, 1); init_vlc(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10, ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "FFmpeg", "commit_id": "073c2593c9f0aa4445a6fc1b9b24e6e52a8cc2c1", "normalized_at": "2026-06-20T05:17:39.243213Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_010290
CodeXGLUE Defect Detection
public_dataset
train
12834
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static void qxl_log_cmd_draw_compat(PCIQXLDevice *qxl, QXLCompatDrawable *draw, int group_id) { fprintf(stderr, ": type %s effect %s", qxl_name(qxl_draw_type, draw->type), qxl_name(qxl_draw_effect, draw->effect)); if (draw->bitmap_offset) { ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "fae2afb10e3fdceab612c62a2b1e8b944ff578d9", "normalized_at": "2026-06-20T05:17:39.184314Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_003545
CodeXGLUE Defect Detection
public_dataset
train
4356
c
generic
vulnerability_detection
unknown
unknown
unknown
true
unknown_defect_or_vulnerability
int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags) { NBDRequest request = { .type = NBD_CMD_READ, .from = offset, .len = bytes, }; assert(bytes <= NBD_MAX_BUFFER_SIZE); assert(!flags);...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": true, "project": "qemu", "commit_id": "f140e3000371e67ff4e00df3213e2d576d9c91be", "normalized_at": "2026-06-20T05:17:39.014621Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_017026
CodeXGLUE Defect Detection
public_dataset
train
21271
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
void tcg_gen_brcond_i64(TCGCond cond, TCGv_i64 arg1, TCGv_i64 arg2, int label) { if (cond == TCG_COND_ALWAYS) { tcg_gen_br(label); } else if (cond != TCG_COND_NEVER) { if (TCG_TARGET_REG_BITS == 32) { tcg_gen_op6ii_i32(INDEX_op_brcond2_i32, TCGV_LOW(arg1), ...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "qemu", "commit_id": "42a268c241183877192c376d03bd9b6d527407c7", "normalized_at": "2026-06-20T05:17:39.358459Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
codexglue_train_018382
CodeXGLUE Defect Detection
public_dataset
train
22948
c
generic
vulnerability_detection
unknown
unknown
unknown
false
unknown_defect_or_vulnerability
static int seq_fill_buffer(SeqDemuxContext *seq, ByteIOContext *pb, int buffer_num, unsigned int data_offs, int data_size) { TiertexSeqFrameBuffer *seq_buffer; if (buffer_num >= SEQ_NUM_FRAME_BUFFERS) return AVERROR_INVALIDDATA; seq_buffer = &seq->frame_buffers[buffer_num]; if (seq_buf...
This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix.
[ "codexglue", "defect-detection", "c-language", "binary-label" ]
{ "original_target": false, "project": "FFmpeg", "commit_id": "591944cd0c4f10ddf0eaee9298553633e12a26d0", "normalized_at": "2026-06-20T05:17:39.398158Z", "combined_dataset_split": "train", "combined_at": "2026-06-20T05:23:08.742901Z" }
End of preview. Expand in Data Studio

CodeSecAudit-RAG

CodeSecAudit-RAG is a curated defensive dataset for building an Enterprise Code Review and Security Auditor Agent. It combines vulnerability-detection examples with a retrieval-ready secure-coding knowledge corpus.

The dataset is designed for practical AIML and MLOps workflows such as vulnerability detection, security review explanation, and RAG-based secure coding guidance retrieval.

Dataset Components

1. Review Dataset

Files:

  • review_combined/train.jsonl.gz
  • review_combined/validation.jsonl.gz
  • review_combined/test.jsonl.gz

Total records: 28,548

Sources:

  • CodeXGLUE Defect Detection: large binary vulnerable/non-vulnerable C examples
  • OWASP Benchmark Python: CWE-labeled Python benchmark examples

The review dataset supports binary vulnerability detection and CWE-aware security review.

2. RAG Corpus

File:

  • rag/rag_corpus.jsonl.gz

Total chunks: 2,833

Source:

  • OWASP Cheat Sheet Series

The RAG corpus contains secure coding guidance chunks for retrieval-augmented generation. It covers topics such as SQL injection prevention, XSS, code injection, OS command injection, authentication, authorization, secrets management, file upload security, SSRF, deserialization, and cryptographic failures.

Intended Use

This dataset is intended for defensive security research and educational AI engineering projects, including:

  • vulnerability detection
  • secure code review
  • security explanation generation
  • RAG-based secure coding assistants
  • MLOps and dataset engineering demonstrations

Not Intended For

This dataset is not intended for building offensive exploitation tools, malware generation systems, or automated attack systems. The dataset should be used for defensive code review, secure coding education, and vulnerability remediation workflows.

Schema

Review records include:

  • id
  • source_name
  • source_type
  • source_split
  • original_id
  • language
  • framework
  • task
  • cwe_id
  • owasp_category
  • severity
  • is_vulnerable
  • vulnerability_name
  • input_code
  • fixed_code
  • explanation
  • secure_pattern
  • tags
  • metadata

RAG records include:

  • id
  • source_name
  • source_type
  • doc_type
  • source_file
  • title
  • section_title
  • chunk_index
  • language
  • framework
  • task
  • cwe_id
  • vulnerability_name
  • owasp_category
  • content
  • positive_pattern
  • negative_pattern
  • tags
  • metadata

Dataset Statistics

Review dataset:

Split Records
Train 22,827
Validation 2,846
Test 2,875
Total 28,548

RAG corpus:

Component Count
RAG chunks 2,833
Covered CWE types 16
Average chunk size ~869 characters

Loading Example

from datasets import load_dataset

review = load_dataset(
    "json",
    data_files={
        "train": "review_combined/train.jsonl.gz",
        "validation": "review_combined/validation.jsonl.gz",
        "test": "review_combined/test.jsonl.gz",
    }
)

rag = load_dataset(
    "json",
    data_files={"train": "rag/rag_corpus.jsonl.gz"}
)

Limitations

CodeXGLUE provides binary labels but does not provide exact CWE labels, so those records use cwe_id: unknown. OWASP Benchmark Python provides stronger CWE-specific labels. The RAG corpus is documentation-derived and should be used as retrieval context rather than ground-truth model labels.

Source and License Notice

This is a curated derivative dataset built from public security datasets and documentation. Users should review the original source licenses before redistribution or commercial use. The dataset card intentionally uses license: other because the final package combines sources with different licensing terms.

Author

Created and curated by Om Choksi.

Downloads last month
6