A method for extracting key fields from PoC reports based on reasoning guidance prompts

By using a reasoning-guided prompting method, combined with a large language model and structured output constraints, the problem of inaccurate field identification in PoC reports is solved, achieving efficient and stable extraction and output of key fields, and adapting to the automated processing of unstructured reports.

CN123070320APending Publication Date: 2026-11-10NANJING TECH UNIV
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611287768.0
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-08-24
Publication Date
2026-11-10

AI Technical Summary

Technical Problem

Existing technologies struggle to accurately identify and extract key fields such as vulnerability number, vulnerability type, operating platform, and date from unstructured PoC reports. Furthermore, they suffer from issues such as non-standard field representation, difficulty in recognizing implicit semantics, easy confusion between fields, and unstable output structure.

Method used

We employ a reasoning-guided hint approach, which utilizes few-shot context learning, field-level reasoning guidance, and structured output constraints, combined with a large language model, to identify and extract key fields from the PoC report, including CVE-ID, Type, Platform, and Date. We then construct the data through noise removal, field configuration, example sets, and RGFP hints, and finally perform result parsing and normalization.

Benefits of technology

It improves the accuracy and stability of automated processing of PoC reports, enabling the output to be directly used for database storage and calculation, reducing field misextraction and confusion, and lowering rule maintenance costs.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123070320A_ABST
    Figure CN123070320A_ABST
Patent Text Reader

Abstract

This invention proposes a method for extracting key fields from PoC reports based on reasoning-guided prompts. First, special characters, blank lines, links, and redundant content in the PoC report are cleaned to obtain standardized text. Then, based on the definitions of CVE-ID, vulnerability type, operating platform, and date fields, a prompt template consisting of task instructions, example input, reasoning guidance, and example output is constructed, and typical samples are used to guide a large language model to learn field expression patterns. Next, the model completes semantic inference in the order of identifier recognition, exploit behavior analysis, operating environment determination, and date extraction. Finally, the output results are normalized, formatted, and encapsulated in JSON. This method can improve the accuracy of extracting implicit and ambiguous fields in complex PoC texts, providing a reliable foundation for vulnerability report quality assessment, information retrieval, and data maintenance.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention belongs to the field of information security and natural language processing technology, and particularly relates to a method for extracting fields from Proof-of-Concept (PoC) reports based on reasoning-guided prompts. This method can automatically identify and extract key fields such as vulnerability number, vulnerability type, operating platform, and date from unstructured PoC reports, providing a unified and parsable structured data foundation for subsequent vulnerability report comparison, data quality assessment, and automated maintenance. Background Technology

[0002] PoC reports serve as a crucial data source in the vulnerability analysis and verification process, typically containing various types of information such as vulnerability description, triggering conditions, exploitation steps, testing environment, exploit code, and supplementary descriptions. Among these, the key fields of CVE-ID, vulnerability type, operating platform, and date can be used to correlate with external vulnerability information, analyze vulnerability exploitation conditions, and assist in security data management, forming the foundational data for automated PoC report processing.

[0003] However, actual PoC reports are typically generated by submitters from different sources according to their own writing habits, lacking a unified text structure, field specifications, and expression constraints. The same field information may be scattered across different locations such as the title, body description, code comments, reproduction steps, or environment configuration; some fields may not even appear as explicit labels. For example, the vulnerability type may need to be semantically determined based on attack behaviors and impacts such as "remotely sending malicious requests," "local user privilege escalation," or "causing service crashes"; the operating platform may simultaneously involve the affected environment, test environment, dependent components, and the language used in the code implementation, requiring contextual understanding to distinguish its true meaning; date information may also contain multiple temporal semantics, including discovery date, disclosure date, code writing date, and database inclusion date. Therefore, accurately identifying and extracting key fields from such loosely structured and semantically complex text reports becomes a crucial issue for achieving automated PoC report analysis.

