Datasets:

PNU-Infosec
/

RealMythosReasoning-English

cve string	cwe list	project string	label string	self_contained bool	augmented_context string	question string	reasoning string	response string	reasoning_source string	poc_eval dict	review_flag string
CVE-2009-3605	[ "CWE-189" ]	poppler	vulnerable	true	null	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Code Under Analysis ```c void SplashOutputDev::d...	We are required to analyze the provided C/C++ code for security vulnerabilities. The code is the `SplashOutputDev::drawImage` function. Upon careful review, it was found that in the branch handling the `splashModeXBGR8` color mode, there is a mismatch between the allocated memory size and the actual write size. In the...	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <signal.h> #include <stdint.h> typedef unsigned char Guchar; typedef Guchar SplashColor; static Guchar colToByte(Guchar c) { return c; } static void gmalloc(size_t size) { return malloc(size); } static void gmallocn(size_t count, size_t s...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly targets the specific allocation-to-write mismatch in SplashOutputDev::drawImage (splashModeXBGR8 case) described in the CVE and the provided vulnerable code snippet. It mirrors the logic flaw exactly.\n\n- Exploitability: 2/5 — The PoC is a standalone simulation of t...	null
CVE-2019-14975	[ "CWE-125" ]	ghostscript	vulnerable	true	null	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Code Under Analysis ```c walk_string(fz_context ...	We are required to analyze the given C/C++ code snippet to determine whether a security vulnerability exists. The code is a function named `walk_string`. Based on the vulnerability category hint (memory boundary and buffer errors), we need to focus on checking array indices, pointer offsets, boundary conditions, etc., ...	#include <stdio.h> #include <stdlib.h> #include <string.h> /* Simulate fz_context. / typedef struct {} fz_context; / Simulate the editable_str structure / struct editable_str { char utf8; int pos; int edited; }; typedef struct editable_str editable_str; /* Simulate fz_chartorune: read the byte pointe...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly targets the heap-based buffer over-read in walk_string due to missing check on str->pos, matching the CVE description and vulnerable code.\n- Exploitability: 5/5 — The PoC constructs a scenario with str->pos = -1, which is a valid demonstration of the missing validat...	null
CVE-2017-15650	[ "CWE-119" ]	musl	vulnerable	false	#include <string.h> #include <sys/socket.h> /* for AF_INET6 / / DNS record type constants (typical values) / #define RR_A 1 #define RR_AAAA 28 #define RR_CNAME 5 / Maximum number of address records storable in the context. This is the only boundary; the actual code does not check it. */ #define MAX_ADDRS...	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Additional Context ```c #include <string.h> #inc...	The provided code is a DNS response parsing callback function `dns_parse_callback`. It is part of a larger resolver infrastructure and stores address records (A, AAAA) into a fixed‑size array `ctx->addrs[]` of length `MAX_ADDRS` (48). The function also handles CNAME records by expanding a domain name into a local b...	#include <stdio.h> #include <string.h> #include <sys/socket.h> /* for AF_INET6 / / DNS record type constants (typical values) / #define RR_A 1 #define RR_AAAA 28 #define RR_CNAME 5 / Maximum number of address records storable in the context. This is the only boundary; the actual code does not check it. *...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly targets CVE-2017-15650 by reproducing the vulnerable `dns_parse_callback` function and demonstrating the buffer overflow in `ctx->addrs[]` due to missing bounds checks.\n- Exploitability: 5/5 — It constructs valid DNS A-record responses (4‑byte addresses) and repeate...	null
CVE-2011-1943	[ "CWE-200" ]	NetworkManager	vulnerable	true	null	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Code Under Analysis ```c destroy_one_secret (gpo...	We are asked to analyze the provided C/C++ code snippet. The code defines a function `destroy_one_secret`, which takes a pointer `data`, casts it to `char *`, calls `g_message` to log the string, then uses `memset` to zero out the secret memory, and finally frees the memory. The first step in the analysis is to identi...	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdarg.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> /* Simulate the g_message function of GLib by writing logs to a specified file. / static FILE log_file = NULL; void g_message(const char *format, ...) { ...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly targets the exact vulnerability: the `destroy_one_secret` function logging a certificate password via `g_message`. It replicates the vulnerable code pattern and demonstrates the secret’s presence in a log file.\n- Exploitability: 5/5 — The code constructs a valid sec...	possible_leak_terms: ['Vulnerable version']
CVE-2018-20103	[ "CWE-835" ]	haproxy	vulnerable	true	null	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Code Under Analysis ```c int dns_read_name(unsig...	We need to analyze the given `dns_read_name` function to determine whether a security vulnerability exists. This function is used to parse domain names in DNS messages, supporting both labels and compression pointers. The focus is on loop exit conditions, recursion depth control, input validity checks, and whether an a...	#define _GNU_SOURCE #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <signal.h> #include <sys/time.h> #include <sys/resource.h> #include <sys/wait.h> #include <time.h> /* The vulnerable version of the dns_read_name function (fully copied from the vulnerable code). */ int dns_read...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly targets the infinite recursion vulnerability in dns_read_name caused by a compressed pointer that points to itself, exactly as described in the CVE.\n- Exploitability: 5/5 — The PoC constructs a minimal, valid DNS-like payload (0xc0 0x00) and calls the vulnerable fun...	null
CVE-2017-13720	[ "CWE-125" ]	libxfont	vulnerable	true	null	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Code Under Analysis ```c PatternMatch(char *pat,...	First, analyze the `PatternMatch` function in the target code. This function is used for pattern matching, where the parameter `pat` is the pattern string, `string` is the string to be matched, and `patdashes` and `stringdashes` are used for dash counting. The function body is an infinite loop that processes `pat` char...	#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/mman.h> #include <unistd.h> #include <signal.h> #define XK_minus '-' static int PatternMatch(char pat, int patdashes, char string, int stringdashes); static int PatternMatch(char pat, int patdashes, char string, int stringdashes) { char...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly targets CVE-2017-13718 by exploiting the missing '\\0' check in the '?' case of the PatternMatch function, using a pattern \"a?b\" and a string placed at a page boundary.\n- Exploitability: 2/5 — The conceptual exploit design is sound (forcing an out-of-bounds read p...	null
CVE-2017-9619	[ "CWE-119" ]	ghostscript	vulnerable	false	#include <stdint.h> #include <string.h> #include <stdio.h> #include <stdlib.h> /* Basic type definitions used in Ghostscript / typedef uint32_t ulong; typedef unsigned int uint; typedef uint32_t gs_glyph; / Structure representing a constant string / typedef struct gs_const_string_s { const unsigned char data;...	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Additional Context ```c #include <stdint.h> #inc...	We are asked to analyze the provided code and determine if a vulnerability exists. The code snippet contains a function `xps_true_callback_glyph_name` that, in the non‑TrueType font branch, directly calls `strlen((char*)pstr->data)` without first checking whether `pstr->data` is `NULL`. If an attacker can cause `pstr->...	#include <stdint.h> #include <string.h> #include <stdio.h> #include <stdlib.h> #include <signal.h> #include <setjmp.h> /* Basic type definitions / typedef uint32_t ulong; typedef unsigned int uint; typedef uint32_t gs_glyph; typedef struct gs_const_string_s { const unsigned char data; unsigned int size; } g...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly targets the NULL pointer dereference in xps_true_callback_glyph_name described in CVE-2017-9619, using the exact vulnerable code path.\n- Exploitability: 5/5 — The PoC sets FontType to a value other than ft_TrueType and provides a string with a NULL data pointer, rel...	null
CVE-2011-4128	[ "CWE-119" ]	savannah	vulnerable	false	#include <stdio.h> #include <stdlib.h> #include <string.h> /* Macro definitions / #define RESUME_FALSE 0 #define RESUME_TRUE 1 #define GNUTLS_E_INVALID_SESSION (-10) #define GNUTLS_E_SHORT_MEMORY_BUFFER (-20) #define GNUTLS_E_SUCCESS 0 / Datum type / typedef struct { unsigned char data; unsigned int ...	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Additional Context ```c #include <stdio.h> #incl...	We are asked to analyze a given C/C++ code snippet (the `gnutls_session_get_data` function with its supporting context) for security vulnerabilities. The context includes definitions, helper functions, and a sample harness. Our task is to determine whether a vulnerability exists, explain root cause, trigger conditions,...	#include <stdio.h> #include <stdlib.h> #include <string.h> #define RESUME_FALSE 0 #define RESUME_TRUE 1 #define GNUTLS_E_INVALID_SESSION (-10) #define GNUTLS_E_SHORT_MEMORY_BUFFER (-20) #define GNUTLS_E_SUCCESS 0 typedef struct { unsigned char *data; unsigned int size; } gnutls_datum_t; struct gnutls_se...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly targets the buffer overflow vulnerability in `gnutls_session_get_data` caused by a missing size check before `memcpy`. It uses a large SessionTicket (1024 bytes) to overflow a small heap buffer, exactly matching the CVE description.\n- Exploitability: 5/5 — The PoC c...	null
CVE-2017-13090	[ "CWE-119" ]	savannah	vulnerable	true	null	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Code Under Analysis ```c fd_read_body (const cha...	We are required to analyze the following C/C++ code to determine whether a security vulnerability exists. This code snippet implements a function `fd_read_body`, which includes handling logic for HTTP chunked transfer encoding. We need to carefully audit the code to identify potential memory boundary errors and constru...	#include <stdint.h> #include <stdbool.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <sys/types.h> #include <errno.h> typedef int64_t wgint; #define MIN(a,b) ((a) < (b) ? (a) : (b)) static void *xmalloc(size_t size) { return malloc(size); } static v...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly replicates the vulnerable wget chunked transfer parsing logic. It constructs a negative chunk length field, exactly as described in the CVE, and demonstrates how that leads to passing an attacker-controlled length to fd_read. The simplified implementation clearly iso...	null
CVE-2013-0292	[ "CWE-20" ]	dbus	vulnerable	true	null	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Code Under Analysis ```c dbus_g_proxy_manager_fi...	We are required to analyze the provided C code to determine whether a security vulnerability exists. In the code, the `dbus_g_proxy_manager_filter` function, when processing D‑Bus signals, does not verify whether the message sender is `DBUS_SERVICE_DBUS` (i.e., `"org.freedesktop.DBus"`) in the branch handling the `Name...	#include <stdio.h> #include <dbus/dbus.h> typedef struct { int dummy; } DBusGProxyManager; static void dbus_g_proxy_manager_replace_name_owner(DBusGProxyManager manager, const char name, const char *prev, ...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly targets the missing sender verification in the dbus_g_proxy_manager_filter function when processing NameOwnerChanged signals, exactly as described in the CVE and vulnerable code.\n- Exploitability: 4/5 — The PoC constructs valid D‑Bus messages and invokes the vulnera...	possible_leak_terms: ['patch']
CVE-2013-2236	[ "CWE-119" ]	savannah	vulnerable	false	#include <stdint.h> #include <stdlib.h> #include <string.h> #include <netinet/in.h> /* OSPF API message types / #define MSG_REGISTER_EVENT 1 / Maximum size of OSPF API message buffer (used on stack) / #define OSPF_API_MAX_MSG_SIZE 4096 / Filter for LSA types, origins and areas */ struct lsa_filter_type { ...	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Additional Context ```c #include <stdint.h> #inc...	The function under analysis, `new_msg_register_event`, is designed to construct a registration event message based on an incoming `lsa_filter_type` pointer. Its implementation first casts a 4096-byte stack buffer `buf` to a `struct msg_register_event` pointer, then calculates the total length `len` based on `filter->nu...	#include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #include <arpa/inet.h> typedef unsigned char u_char; #define MSG_REGISTER_EVENT 1 #define OSPF_API_MAX_MSG_SIZE 4096 struct in_addr { uint32_t s_addr; }; struct lsa_filter_type { uint16_t typemask; uint8_t origin; uin...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 4/5 — The PoC targets the buffer overflow in `new_msg_register_event`, which is the function shown in the provided vulnerable code snippet. However, the CVE description explicitly names `new_msg_lsa_change_notify` as the vulnerable function, so there is a slight mismatch. Nevertheless, the...	null
CVE-2015-3194	[ "CWE-476" ]	openssl	vulnerable	true	null	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Code Under Analysis ```c static RSA_PSS_PARAMS *...	Analyze the provided C/C++ code to determine if there are security vulnerabilities. The code is a function named `rsa_pss_decode`, used for parsing RSA-PSS algorithm parameters. Observing its implementation: after `pss` is successfully decoded, if `pss->maskGenAlgorithm` is not NULL, it uses `OBJ_obj2nid` to check whet...	#include <stdio.h> #include <stdlib.h> #include <openssl/objects.h> #include <openssl/rsa.h> #include <openssl/asn1.h> #include <openssl/x509.h> #include <openssl/err.h> /* Vulnerable version of the rsa_pss_decode function, identical to the CVE-2015-3194 vulnerable code. / static RSA_PSS_PARAMS rsa_pss_decode(const ...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly targets the NULL pointer dereference described in CVE-2015-3194, mimicking the vulnerable rsa_pss_decode function and constructing an ASN.1 RSA PSS signature that lacks the mask generation function parameter.\n- Exploitability: 5/5 — The DER payload correctly models ...	null
CVE-2013-4473	[ "CWE-119" ]	poppler	vulnerable	true	null	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Code Under Analysis ```c bool extractPages (cons...	Analyze the provided code snippet: ```c bool extractPages (const char srcFileName, const char destFileName) { char pathName[1024]; // ... omitted parts ... for (int pageNo = firstPage; pageNo <= lastPage; pageNo++) { sprintf (pathName, destFileName, pageNo); // ... } return true; } ``` A stack buf...	#include <cstdio> #include <cstring> #include <cstdlib> class GooString { public: char cstr; GooString(const char s) { cstr = strdup(s); } ~GooString() { free(cstr); } }; class PDFDoc { public: GooString fileName; PDFDoc(GooString f, void, void, void*) : fileName(f) {} bool isOk() { retu...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly targets the sprintf overflow in extractPages by constructing a long destFileName that exceeds the 1024-byte pathName buffer, matching the exact vulnerability mechanism.\n- Exploitability: 5/5 — The PoC constructs a valid destFileName that satisfies the \"%d\" require...	null
CVE-2017-15994	[ "CWE-354" ]	samba	vulnerable	false	#include <string.h> #include <stdint.h> /* Type definition / typedef unsigned char uchar; typedef int int32; / Checksum block size; typical value is 64 bytes (matching the MD4/MD5 block size). / #define CSUM_CHUNK 64 / Checksum type enumeration */ enum sum_type { CSUM_MD5, CSUM_MD4, CSUM_MD4_OLD, ...	Analyze the following C/C++ code and determine whether it contains a security vulnerability. If a vulnerability exists, explain the root cause, trigger conditions, attacker-controlled inputs, data-flow path, potential impact, and construct a PoC that can trigger it. ### Additional Context ```c #include <string.h> #inc...	Analyzing the given `sum_update` function reveals a security vulnerability that can lead to the bypass of integrity checks. First, starting from the code structure. `sum_update` dispatches different checksum update logic based on the value of the global variable `cursum_type`. The `switch` statement handles known chec...	#include <stdio.h> #include <string.h> #include <stdint.h> typedef unsigned char uchar; typedef int int32; #define CSUM_CHUNK 64 enum sum_type { CSUM_MD5, CSUM_MD4, CSUM_MD4_OLD, CSUM_MD4_BUSTED, CSUM_NONE, CSUM_MD4_ARCHAIC = 99 /* Old checksum type; not handled in the original code. */ }; ...	rewrite_reasoning_code_only	{ "analysis": "- Relevance: 5/5 — The PoC directly targets the CVE-described vulnerability: mishandling of archaic checksums leading to bypass of access restrictions. It demonstrates that an unhandled checksum type causes data to be completely ignored, matching the vulnerability mechanism.\n- Exploitability: 5/5 — Th...	null

End of preview. Expand in Data Studio

RealMythosReasoning — Unofficial English Translation

This is an unofficial, machine-translated English derivative of RealMythos/RealMythosReasoning at pinned revision d363dda86d9316c29a181da042812050772bbf36. It is not produced, endorsed, or maintained by the upstream RealMythos authors.

The release contains 6,159 training records. Chinese-language text found in code comments, selected string literals, review flags, questions, additional context, responses, and PoC evaluation analysis was translated into technical English. Existing English text, JSON structure, metadata, identifiers, format placeholders, and code syntax were protected by the translation and validation pipeline. augmented_context embedded verbatim in question was translated once and reused to avoid divergent copies.

Semantics-sensitive encoding, Unicode, and IDN test literals are an intentional exception: their values were not translated. Raw Han/Bopomofo code points in those literals were deterministically represented as equivalent C/C++ Unicode escape sequences so the test payload is preserved while the released JSONL has no raw Han/Bopomofo characters. The validator accepts such sequences only when the ledger marks an exact deterministic literal_escape replacement, and reports their count as approved_literal_escape_sequences.

Data

Item	Value
Split	`train`
Records	6,159
Data file	`data/stage1/sft_train_en.jsonl`
File size	177,686,826 bytes
SHA256	`a3d1d020c40aaa8b0d5266a0245a78a4b7cb111d63c988c10d3ed580fe759714`
Translation model	`qwen/qwen3.8-flash, tencent/hy-mt2-30b-a3b` through OpenRouter
Prompt version	`realmythos-zh-en-v1`
Build time	`2026-09-29T05:28:02Z`

The record schema is retained from upstream: cve, cwe, project, label, self_contained, augmented_context, question, reasoning, response, reasoning_source, poc_eval, and review_flag.

Attribution and license

The source dataset is RealMythosReasoning by the RealMythos contributors, available at https://huggingface.co/datasets/RealMythos/RealMythosReasoning, and licensed under Creative Commons Attribution 4.0 International. This derivative is distributed under the same CC BY 4.0 license. The changes consist of machine translation into English, deterministic reconstruction, and release validation. See NOTICE.md and LICENSE for attribution and terms.

Validation

The release builder only emits these assets after the validation report records a passing result, the output contains the expected 6,159 rows, and the source/output hashes agree with the cache and report. See validation_report.json, translation_manifest.json, and SHA256SUMS for machine-readable provenance and integrity information.

Safety and limitations

The dataset contains real vulnerability descriptions and proof-of-concept C/C++ code. Treat every sample as untrusted and do not compile or execute it outside an isolated environment.
Machine translation can lose nuance, choose imperfect security terminology, or alter the human-readable meaning of a runtime string even when code syntax remains intact.
Passing structural validation is not proof that every translated program preserves runtime behavior, compiles, or accurately represents the underlying CVE.
The dataset is intended for defensive security research, auditing, and model development. Users remain responsible for lawful and safe use.
Upstream data quality, coverage, provenance limitations, and responsible-disclosure considerations continue to apply. Consult the upstream dataset card before use.

Downloads last month: 98