Datasets:

QCRI
/

verivul-dataset

id stringlengths 36 36	seed_id stringlengths 36 36	parent_id stringlengths 36 36 ⌀	pair_ids listlengths 0 7	label stringclasses 2 values	language stringclasses 3 values	code stringlengths 79 52.9k	code_sha256 stringlengths 64 64	loc int64 6 1.86k	generation_model stringclasses 5 values	generation_batch stringclasses 2 values	source_corpus stringclasses 2 values	cve stringlengths 13 16	project stringclasses 440 values	repo_url stringclasses 433 values	commit_hash stringlengths 40 40	cwes listlengths 0 6	cwe_source stringclasses 2 values	seed_cwes listlengths 0 4	esbmc_cwes listlengths 0 6	esbmc_cwe_source stringclasses 2 values	category stringclasses 11 values	property stringclasses 587 values	property_function stringlengths 3 33 ⌀	property_line int64 6 1.89k ⌀	trigger_line_number int64 6 1.86k ⌀	trigger_line stringlengths 1 1.12k ⌀	trigger_in_program bool 2 classes	esbmc_version stringclasses 1 value	esbmc_verdict stringclasses 2 values	esbmc_proof stringclasses 1 value	esbmc_k int64 1 1.03k	esbmc_timeout_s int64 290 1.79k	esbmc_memlimit_mb int64 4.1k 8.19k	esbmc_duration_s float64 1.07 1.72k	sanitizer_level stringclasses 6 values	sanitizer_kind stringclasses 25 values	sanitizer_runs int64 9 11.3k ⌀	sanitizer_stage stringclasses 3 values	flag_sanitizer_counterexample_on_safe bool 2 classes	flag_empty_main bool 2 classes	flag_lexically_obvious bool 2 classes	flag_env_dependent bool 2 classes	created_at stringdate 2026-10-11 00:00:00 2026-10-28 00:00:00
7a2335a3-f087-4e20-997b-f2b722b809bf	926f48d4-3bb7-4074-a836-fc5b278d2d51	null	[ "641b48ce-f97b-475e-a44e-c37f5fdd9992" ]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> struct resource_node { uint32_t id; uint32_t ref_count; uint32_t flags; char data[64]; }; struct resource_pool { struct resource_node *nodes; uint32_t capacity; uint32_t active_count; }; struct pool_context { ...	50bc87462639f82fb51480cbf71d95e5deab9736688bd52ec2a132a842d17f7c	135	gemma-4-31b-it	A	ReposVul	CVE-2013-4483	torvalds/linux	https://github.com/torvalds/linux	6062a8dc0517bce23e3c2f7d2fea5e22411269a3	[ "CWE-416" ]	assigned	[ "CWE-189" ]	[ "CWE-416", "CWE-825" ]	esbmc	memory-safety:lifetime	dereference failure: invalidated dynamic object	node_set_flag	65	65	node->flags \|= flag;	true	8.4.0	FAILED	null	7	290	4,096	306.31	confirmed_exact	heap-use-after-free	43	search	false	false	false	false	2026-10-11
79be5c6e-8e55-4ef7-86e2-0382a28dd790	b29dcd9b-18bb-4fc9-9b1a-912847016aee	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> struct session_ctx { uint32_t session_id; uint16_t flags; int active; }; struct request_node { uint32_t req_id; uint16_t priority; struct session_ctx ctx; void (handler)(struct request_node *); struct requ...	971133368cf0c0b9cd1cdfa50390e90d69a06eea658e995a4c1aed8220a5cc22	144	gemma-4-31b-it	A	ReposVul	CVE-2011-2491	torvalds/linux	https://github.com/torvalds/linux	0b760113a3a155269a3fba93a409c640031dd68f	[ "CWE-416" ]	assigned	[ "CWE-399", "CWE-400" ]	[ "CWE-416", "CWE-825" ]	esbmc	memory-safety:lifetime	dereference failure: invalidated dynamic object	handle_auth_verify	34	34	node->ctx->flags \|= 0x02;	true	8.4.0	FAILED	null	1	290	4,096	318.84	confirmed_class	heap-use-after-free	180	search	false	false	false	false	2026-10-11
7fc72a3a-15fe-40b7-bb8e-fae7236f8059	5c0982c2-b0bf-47d3-8e71-32a4b2c34909	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> struct resource_meta { uint32_t id; uint32_t ref_count; uint32_t flags; int active; }; struct resource_node { struct resource_meta meta; void *data; size_t data_size; }; struct resource_manager { struct res...	966d21cd28d22eacb3db99e97f729b915256ff27f23ecc733cfcfe5b0bf8290d	165	gemma-4-31b-it	A	ReposVul	CVE-2013-4483	torvalds/linux	https://github.com/torvalds/linux	6062a8dc0517bce23e3c2f7d2fea5e22411269a3	[ "CWE-415" ]	assigned	[ "CWE-189" ]	[ "CWE-120", "CWE-787" ]	rules	memory-safety:bounds	buffer overflow on sscanf	main	146	146	if (sscanf(input_buf, "%u %s", &id, data_val) == 2) {	true	8.4.0	FAILED	null	1	290	4,096	298.03	confirmed_exact	stack-buffer-overflow	16	afl	false	false	true	false	2026-10-11
d667b0fa-fe7e-4ce1-a222-99f0c1dd95e2	36940e39-e091-4df2-b94e-f0d6ffb895ad	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> #define MAX_REGISTRY_ENTRIES 16 #define BUFFER_CAPACITY 256 #define REGISTRY_MAGIC 0x52454749 typedef enum { CMD_GET_METADATA = 0, CMD_GET_STATUS = 1, CMD_GET_CONFIG = 2, CMD_GET_LOGS = 3, CMD_GET_STATS = 4, CMD_MAX...	aa5667c704a5813427223567dbbe28858b73cb6b7fa09b411ba7a036849e443b	191	gemma-4-31b-it	A	ReposVul	CVE-2013-4588	torvalds/linux	https://github.com/torvalds/linux	04bcef2a83f40c6db24222b27a52892cba39dffb	[ "CWE-119" ]	seed	[ "CWE-119" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	array bounds violated: array `op_arg_sizes' upper bound	dispatch_registry_op	113	113	size_t required_arg_size = op_arg_sizes[op_code];	true	8.4.0	FAILED	null	141	590	8,192	263.68	confirmed_exact	array-bounds	34	search	false	false	false	false	2026-10-11
f9006f5d-8a20-486f-9815-c51a255982ef	f3a4823a-48f6-40d4-9250-bfd9ac9147ba	null	[]	SAFE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define PAGE_SIZE 4096 #define PAGE_MASK (~(PAGE_SIZE - 1)) #define MAX_REGION_SIZE 0x1000000 typedef struct { uintptr_t base_addr; size_t size; } mem_region_t; typedef struct { mem_region_t primary; mem_region_t secondary...	eb69ad3de5a14fcae534d4bc844fba5066b2229131168f80005379108a605a98	138	gemma-4-31b-it	A	ReposVul	CVE-2013-2596	torvalds/linux	https://github.com/torvalds/linux	fc9bbca8f650e5f738af8806317c0a041a48ae4a	[]	null	[ "CWE-189" ]	[]	null	safe	null	null	null	null	null	null	8.4.0	SUCCESSFUL	forward condition	65	290	4,096	279.26	no_crash_found	null	10,716	null	false	false	false	false	2026-10-11
4ca28792-9fa7-4c57-bdf2-f132ac1fe82f	c8783ec1-3744-4642-b783-ae4c01a6e054	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> typedef enum { MSG_TYPE_DATA = 1, MSG_TYPE_CONTROL = 2, MSG_TYPE_HEARTBEAT = 3, MSG_TYPE_SYNC = 4 } msg_type_t; typedef enum { STATUS_OK = 0, STATUS_ERROR_BUFFER, STATUS_ERROR_PROTOCOL, STATUS_ERROR_DISPATCH...	f4e27ef4b5547ab5cad03feba34d8125fa3588e37a046e10cf5a5c999859b599	206	gemma-4-31b-it	A	ReposVul	CVE-2013-2017	torvalds/linux	https://github.com/torvalds/linux	6ec82562ffc6f297d0de36d65776cff8e5704867	[ "CWE-416" ]	assigned	[ "CWE-399" ]	[ "CWE-416", "CWE-825" ]	esbmc	memory-safety:lifetime	dereference failure: invalidated dynamic object	route_frame	127	127	update_node_metrics(link->target_node, msg->header.length, (status == STATUS_OK));	true	8.4.0	FAILED	null	14	290	4,096	406.44	confirmed_exact	heap-use-after-free	45	search	false	false	false	false	2026-10-11
cd0da928-41c2-4ca9-bd0f-375083780c7c	a99c378c-4ab6-4883-b9e0-9974d65df594	null	[]	SAFE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define MAX_REGION_COUNT 16 #define PAGE_SIZE 4096 #define REGION_ALIGN 0x1000 typedef struct { uint64_t start_gpa; uint64_t size; void *host_ptr; } mem_region_t; typedef struct { mem_region_t regions[MAX_REGION_COUNT]; ...	d251fa45c61ded2b83fd6c81c7eb2158f29e38b3b935144d44d77ecb6b21cd9f	202	gemma-4-31b-it	A	ReposVul	CVE-2013-1797	torvalds/linux	https://github.com/torvalds/linux	0b79459b482e85cb7426aa7da683a9f2c97aeae1	[]	null	[ "CWE-399" ]	[]	null	safe	null	null	null	null	null	null	8.4.0	SUCCESSFUL	forward condition	17	290	4,096	332.64	no_crash_found	null	10,510	null	false	false	false	false	2026-10-11
316237aa-a5c3-493c-a683-aa73a35a8821	c9291e84-c27a-45d3-bca0-13690164edff	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> #define MAGIC_NUMBER 0xdeadbeefU #define MAX_FILENAME 256 #define MAX_RECORD_SIZE 4096 struct file_header { uint32_t magic; uint32_t num_records; uint32_t record_size; }; static int read_filename(char *buf, size_t sz) { if...	279efb1a58daae3abe7eefbe654b475aa79d9652c54ceb10f8ae8207bc2dcc81	103	gpt-oss-120b	A	ReposVul	CVE-2011-3209	torvalds/linux	https://github.com/torvalds/linux	f8bd2258e2d520dff28c855658bd24bdafb5102d	[ "CWE-190" ]	assigned	[ "CWE-189" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	__memcpy_impl	286	58	size_t rec_sz = hdr->record_size;	false	8.4.0	FAILED	null	13	290	4,096	307.55	confirmed_class	heap-buffer-overflow	20	seeded	false	false	false	true	2026-10-11
32233b4a-b30e-4c57-8431-2f234e84f3da	c4c692d3-8675-427c-9971-9d84e8f30761	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> struct LogHeader { uint32_t magic; uint32_t record_count; }; struct RecordHeader { uint16_t type; uint16_t length; }; static inline int read_uint32(FILE f, uint32_t out) { uint8_t buf[4]; if (fread(buf, 1, 4, f) ...	fef4cb546e4cee56126ca9145e22070426f520acc0c131c99f5d5b51ae84fa00	121	gpt-oss-120b	A	ReposVul	CVE-2013-4483	torvalds/linux	https://github.com/torvalds/linux	6062a8dc0517bce23e3c2f7d2fea5e22411269a3	[ "CWE-190" ]	assigned	[ "CWE-189" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	fread	209	71	size_t len = (size_t)rhdr.length;	false	8.4.0	FAILED	null	8	290	4,096	270.64	confirmed_class	heap-buffer-overflow	72	search	false	false	false	true	2026-10-11
39fd2edd-6ec9-4333-a161-15397b050880	dd697783-fe2b-45b8-b3ef-0b4e868e5364	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define LOG_MAGIC 0x4C4F4746 #define MAX_TOTAL_SIZE 1048576 #define MAX_RECORDS 1024 typedef struct { uint32_t magic; uint16_t version; uint32_t payload_len; } file_header_t; typedef struct { uint32_t type; uint32_t le...	b9162c30d9e11a45a598f449a988f1633b7a984a0d41cdfa80be5a2d0a5c3b4c	128	gpt-oss-120b	A	ReposVul	CVE-2011-2918	torvalds/linux	https://github.com/torvalds/linux	a8b0ca17b80e92faab46ee7179ba9e99ccb61233	[ "CWE-119" ]	assigned	[ "CWE-400" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	fread	209	105	size_t buf_size = compute_buffer_size(hdr.payload_len);	false	8.4.0	FAILED	null	13	290	4,096	289.95	confirmed_class	heap-buffer-overflow	1,045	search	false	false	false	true	2026-10-11
979dfb5f-fd1c-4ac5-832c-3ca5c212b0f3	2b6301d6-cca1-4eb3-bbb2-5e8cf8a29883	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct ConfigEntry { char key; char value; struct ConfigEntry next; } ConfigEntry; static ConfigEntry config_head = NULL; static void trim_whitespace(char s) { char end; while (s && (s == ' ' \|\| s == '\t' \|\| s == '\n' \|\|...	6e41ef92a4dd8923c213fb33ba9b06e2f57f74766b304b350011c390f2d7d460	116	gpt-oss-120b	A	ReposVul	CVE-2011-0991	mono/mono	https://github.com/mono/mono	89d1455a80ef13cddee5d79ec00c06055da3085c	[ "CWE-590" ]	assigned	[ "CWE-399" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	trim_whitespace	18	18	while (end > s && (end == ' ' \|\| end == '\t' \|\| end == '\n' \|\| end == '\r')) *end-- = '\0';	true	8.4.0	FAILED	null	2	290	4,096	4.49	other_defect	stack-use-after-return	1,518	search	false	false	false	false	2026-10-11
9c72ccef-ef68-400e-88fe-1ffbbd6b1f07	e72c3e03-a854-428d-81a4-800b93e55ceb	null	[ "19d3c005-2228-4bae-b775-e82fa8b130a0" ]	SAFE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> #define MAX_REGISTRY_ENTRIES 64 #define ADDR_SIZE 16 #define PROTOCOL_ID 0x5A typedef enum { STATE_IDLE, STATE_ACTIVE, STATE_ZAPPED, STATE_CLOSED } node_state_t; typedef struct { uint8_t hardware_addr[ADDR_SIZE]; u...	fb2a7122c13a86cfb467b631c4eac72072e824a0a877bb8ac991bc23d6e7fe0a	152	gemma-4-31b-it	A	ReposVul	CVE-2012-6542	torvalds/linux	https://github.com/torvalds/linux	3592aaeb80290bda0f2cf0b5456c97bfc638b192	[ "CWE-476" ]	null	[ "CWE-200" ]	[]	null	safe	null	null	null	null	null	null	8.4.0	SUCCESSFUL	forward condition	17	290	4,096	376.77	no_crash_found	null	8,433	null	false	false	false	false	2026-10-11
283ee43b-8d4e-4e0b-9f5b-8cb1d446b575	86434eae-6b69-47a7-9107-8ef38a647e50	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> struct entry { char key; char value; struct entry next; }; struct store { struct entry head; }; static struct store create_store(void) { struct store s = (struct store *)malloc(sizeof(struct store)); if (!s) ...	ded6cae688607870b0559f3a51f5882ce332d2f4f434b618df186ec63932ac57	173	gpt-oss-120b	A	ReposVul	CVE-2013-4483	torvalds/linux	https://github.com/torvalds/linux	6062a8dc0517bce23e3c2f7d2fea5e22411269a3	[ "CWE-415" ]	assigned	[ "CWE-189" ]	[ "CWE-416", "CWE-825" ]	esbmc	memory-safety:lifetime	dereference failure: invalidated dynamic object	free_entry	31	31	free(e->key);	true	8.4.0	FAILED	null	2	290	4,096	276.6	confirmed_exact	heap-use-after-free	20	seeded	false	false	false	true	2026-10-11
82bf2931-58a6-4f92-a91c-5126a53fc72d	4be6fc48-e1c0-4e3f-908c-b1e81eef759f	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define MAX_RECORDS 1024 #define MAX_FILE_SIZE (10 * 1024 * 1024) typedef struct Record { uint8_t type; uint32_t length; void data; struct Record next; } Record; static int read_uint8(FILE f, uint8_t out) { unsigne...	ec7e210cee412ccedd35245f03236b946b1babc9ce84240bd879f2e6511809c3	154	gpt-oss-120b	A	ReposVul	CVE-2011-2918	torvalds/linux	https://github.com/torvalds/linux	a8b0ca17b80e92faab46ee7179ba9e99ccb61233	[ "CWE-415" ]	assigned	[ "CWE-400" ]	[ "CWE-415", "CWE-416", "CWE-590", "CWE-761", "CWE-825" ]	esbmc	memory-safety:lifetime	dereference failure: invalidated dynamic object freed	cleanup_record	130	130	free(r->data);	true	8.4.0	FAILED	null	5	290	4,096	284.3	confirmed_exact	attempting double-free	22	seeded	false	false	false	true	2026-10-11
592398a4-e93f-4f2f-8e62-09b7520d75a0	b7d20c71-828d-4a92-aa9f-cfce53ea791c	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> typedef struct { uint32_t magic; uint16_t version; uint16_t record_count; } Header; typedef struct { uint32_t id; uint32_t length; uint8_t data; } Record; static int read_uint32(FILE f, uint32_t *out) { size_t r = fread(out, 1, ...	fb941ecbfc10223ec03c3ed80afd573c43e97841b603c6b347274b25e415f163	149	gpt-oss-120b	A	ReposVul	CVE-2011-2918	torvalds/linux	https://github.com/torvalds/linux	a8b0ca17b80e92faab46ee7179ba9e99ccb61233	[ "CWE-590" ]	assigned	[ "CWE-400" ]	[ "CWE-590", "CWE-761" ]	esbmc	memory-safety:lifetime	dereference failure: free() of non-dynamic memory	cleanup_record	111	111	free(rec->data);	true	8.4.0	FAILED	null	5	290	4,096	373.47	other_defect	leak	72	search	false	false	false	false	2026-10-11
87c4ae11-af31-45d7-b191-89f1a683a601	58239067-1e52-4ca4-8ed0-6b9f14354123	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define HEADER_MAGIC 0xdeadbeefU #define HEADER_SIZE 12U #define MAX_FILE_SIZE (1U << 30) struct PacketHeader { uint32_t magic; uint32_t total_len; uint16_t type; uint16_t reserved; }; struct Packet { uint32_t total_le...	625baaac95b615e23cd36ffe22136cd186ce33fb37cbe3418d382f07e8a6f8b4	123	gpt-oss-120b	A	ReposVul	CVE-2013-4470	torvalds/linux	https://github.com/torvalds/linux	e93b7d748be887cd7639b113ba7d7ef792a7efb9	[ "CWE-125" ]	assigned	[ "CWE-264" ]	[ "CWE-476" ]	esbmc	memory-safety:null	dereference failure: NULL pointer	compute_checksum	80	80	sum += pkt->data[i];	true	8.4.0	FAILED	null	13	290	4,096	370.93	other_defect	heap-buffer-overflow	525	search	false	false	false	true	2026-10-11
c63abc29-c049-4eb5-aca8-e25949b45d72	c8783ec1-3744-4642-b783-ae4c01a6e054	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define MAX_PACKETS 100 #define MAX_DATA 256 typedef struct { uint32_t length; uint8_t flags; char *data; } Packet; typedef struct { uint64_t tx_bytes; uint64_t tx_packets; uint64_t tx_dropped; uint64_t rx_byte...	59db8a26efc03b59e5d9b549c3fe60de1d265c473eff82a91fa90cdfe9b3a339	169	gpt-oss-120b	A	ReposVul	CVE-2013-2017	torvalds/linux	https://github.com/torvalds/linux	6ec82562ffc6f297d0de36d65776cff8e5704867	[ "CWE-416" ]	assigned	[ "CWE-399" ]	[ "CWE-401" ]	esbmc	resource-leak	dereference failure: forgotten memory: dynamic_11_value	main	169	169	}	true	8.4.0	FAILED	null	2	290	4,096	317.15	confirmed_class	leak	935	search	false	false	false	true	2026-10-11
ba0e1819-9765-4563-9c46-ecd24b6436d4	fbf0c8ad-19b5-4340-8e73-75f29926cc78	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> typedef enum { CONN_IDLE, CONN_AUTHENTICATING, CONN_ESTABLISHED, CONN_FAILED } conn_state_t; typedef enum { MSG_TYPE_HEARTBEAT, MSG_TYPE_DATA, MSG_TYPE_CONTROL, MSG_TYPE_DISCONNECT } msg_type_t; struct sessi...	43011adcfcb630ceb4383b50d0a09d817cf6fb184b34eee69bef23d10bd39b48	206	gemma-4-31b-it	A	ReposVul	CVE-2013-0281	clusterlabs/pacemaker	https://github.com/ClusterLabs/pacemaker	564f7cc2a51dcd2f28ab12a13394f31be5aa3c93	[ "CWE-401" ]	assigned	[ "CWE-399" ]	[ "CWE-401" ]	esbmc	resource-leak	dereference failure: forgotten memory: dynamic_355_value	main	206	206	}	true	8.4.0	FAILED	null	13	290	4,096	404.27	confirmed_class	leak	62	seeded	false	false	false	false	2026-10-11
63618ac9-76ca-478c-8a7c-3420e49e4c10	b83d2554-993c-42fc-87db-be766ec93ab5	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define LOG_MAGIC 0x4C4F474F #define MAX_ENTRIES 1024 #define MAX_DATA_SIZE 4096 enum { TYPE_DATA = 1, TYPE_SKIP = 2, TYPE_END = 3 }; struct LogHeader { uint32_t magic; uint32_t version; uint32_t entry_count; }; ...	b50555d2ae1df0e6c875cca6a8b54002afa047afece99240e0eb3d5739f68c1d	187	gpt-oss-120b	A	ReposVul	CVE-2011-2918	torvalds/linux	https://github.com/torvalds/linux	a8b0ca17b80e92faab46ee7179ba9e99ccb61233	[ "CWE-401" ]	assigned	[ "CWE-400" ]	[ "CWE-401" ]	esbmc	resource-leak	dereference failure: forgotten memory: dynamic_1_value	main	187	187	}	true	8.4.0	FAILED	null	1	290	4,096	310.66	confirmed_class	leak	42	search	false	false	false	true	2026-10-11
fe0a8ed1-177c-4d34-92de-a87527221365	b6590a1e-ae97-4c28-95e4-23d79e6a591e	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define MAX_PACKETS 64 #define MAX_PAYLOAD 4096 #define TMP_BUFFER_SIZE 256 #define SPECIAL_TYPE 0xFFFFFFFFU typedef struct { uint32_t type; uint32_t length; uint8_t data; } Packet; typedef struct { uint8_t tmp; Pack...	3c289c63776f94a6baa8f0e46de7e578b74c2df28d738a65f5a9783822be40c8	169	gpt-oss-120b	A	ReposVul	CVE-2013-4350	torvalds/linux	https://github.com/torvalds/linux	95ee62083cb6453e056562d91f597552021e6ae7	[ "CWE-415" ]	assigned	[ "CWE-310" ]	[ "CWE-415", "CWE-416", "CWE-590", "CWE-761", "CWE-825" ]	esbmc	memory-safety:lifetime	dereference failure: invalidated dynamic object freed	release_context	99	99	if (ctx->tmp) free(ctx->tmp);	true	8.4.0	FAILED	null	5	290	4,096	333.04	confirmed_exact	attempting double-free	217	search	false	false	false	true	2026-10-11
38821b93-7481-4ad7-92ec-0249b3fe666d	9b31c046-88f6-4ad0-993c-ab81e5265046	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define MAGIC_NUMBER 0x4C4F474F #define MAX_RECORDS 1024 #define MAX_PATH 256 struct FileHeader { uint32_t magic; uint16_t version; uint16_t rec_count; }; struct RecordHeader { uint32_t timestamp; uint16_t type; ui...	4112ab6e650ecee6c0b96b9436dad999f9ba358489dc4c6a2e8337286e41d6d8	172	gpt-oss-120b	A	ReposVul	CVE-2013-4254	torvalds/linux	https://github.com/torvalds/linux	c95eb3184ea1a3a2551df57190c81da695e2144b	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	assigned	[ "CWE-20" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	fread	209	68	size_t need = raw_len;	false	8.4.0	FAILED	null	5	290	4,096	240.5	confirmed_class	heap-buffer-overflow	240	search	false	false	false	true	2026-10-11
52dd24e2-430a-484d-be37-a99517b1abb6	155ba72f-1b37-4170-81d3-516154b29252	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #include <errno.h> typedef struct Record { uint8_t type; uint16_t length; uint8_t data; struct Record next; } Record; static uint32_t read_uint32(FILE *f) { uint8_t buf[4]; if (fread(buf, 1, 4, f) != 4) return 0; ...	d0eb59b6036735fe7b26123682ce1bc3896a9bfbd26604b60be96247bde99deb	149	gpt-oss-120b	A	ReposVul	CVE-2012-6607	hercules-team/augeas	https://github.com/hercules-team/augeas	163877441402e464266b45ee98e24bb652971def	[ "CWE-401" ]	assigned	[ "CWE-22" ]	[ "CWE-401" ]	esbmc	resource-leak	dereference failure: forgotten memory: dynamic_50_value	main	149	149	}	true	8.4.0	FAILED	null	5	290	4,096	317.58	confirmed_class	leak	132	search	false	false	false	true	2026-10-11
79e6416c-c3d1-42d2-85e0-6f23b9478ed5	c36b4202-8d43-4a6a-b831-f161b7121790	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> #define FILE_MAGIC 0x4D504B47U #define MAX_RECORDS 1024U #define TYPE_A 0x01U #define TYPE_B 0x02U #define TYPE_C 0x03U typedef struct { uint8_t type; uint32_t length; } RecordHeader; static int read_uint32(FILE f, uint32_t out)...	c4c7042febc54fe377021762a32fa5b9472a752103c75a50bb5672c0b62f7116	182	gpt-oss-120b	A	ReposVul	CVE-2011-1768	torvalds/linux	https://github.com/torvalds/linux	d5aa407f59f5b83d2c50ec88f5bf56d40f1f8978	[ "CWE-119" ]	assigned	[ "CWE-362" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	fread	209	96	void *buf = allocate_buffer_small(truncated);	false	8.4.0	FAILED	null	9	290	4,096	294.48	confirmed_class	heap-buffer-overflow	27	seeded	false	false	false	true	2026-10-11
549d94c5-3ef4-44ec-99c3-7606cdddf549	610e13ab-d0bf-4348-a1f8-4a2917c1c3bf	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> #define LOG_MAGIC 0x4C4F4746 #define MAX_RECORDS 1024 #define MAX_PAYLOAD 1048576 struct LogHeader { uint32_t magic; uint32_t record_count; }; struct Record { uint32_t id; uint16_t length; char *data; }; static struct...	05b9d9a510cdaa1ee5f6b3e410583f94ca4e19ea8b9f262b3c49bc2f68f724ab	238	gpt-oss-120b	A	ReposVul	CVE-2011-4086	torvalds/linux	https://github.com/torvalds/linux	15291164b22a357cb211b618adfef4fa82fc0de3	[ "CWE-119" ]	seed	[ "CWE-119" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	fread	209	95	rec->data = (char *)malloc(rec->length);	false	8.4.0	FAILED	null	5	590	8,192	467.71	other_defect	leak	94	search	false	false	false	true	2026-10-11
8089ad94-128b-4e25-82f3-229f14c22ebb	75f69f65-d03e-407a-9814-023d3a9ee0a5	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define MAGIC_NUMBER 0x4D41524B #define MAX_RECORD_SIZE 1024 #define MAX_TOTAL_SIZE (1U << 30) typedef struct { uint32_t magic; uint32_t rec_cnt; uint32_t rec_size; } raw_header_t; typedef struct { uint32_t magic; uint...	d055c6c1156260d885bb91a0c63592227314f6f276f414812326cbc06bac4fb4	146	gpt-oss-120b	A	ReposVul	CVE-2011-2918	torvalds/linux	https://github.com/torvalds/linux	a8b0ca17b80e92faab46ee7179ba9e99ccb61233	[ "CWE-190" ]	assigned	[ "CWE-400" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	fread	209	78	size_t need = (size_t)raw->rec_cnt * raw->rec_size;	false	8.4.0	FAILED	null	13	290	4,096	328.91	confirmed_class	segv	23	seeded	false	false	false	true	2026-10-11
71172d64-b5e7-4a8f-81bb-bf4eaafa9ff1	107050ef-09cd-4193-adb9-a7ca8f8aa77d	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> typedef enum { OP_READ, OP_WRITE, OP_SYNC, OP_RESET } op_type_t; typedef struct { uint32_t id; uint32_t offset; uint32_t length; op_type_t type; } command_t; typedef struct { uint8_t *data; size_t c...	028ca17cdefd064c6ea5472abfe0ac054cea96628b6a4a705c452722b6325cb0	223	gemma-4-31b-it	A	ReposVul	CVE-2011-2918	torvalds/linux	https://github.com/torvalds/linux	a8b0ca17b80e92faab46ee7179ba9e99ccb61233	[ "CWE-415", "CWE-416", "CWE-590", "CWE-761", "CWE-825" ]	assigned	[ "CWE-400" ]	[ "CWE-415", "CWE-416", "CWE-590", "CWE-761", "CWE-825" ]	esbmc	memory-safety:lifetime	dereference failure: invalid pointer freed	fclose	122	160	ctx->total_processed = 0;	false	8.4.0	FAILED	null	17	290	4,096	324.48	confirmed_class	segv	20	afl	false	false	false	false	2026-10-11
264be9b9-c7dd-43e1-a4f7-38638d1db0ea	e72c3e03-a854-428d-81a4-800b93e55ceb	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define MAX_FILE_SIZE (1024 * 1024) #define MAX_SECTIONS 1024 #define MAGIC_NUMBER 0x4D504B47U struct Header { uint32_t magic; uint32_t version; uint32_t flags; uint32_t section_count; }; struct Meta { uint32_t id; ...	cefbced250e5bbb4942e567fa4dd8e5ab013898fe222e6a95c210b7b176abe9c	140	gpt-oss-120b	A	ReposVul	CVE-2012-6542	torvalds/linux	https://github.com/torvalds/linux	3592aaeb80290bda0f2cf0b5456c97bfc638b192	[ "CWE-476" ]	assigned	[ "CWE-200" ]	[ "CWE-401" ]	esbmc	resource-leak	dereference failure: forgotten memory: dynamic_2_array	main	140	140	}	true	8.4.0	FAILED	null	1	290	4,096	309.33	confirmed_class	leak	36	search	false	false	false	true	2026-10-11
514458a7-8111-4c6c-b601-551b55477b66	2ad6db3c-9ca8-45a6-b001-76fab22cf318	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define MAX_RECORDS 1024 #define MAX_DATA_SIZE 65535 struct Record { uint32_t id; uint16_t data_len; uint8_t data; struct Record next; }; static FILE open_input(void) { FILE f = fopen("input.bin", "rb"); return...	87f35b93ad903ba5a82451017d547154146a1b8a931f2e44a6ea0b21d819b756	182	gpt-oss-120b	A	ReposVul	CVE-2013-1943	torvalds/linux	https://github.com/torvalds/linux	fa3d315a4ce2c0891cdde262562e710d95fba19e	[ "CWE-401" ]	assigned	[ "CWE-20" ]	[ "CWE-401" ]	esbmc	resource-leak	dereference failure: forgotten memory: dynamic_53_array	main	182	182	}	true	8.4.0	FAILED	null	5	290	4,096	303.4	confirmed_class	leak	30	seeded	false	false	false	true	2026-10-11
22323f2e-5dee-439c-beee-276a781cf921	b798b8cc-53ce-46b2-b7ac-e600dfca4653	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define MAGIC_NUMBER 0x4D4C4B44U #define HEADER_OVERHEAD 8U #define MAX_RECORDS 1024U struct RecordHeader { uint32_t id; uint32_t len; }; struct Record { uint32_t id; uint8_t *data; uint32_t len; }; static int read_ui...	873ac595685425d971ec22de32a0bff6f8e7ca4b21303252def55323cd4f7a98	156	gpt-oss-120b	A	ReposVul	CVE-2011-2918	torvalds/linux	https://github.com/torvalds/linux	a8b0ca17b80e92faab46ee7179ba9e99ccb61233	[ "CWE-190" ]	assigned	[ "CWE-400" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	fread	209	119	uint8_t *buf = allocate_buffer(bufsize);	false	8.4.0	FAILED	null	5	290	4,096	374.31	confirmed_class	heap-buffer-overflow	736	search	false	false	false	false	2026-10-11
554ac91e-8639-43ff-a871-630386aaa175	38403d52-776c-4124-9f9b-924e525c5557	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> #define MAGIC_NUMBER 0x4D504B47 #define MAX_RECORDS 1024 #define TYPE_A 0x01 #define TYPE_B 0x02 #define TYPE_C 0x03 struct FileHeader { uint32_t magic; uint16_t version; uint16_t reserved; uint32_t record_count; }; struct...	a11d3fccd381db7497263cb3bc5a681fe29cb491733e87072c485af2b90d5122	262	gpt-oss-120b	A	ReposVul	CVE-2012-2745	torvalds/linux	https://github.com/torvalds/linux	79549c6dfda0603dba9a70a53467ce62d9335c33	[ "CWE-119" ]	seed	[ "CWE-119" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	fread	209	76	uint16_t truncated = (uint16_t)length;	false	8.4.0	FAILED	null	11	290	4,096	243.25	confirmed_class	heap-buffer-overflow	20	seeded	false	false	false	true	2026-10-11
d49b64b8-222e-4028-8759-6702d0eae68e	8ba222d2-4d46-44a7-979a-2119d15205a9	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define MAGIC_NUMBER 0x4D544C46U #define MAX_RECORDS 1024 #define MAX_PAYLOAD_SIZE 1048576U typedef struct { uint32_t magic; uint32_t payload_len; uint16_t version; uint16_t flags; } Header; typedef struct { uint8_t *d...	78b681aa242575173a423731b8ec24787d520c3b3345c10bc2a81d8f53a0532f	191	gpt-oss-120b	A	ReposVul	CVE-2011-2918	torvalds/linux	https://github.com/torvalds/linux	a8b0ca17b80e92faab46ee7179ba9e99ccb61233	[ "CWE-787" ]	assigned	[ "CWE-400" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	fread	209	68	ctx->payload.data = allocate_memory_uint16((uint16_t)hdr->payload_len);	false	8.4.0	FAILED	null	5	290	4,096	308.69	confirmed_class	null-deref	121	search	false	false	false	true	2026-10-11
e84088a4-29c2-4bd5-bf24-8325116d4aa8	3b5fadd9-4161-4e16-84b3-a6c8228fa052	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define FILE_MAGIC 0x4D504B47U #define FILE_VERSION 1U #define MAX_PAYLOAD_LIMIT 0xFFFFFFFFU typedef struct { uint32_t magic; uint32_t version; uint32_t payload_len; } FileHeader; typedef struct { uint8_t *data; size_t...	316730e5e91ca63dc1f173b6a0e247e38f534837ca72db92b080832963904b93	189	gpt-oss-120b	A	ReposVul	CVE-2013-1819	torvalds/linux	https://github.com/torvalds/linux	eb178619f930fa2ba2348de332a1ff1c66a31424	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	assigned	[ "CWE-20" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	write_footer	127	127	p[payload_len] = 0xFF;	true	8.4.0	FAILED	null	13	290	4,096	283.45	confirmed_exact	heap-buffer-overflow	23	seeded	false	false	false	true	2026-10-11
6233dcf6-c93b-4149-a0d9-3c98e807bd9c	3ca0d013-747f-412e-9ea2-e99401f12c08	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> struct FileHeader { uint32_t magic; uint32_t version; uint32_t entry_count; }; struct Entry { uint32_t id; uint32_t value; }; struct Table { uint16_t entry_count; struct Entry entries; }; static int read_uint32_be(FILE f, uint3...	29f9c10203970e3e726db05bc667e1b3d242e5d0122c2dede058178b23cb4ae9	204	gpt-oss-120b	A	ReposVul	CVE-2013-4129	torvalds/linux	https://github.com/torvalds/linux	c7e8e8a8f7a70b343ca1e0f90a31e35ab2d16de1	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	assigned	[ "CWE-20" ]	[ "CWE-121", "CWE-125", "CWE-129", "CWE-131", "CWE-193", "CWE-787" ]	esbmc	memory-safety:bounds	dereference failure: array bounds violated	read_entries	115	115	tbl->entries[i] = tmp;	true	8.4.0	FAILED	null	5	290	4,096	308.97	confirmed_exact	heap-buffer-overflow	16	seeded	false	false	false	true	2026-10-11
79c33fba-b5b0-42dc-892c-e0cf1f64fe54	2aeb043f-8b2a-4651-80d7-ebf420666462	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> typedef struct Record { uint8_t type; uint16_t length; uint8_t data; struct Record next; } Record; typedef struct Log { uint32_t count; Record head; Record tail; uint64_t total_bytes; uint32_t type_c...	b96df6bde96970298dd23929131fd248f581a7bf3ba87191194639c5df111cd2	209	gpt-oss-120b	A	ReposVul	CVE-2011-2918	torvalds/linux	https://github.com/torvalds/linux	a8b0ca17b80e92faab46ee7179ba9e99ccb61233	[ "CWE-401" ]	assigned	[ "CWE-400" ]	[ "CWE-401" ]	esbmc	resource-leak	dereference failure: forgotten memory: dynamic_41_value	main	209	209	}	true	8.4.0	FAILED	null	5	290	4,096	472.96	confirmed_class	leak	55	search	false	false	false	false	2026-10-11
54ad2c29-d95f-4e3a-ac30-cd84ee00847e	a977ecd7-12de-4e46-9044-9e27c75e9f3f	null	[]	VULNERABLE	c	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #define MAX_RECORDS 1024 #define MAX_SECTIONS 256 #define TYPE_CREATE 1 #define TYPE_DELETE 2 #define TYPE_READ 3 #define TYPE_UPDATE 4 struct Record { uint32_t id; uint16_t data_len; uint8_t data; }; static struct Record re...	298fe60450dd16fd3d28c28881cf76068f97c631d44c3764acbc8e103a9d2a25	211	gpt-oss-120b	A	ReposVul	CVE-2011-4914	torvalds/linux	https://github.com/torvalds/linux	e0bccd315db0c2f919e7fcf9cb60db21d9986f52	[ "CWE-416" ]	assigned	[ "CWE-20" ]	[ "CWE-190", "CWE-191" ]	esbmc	ub:shift	arithmetic overflow on shl	read_u32	37	37	return (uint32_t)(b1 << 24 \| b2 << 16 \| b3 << 8 \| b4);	true	8.4.0	FAILED	null	1	290	4,096	322.9	confirmed_exact	shift	25	seeded	false	false	false	true	2026-10-11

End of preview. Expand in Data Studio

VeriVul

13,908 self-contained programs (10,225 vulnerable, 3,683 safe) that LLMs generated from real CVE seed functions of ReposVul and ICVul. Each program has an ESBMC 8.4 verdict. C and C++ programs also have a sanitizer record. The language mix is C 87.4%, C++ 12.2% and Python 0.4%.

Paper: VeriVul: A Verification-Guided Framework for Generating Realistic Vulnerability Benchmarks, NeurIPS 2026 Evaluations and Datasets Track.

Configurations

Config	Split	Contents
`default`	train	all programs, scalar fields
`full`	train	all programs with nested verifier, sanitizer and flag records
`strict`	train	13,608 programs without flags
`c_cpp`, `python`	train	13,851 C and C++ programs, 57 Python programs
`pairs`	train	102 verified vulnerable and safe pairs
`eval_seed_matched_400`	test	400 pairs, 50 for each of eight CWEs
`eval_verified_pairs_98`	test	98 verified minimal-edit pairs

from datasets import load_dataset
ds = load_dataset("qcri/verivul-dataset", "strict", split="train")
ds = ds.filter(lambda r: r["label"] == "VULNERABLE" and r["language"] == "c")

Labels

SAFE means ESBMC proves that no checked property is violated under the modelling assumptions in the recorded command. VULNERABLE means ESBMC found a violating execution. Both labels describe the program, not its source CVE. For C and C++ a bounded sanitizer search adds evidence but does not prove the verdict. Two groups of programs are flagged: SAFE programs where the search found a failure, and programs with an empty main. The strict config excludes them. Read the datasheet before use.

Files outside the configs

The configs read the parquet files. The repository also holds the raw files. They are not part of any config.

Path	Content
`data/verivul.jsonl`	all programs with nested records (same content as the `full` config)
`data/verivul_sample.jsonl`	100 vulnerable and 100 safe programs
`data/logs/`	full ESBMC logs, witnesses and SARIF results, `esbmc_logs_<batch>_<n>.jsonl.gz`
`data/subsets/`	id lists (`ids_*.txt`), `pairs.jsonl`, `flagged.jsonl`
`data/evaluation/`	the two evaluation sets (`*.jsonl`) and `trigger_ground_truth.jsonl`
`data/comparison/`	evaluation pairs of the comparison corpora, one folder per corpus

Each log shard holds 1,000 programs, one JSON object per line with id, esbmc_log, witness_graphml, witness_yaml, sarif_results and violated_properties. The field verification.log_shard of a program names its shard, and data/logs/index.json maps every id to its shard.

import gzip, json
with gzip.open("data/logs/esbmc_logs_A_000.jsonl.gz", "rt") as f:
    log = json.loads(next(f))
print(log["id"], log["esbmc_log"][-200:])

Comparison corpora

data/comparison/ has the evaluation pairs of ICVul, FormAI, ARVO, TitanVul and Mono that the paper compares with. ICVul (MIT), FormAI (MIT) and ARVO (BSD 2-Clause) are shipped with code and keep their licenses. TitanVul and Mono are not redistributed because no license was found, so their folders hold identifiers and SHA-256 hashes. data/comparison/rebuild_withheld_samples.py rebuilds them from the originals.

More material

The Zenodo record has the same data: https://doi.org/10.5281/zenodo.24021165. The framework repository is https://github.com/qcri/verivul-framework.

License and citation

Data under CC BY 4.0. Seeds derive from ReposVul and ICVul, both MIT. The comparison samples keep the licenses of their sources. See NOTICE and licenses/.

@inproceedings{lekssays2026verivul,
  title     = {VeriVul: A Verification-Guided Framework for Generating Realistic Vulnerability Benchmarks},
  author    = {Lekssays, Ahmed and Mouhcine, Hamza and Khalil, Issa},
  booktitle = {Advances in Neural Information Processing Systems, Evaluations and Datasets Track},
  year      = {2026},
  note      = {Dataset DOI: 10.5281/zenodo.24021165, code: https://github.com/qcri/verivul-framework}
}

Downloads last month: 196