[0004] Existing extraction methods based on regular expressions or keyword matching typically rely on fixed formats and predefined vocabularies. While they can identify CVE-IDs or dates with obvious formatting characteristics, they struggle to handle implicit semantics of vulnerability types, contextual ambiguity of platform names, and issues related to multiple date filtering. When a report contains phrases like "Python script executed on a Windows target," simple keyword matching may mistakenly identify the PoC implementation language as the affected platform, causing the extraction results to deviate from the true meaning of the report.

[0005] With the development of large language models, generating structured fields from unstructured text using prompts has become a feasible approach. However, general zero-shot prompts typically only provide the names of the fields to be extracted, lacking field definitions, semantic boundaries, and output format constraints; ordinary few-shot prompts, while providing examples, do not specify the analysis order when the model processes different fields; directly requiring the model to perform general inference can easily result in verbose text, missing fields, or output that cannot be parsed by the program. Therefore, existing methods still suffer from insufficient implicit field recognition, semantic confusion between fields, and unstable output formats.

[0006] To address this issue, this invention proposes a method for extracting key fields from PoC reports based on reasoning-guided prompts. First, noise cleanup and text normalization are performed on the PoC report to be processed, and a set of fields to be extracted and their standard label space are configured. Then, reasoning-guided prompts are constructed according to the structure of task instructions, example inputs, field analysis order constraints, and example outputs. Next, the prompt information and the PoC report to be processed are input into a large language model to obtain structured candidate results. Finally, the candidate results are subjected to format validation, field normalization, and anomaly handling, outputting key fields of the PoC report that can be directly stored and computed. Summary of the Invention

[0007] The purpose of this invention is to provide a method for extracting key fields from PoC reports based on reasoning guidance prompts, so as to solve the problems of non-standard field expression, difficulty in recognizing implicit semantics, easy confusion between fields, unstable output structure, and high rule maintenance cost in the processing of unstructured PoC reports by existing technologies.

[0008] To achieve the above objectives, this invention combines few-shot context learning, field-level inference guidance, structured output constraints, and result verification mechanisms. The method takes the original PoC report as input and a structured record containing key fields such as CVE-ID, Type, Platform, and Date as output, and specifically includes the following steps:

[0009] 1) PoC report text preprocessing: Obtain the original PoC report to be processed, identify and remove content consisting only of special characters, repeated delimiters, invalid whitespace or format noise; unify character encoding, line breaks and space format; retain information related to field identification such as vulnerability title, vulnerability description, triggering conditions, reproduction steps, test environment, code and code comments, product version and date, to obtain the preprocessed PoC report text.

[0010] 2) Field Configuration, Example Set, and RGFP Prompt Construction: Determine the set of fields to be extracted, F={CVE-ID, Type, Platform, Date}, and the semantic scope, standard labels, judgment criteria, missing data representation, and structured output mode for each field; Input a manually verified PoC report sample set D, classifying it according to explicit fields, implicit fields, multi-valued fields, ambiguous fields, and missing fields; Select representative samples from each category to form a small sample set E, and construct example_input, example_guidance, and example_output for each sample; Check whether the small sample set covers the four types of fields and the preset difficulty scenarios; If not, supplement the corresponding samples; After coverage, organize the examples in a fixed order; Finally, concatenate the Task_Instruction, Few-shot_Examples, Reasoning_Guidance, Output_Schema, and Target_Report in a preset order to obtain RGFP_promp.

[0011] Specifically, the CVE-ID field is used to extract vulnerability identifiers explicitly appearing in the PoC report. It is primarily identified based on CVE format strings in the title, body, code comments, and header, and output as a string array after capitalization and deduplication. The Type field indicates the vulnerability exploitation method or vulnerability category, mainly determined by attack path, triggering conditions, permission requirements, and impact results. Its output value is limited to an array of tags: remote, local, webapps, dos, and hardware. The Platform field indicates the system environment affected by the vulnerability or actually running on it. It is identified based on the affected system, test environment, runtime environment, hardware architecture, and dependent components. The platform name is unified with synonyms and deduplicated before being output as an array. The Date field indicates the main date related to the PoC disclosure or release, mainly determined by adjacent words, header semantics, and contextual events. The final output is a string in YYYY-MM-DD format; if it cannot be determined, an empty value is output.

[0012] 3) Field extraction based on a large language model: The RGFP_prompt is input into the large language model, which learns the field expression pattern based on a few sample examples, identifies explicit CVE identifiers and generates valid CVE-ID candidates, determines Type candidates based on vulnerability exploitation behavior, attack path, permission conditions and impact results, and identifies Platform candidates from affected systems, test environments, runtime environments and dependent components; it determines whether the Platform candidate represents the vulnerability target, triggering environment or conditions required for reproduction, retains the candidates that meet the conditions and excludes the candidates that do not belong to the preset Platform category; then it identifies the date and its adjacent semantic tags to determine the vulnerability disclosure date, PoC public date or report release date; finally, it organizes the field values ​​according to Output_Schema, and represents missing fields as empty arrays or null values, outputting a structured candidate result raw_result containing CVE-ID, Type, Platform and Date.

[0013] 4) Field result parsing, normalization, and validation: Receive raw_result and report_id, remove any JSON code block markers and extract the JSON object, then perform JSON parsing. If parsing fails, retry according to the same output constraints before reaching the maximum number of retries. If parsing still fails after reaching the maximum number of retries, record the parsing failure status and retain report_id. If parsing succeeds, check if the fields are complete and if the key names and data types conform to Output_Schema. Perform format validation, synonym mapping, and normalization processing on CVE-ID, Type, Platform, and Date respectively, delete duplicate values, illegal values, and field values ​​without supporting reporting evidence, and output normalized_result.

[0014] Furthermore, the specific steps of step 1) are as follows:

[0015] Step 1)-1: Initial state;

[0016] Step 1)-2: Enter the raw PoC report poc_report_raw and the report identifier report_id;

[0017] Steps 1)-3: Standardize text character encoding and convert different forms of newline and whitespace characters into a unified form;

[0018] Steps 1)-4: Read poc_report_raw line by line and determine whether the current line consists only of format noise such as special characters, repeating delimiters, or invalid whitespace; if so, delete the current line; if not, keep the current line.

[0019] Step 1)-5: Determine if there are any unprocessed lines; if yes, continue reading line by line and execute Step 1)-4; if no, proceed to the next step.

[0020] Steps 1)-6: Merge consecutive blank lines, remove extra spaces at the beginning and end of lines, and normalize abnormal tabs and duplicate spaces;

[0021] Steps 1)-7: Identify and retain content with semantic field meaning, such as title, vulnerability description, code comments, HTTP requests, reproduction steps, and test environment;

[0022] Step 1)-8: Reassemble and retain the content according to the original semantic order to obtain the preprocessed text poc_report_clean;

[0023] Step 1)-9: Output poc_report_clean and report_id;

[0024] Step 1)-10: End state.

[0025] Furthermore, the specific steps of step 2) are as follows:

[0026] Step 2)-1: Initial state;

[0027] Step 2)-2: Create a field set F={f_cve, f_type, f_platform, f_date}, and define the semantic scope, standard label, judgment criteria, missing representation method and structured output mode for each field;

[0028] Steps 2)-3: Input the manually verified PoC report sample set D;

[0029] Steps 2)-4: Classify D according to field coverage, and the classification includes at least explicit field samples, implicit field samples, multi-valued field samples, ambiguous field samples, and field missing samples;

[0030] Steps 2)-5: Select at least one representative sample from each category to obtain a small sample set E;

[0031] Steps 2)-6: For each sample in E, construct example input (example_input), field analysis step (example_guidance), and standard output (example_output);

[0032] Step 2)-7: Check whether the small sample set covers the four fields of CVE-ID, Type, Platform, and Date, as well as the preset difficult scenarios; if not covered, supplement the corresponding samples and return to Step 2)-6; if covered, proceed to the next step.

[0033] Step 2)-8: Organize the few sample examples in a fixed order to reduce the impact of changes in the cue order on the model results;

[0034] Step 2)-9: Construct the Task Instruction, Few-shot Examples, Reasoning Guidance, Output Schema, and Target Report;

[0035] Step 2)-10: Assemble the components in the order of Task_Instruction, Few-shot_Examples, Reasoning_Guidance, Output_Schema, and Target_Report;

[0036] Step 2)-11: Output RGFP_prompt;

[0037] Step 2)-12: End state.

[0038] Furthermore, the specific steps of step 3) are as follows:

[0039] Step 3)-1: Initial state;

[0040] Step 3)-2: Input RGFP_prompt into the large language model;

[0041] Step 3)-3: The model learns field expression patterns based on a small number of sample examples;

[0042] Steps 3)-4: Identify explicit CVE identifiers and output CVE-ID candidates that conform to the preset format;

[0043] Steps 3)-5: Determine the Type candidates based on the vulnerability exploitation behavior, attack path, permission conditions, and impact results;

[0044] Steps 3)-6: Identify Platform candidates from the affected systems, test environments, runtime environments, and dependent components;

[0045] Steps 3)-7: Determine whether the Platform candidate represents the vulnerability target, triggering environment, or conditions required for reproduction; if yes, retain the Platform candidate; if no, exclude candidates that do not belong to the preset Platform category.

[0046] Step 3)-8: Identify the date and its adjacent semantic markers to determine the vulnerability disclosure date, PoC public release date, or report release date;

[0047] Step 3)-9: Organize field values ​​according to Output_Schema, with missing fields represented by empty arrays or null values;

[0048] Step 3)-10: Output a structured candidate result raw_result containing CVE-ID, Type, Platform, and Date;

[0049] Step 3)-11: End state.

[0050] Furthermore, the specific steps of step 4) are as follows:

[0051] Step 4)-1: Initial state;

[0052] Step 4)-2: Receive raw_result and report_id;

[0053] Step 4)-3: Remove any JSON code block markers that may exist in raw_result and extract the JSON object;

[0054] Step 4)-4: Perform JSON parsing on the extracted JSON object;

[0055] Steps 4)-5: Determine if the JSON parsing was successful; if not, check if the maximum number of retries has been reached; if the maximum number of retries has not been reached, re-request according to the same output constraints and return to Steps 4)-3; if the maximum number of retries has been reached and parsing is still unsuccessful, record the parsing failure status, retain the report_id and end the processing; if parsing is successful, proceed to the next step.

[0056] Steps 4)-6: Check if all fields are complete and if the key names and data types conform to Output_Schema;

[0057] Step 4)-7: Perform case unification, prefix completion, connector normalization, and regular expression validity checks on the CVE-ID field;

[0058] Steps 4)-8: Perform lowercase conversion, synonym mapping, and standard label mapping on the Type field;

[0059] Step 4)-9: Perform synonym merging and platform family normalization on the Platform field, and distinguish between the runtime environment and the PoC implementation language;

[0060] Step 4)-10: Identify different date formats and date semantics for the Date field and convert them uniformly to YYYY-MM-DD format;

[0061] Step 4)-11: Delete duplicate values, invalid values, and field values ​​that are not supported by reporting evidence;

[0062] Step 4)-12: Output normalized_result;

[0063] Step 4)-13: End state.

[0064] Compared with existing technologies, this invention combines few-sample pattern learning, field-level analysis sequence, and structured output constraints, enabling large language models to adapt to the non-uniform expression of PoC reports without parameter fine-tuning; by setting different semantic judgment paths for Type, Platform, and Date, it reduces the possibility of mistakenly extracting attack tools, PoC implementation languages, or irrelevant time as target fields; and through result verification and normalization, it enables the output to be directly used for database storage, field comparison, and batch calculation, thereby improving the accuracy and stability of automated PoC report processing. Attached Figure Description

[0065] Figure 1 This is a flowchart illustrating the overall process of a PoC report key field extraction method based on reasoning guidance prompts in an embodiment of the present invention.

[0066] Figure 2 for Figure 1 A flowchart of the text preprocessing steps in the PoC report.

[0067] Figure 3 for Figure 1 A flowchart of the field configuration, example set, and RGFP hints construction steps.

[0068] Figure 4 for Figure 1 A flowchart of the field extraction steps based on a large language model.

[0069] Figure 5 for Figure 1 A flowchart of the steps for result parsing, standardization, and verification. Detailed Implementation

[0070] The technical solution of the present invention will be further described below with reference to the accompanying drawings and specific embodiments. It should be understood that the following embodiments are used to illustrate the present invention and are not intended to limit the scope of protection of the present invention; any equivalent substitutions or modifications that can be made by those skilled in the art without departing from the concept of the present invention should fall within the scope of protection of the present invention.

[0071] In one embodiment, such as Figure 1As shown, this method consists of a PoC report input module, a text preprocessing module, a field task configuration module, an RGFP hint construction module, a large language model invocation module, and a result parsing and normalization module. These modules can be deployed on the same computing device or distributed via interfaces. The PoC report to be processed can originate from local files, database records, or network-collected results, and is input using a correspondence between report_id and report text.

[0072] like Figure 2 As shown, the text preprocessing module reads `poc_report_raw` and unifies the character encoding, newline characters, and whitespace characters. It removes noisy lines that only serve as layout separators, while retaining content that may contain field evidence, such as the title, description, code comments, HTTP requests, reproduction steps, and test environment. After processing, the retained content is combined according to its original semantic order to obtain `poc_report_clean`, maintaining its association with `report_id`.

[0073] The field task configuration module defines the CVE-ID, Type, Platform, and Date fields, specifying their output data types and normalization rules. Specifically, CVE-ID uses a string array; Type uses a tag array allowing only remote, local, webapps, DOS, and hardware; Platform uses a platform array after synonym merging; and Date uses a string in YYYY-MM-DD format or a null value.

[0074] like Figure 3 As shown, the field configuration, example set, and RGFP hint building module first establishes the definitions, output data types, and normalization rules for four types of fields: CVE-ID, Type, Platform, and Date. Specifically, CVE-ID uses a string array; Type uses a tag array that only allows remote, local, webapps, dos, and hardware; Platform uses a platform array that has been merged with synonyms; and Date uses a string in YYYY-MM-DD format or a null value.

[0075] Subsequently, a few-shot example set is constructed from manually verified samples. The example set covers at least explicit fields, implicit fields, multi-valued fields, ambiguous fields, and cases where fields are missing. Each example includes example input, field decision guidance, and standard output. Once the example set covers the four types of fields and preset difficult cases, the examples are organized in a fixed order, and the task instruction (Task_Instruction), few-shot examples (Few-shot_Examples), reasoning guidance (Reasoning_Guidance), structured output constraints (Output_Schema), and target report (Target_Report) are concatenated sequentially to obtain RGFP_prompt.

[0076] In this embodiment, the task instruction requires the model to extract fields only based on the target PoC report and the context information that can be determined therein, and not to add numbers, platforms or dates without textual basis; Output_Schema stipulates that the values ​​of CVE-ID, Type and Platform must be arrays, the value of Date must be a string or an empty value, and it is prohibited to output descriptive text outside of JSON objects.

[0077] like Figure 4 As shown, RGFP_prompt is input into a large language model, enabling the model to learn field expression patterns based on few sample examples, identify explicit CVE identifiers and generate valid CVE-ID candidates. Type candidates are determined based on vulnerability exploitation behavior, attack paths, permission conditions, and impact results. Platform candidates are identified from affected systems, test environments, runtime environments, and dependent components. It is determined whether a Platform candidate represents a vulnerability target, triggering environment, or condition required for reproduction; candidates that meet the criteria are retained, while those not belonging to the preset Platform category are excluded. Subsequently, the date and its adjacent semantic markers are identified to determine the vulnerability disclosure date, PoC publication date, or report release date. Finally, field values ​​are organized according to Output_Schema, with missing fields represented by empty arrays or null values, outputting a structured candidate result raw_result containing CVE-ID, Type, Platform, and Date.

[0078] like Figure 5 As shown, the result parsing and normalization module first performs JSON parsing on the candidate results and checks whether the fields are complete, the key names are correct, and the data types conform to the Output_Schema. If the output contains JSON code block markers, the markers are removed and the JSON object is extracted; if parsing still fails, a new request is made according to the same output constraints within the maximum number of retries. If parsing still fails after the maximum number of retries, the parsing failure status is recorded, and the report_id is retained for subsequent review.

[0079] For successfully parsed results, regular expressions are used to check if the CVE-ID conforms to the format of CVE-four-digit year-at least four-digit serial number. Case sensitivity, prefixes, and connectors are normalized, and values ​​that do not meet the format requirements or lack supporting evidence are deleted. For Type, natural language expressions and synonyms are mapped to a preset tag set, and tags outside the set and duplicate tags are deleted. For Platform, case sensitivity and common aliases are first standardized, and then normalized according to platform family mapping relationships. When the same report simultaneously mentions the target operating system, test environment, and PoC implementation language, their roles are determined by combining the semantic proximity of "affected," "tested on," "requires," and "written in"; only content representing the vulnerability target, triggering environment, or conditions required for reproduction is retained as Platform. For Date, formats such as year-month-day, day / month / year, and month name plus date are first identified and their validity is checked, and then uniformly converted to YYYY-MM-DD. When multiple dates exist in a report, the PoC report publication or release date explicitly indicated by the Date, Published, or Released header is prioritized; if no explicit header is available, the date is determined based on adjacent words and contextual events. Dates whose target semantics cannot be determined are not output.

[0080] After normalization, the normalized_result is associated with the report_id and written to the database. In batch processing scenarios, the system performs preprocessing, suggestion construction, model invocation, and result normalization for each report, and can simultaneously record the original model output, parsing status, and anomaly markers to support subsequent data quality assessment, field comparison, and manual review.

[0081] In other embodiments, the large language model can be a locally deployed model or a remote model accessed via an interface; the number of few-shot examples, model call parameters, and platform mapping dictionary can be adjusted according to the report type and computing resources, but all maintain the combined structure of task instructions, few-shot examples, field inference guidance rules, structured output constraints, and target PoC report.

[0082] This method can be implemented by a processor executing a computer program stored in memory, or by a server, personal computer, or other electronic device with text processing and model calling capabilities. When the computer program is executed by the processor, it enables the electronic device to complete the aforementioned key field extraction steps from the PoC report.

Claims

1. A method for extracting key fields from a PoC report based on reasoning-guided prompts, characterized in that, The method is applied to the field of network security vulnerability exploitation information processing. It constructs a large language model-based suggestion enhancement mechanism for PoC report text, and utilizes reasoning-guided few-sample suggestion RGFP to guide the large language model in semantic analysis of vulnerability descriptions, environmental information, exploitation conditions, and code context in the PoC report. This enables automatic identification and structured extraction of key security information from unstructured PoC reports. The method takes the original PoC report text as input and a standardized structured record containing CVE-ID, Type, Platform, and Date fields as output, and includes the following steps: 1) PoC report text preprocessing: Obtain the original PoC report to be processed, unify the character encoding, newline characters and whitespace characters, identify and remove invalid characters, duplicate delimiters and other format noise line by line, merge consecutive blank lines and standardize spaces and tabs, while retaining the valid field information in vulnerability description, reproduction steps, test environment, code and code comments, to obtain the preprocessed PoC report text; 2) Field Configuration, Example Set, and RGFP Hint Construction: Based on the content characteristics of the PoC report, define the semantic scope, standard labels, judgment criteria, missing data representation, and structured output format for the CVE-ID, Type, Platform, and Date fields; select representative samples from manually verified PoC reports, and construct example inputs, field analysis steps, and standard structured outputs for each sample to form a few-sample example set; combine task instructions, few-sample examples, inference guidance, structured output constraints, and the preprocessed PoC report to be processed in a preset order to obtain the RGFP hint; 3) Field extraction based on a large language model: The RGFP prompt is input into the large language model, which learns the field expression pattern based on a few sample examples, and identifies and analyzes the CVE-ID, Type, Platform, and Date fields in the PoC report according to the inference guidance; semantic judgment is performed on the identified Platform candidate values, and Platform candidate values ​​used to represent the vulnerability target, triggering environment, or conditions required for reproduction are retained; the field values ​​are organized according to a preset structured output format to generate structured field candidate results; 4) Field result parsing, normalization and validation: Receive the structured field candidate results, perform JSON parsing and output structure checks on them; perform format validation, synonym mapping and normalization processing on the successfully parsed CVE-ID, Type, Platform and Date fields respectively, delete duplicate values, illegal values ​​and field values ​​that are not supported by the PoC report content, and obtain the standardized key field extraction results of the PoC report; for the results that fail to be parsed, re-request the large language model to generate structured field candidate results before reaching the preset maximum number of retries, and record the parsing failure status if the parsing still fails after reaching the maximum number of retries.

2. The method according to claim 1, characterized in that, The field configuration in step 2) includes: setting the set of fields to be extracted to F={CVE-ID, Type, Platform, Date}; the CVE-ID field is used to represent the CVE number associated with the PoC report, and adopts the format CVE-YYYY-NNNN…, where YYYY is a four-digit year and NNNN… is a number sequence number of no less than four digits; the standard labels of the Type field only include remote, local, webapps, dos, and hardware; the Platform field is used to represent the operating system, processor architecture, programming language, runtime environment, or application framework required for the vulnerability to be affected, tested, or reproduced; the Date field is used to represent the vulnerability disclosure date, PoC public date, or report release date, and is uniformly converted to YYYY-MM-DD format; when a field cannot be determined, it is represented by a preset empty array or null value.

3. The method according to claim 1, characterized in that, Step 2) involves constructing the few-shot example set and RGFP hints, which include: inputting a manually verified PoC report sample set; classifying the sample set according to explicit fields, implicit fields, multi-valued fields, ambiguous fields, and missing fields; selecting representative samples from each category; constructing example inputs, field analysis steps, and standard structured outputs for each representative sample; checking whether the few-shot example set covers the four fields CVE-ID, Type, Platform, and Date, as well as preset difficult scenarios; supplementing corresponding samples if not covered; and organizing the few-shot examples in a fixed order after coverage; and concatenating the Task_Instruction, Few-shot_Examples, Reasoning_Guidance, Output_Schema, and Target_Report in a preset order to obtain the RGFP hints.

4. The method according to claim 1, characterized in that, The reasoning guidance in step 3) includes: identifying text that conforms to the CVE number format characteristics and determining CVE-ID candidate values; judging Type candidate values ​​based on vulnerability exploitation behavior, attack path, permission conditions, and impact results; identifying Platform candidate values ​​based on the affected system, test environment, runtime environment, code, and dependent components, and determining whether the Platform candidate values ​​represent the vulnerability target, triggering environment, or conditions required for reproduction, and retaining Platform candidate values ​​that meet the conditions; identifying Date candidate values ​​based on date-adjacent words, contextual events, and corresponding date semantics; organizing the extracted results of CVE-ID, Type, Platform, and Date fields according to Output_Schema, and outputting a preset empty array or null value for fields that cannot be determined.

5. The method according to claim 1, characterized in that, The field result parsing, normalization, and validation in step 4) include: removing JSON code block markers that may exist in the output results of the large language model and extracting JSON objects; performing JSON parsing on the JSON objects; when parsing fails, determining whether the preset maximum number of retries has been reached; if the maximum number of retries has not been reached, requesting the large language model to generate results again according to the same structured output constraints; if parsing still fails after reaching the maximum number of retries, recording the parsing failure status; when parsing succeeds, checking whether the fields are complete, whether the key names and data types conform to Output_Schema, performing case unification, prefix completion, connector normalization, and format validity validation on CVE-ID, lowercaseization, standard label mapping, and synonym merging on Type, name unification, synonym merging, and platform category mapping on Platform, date format conversion and date validity validation on Date, and deleting duplicate values, illegal values, and field values ​​that lack PoC report content support, to obtain normalized structured key field results.