Automated Vulnerability Repair Using Prototype-Based Deep Metric Learning with Normative Compliance Constraints ^†

Abstract

Automated Program Repair (APR) is increasingly used for vulnerability patching, yet many existing methods focus primarily on syntactic similarity between vulnerable and fixed code, with limited guarantees of semantic correctness and limited alignment with security frameworks. This work presents a prototype-based deep metric learning method for vulnerability repair that integrates normative constraints from OWASP and NIST SSDF. The method combines embeddings of vulnerable code and CWE descriptions, refines category prototypes to improve separation among CWE types, and validates repairs against statement-level control requirements derived from the normative mapping. Experiments on 959 vulnerable–fixed pairs across Python, Java, C, and C++ covering 15 CWE categories achieved a Match Ratio of 88.95%, 0.81 compliance, and 0.84 consistency.

1. Introduction

Cybersecurity has become an essential pillar for safeguarding organizational information technology assets, spanning multiple fronts: the human factor, defensive operations, offensive operations, and regulatory and legal compliance. Within the defensive and compliance domains, the Secure Software Development Life Cycle (SSDLC) plays a central role in the early detection of flaws, from requirements engineering and design to continuous integration and deployment (CI/CD) [1]. This approach drives sustained improvements in software quality, which is particularly important given that, according to the European Union Agency for Cybersecurity (ENISA) [2], poor development practices maintain persistent exposure to vulnerabilities, with notable impact on production systems in sectors such as transport, healthcare, education, and government.

APR has emerged in recent years as a relevant research line within Natural Language Processing, positioning itself as a complementary alternative to traditional static and dynamic analysis. Its momentum largely stems from the use of Large Language Models (LLMs), which can identify risk patterns and propose automated code corrections. In this context, encoder-based models are commonly used to localize potentially vulnerable regions in code; encoder–decoder architectures are used to model and generate concrete modifications on specific fragments; and decoder-only models, supported by retrieval and prompt engineering with reasoning chains, can produce complete repairs or targeted patches for the vulnerable portion [3].

However, much of the state-of-the-art [4,5,6] in APR assumes that the problem is limited to transforming a vulnerable region and contrasting it with its secure counterpart, which requires abundant and consistent vulnerable–fixed pairs and tends to prioritize textual similarity over semantic stability and verifiability. This formulation often yields heterogeneous repairs within the same Common Weakness Enumeration (CWE) category, weak discrimination among closely related weaknesses, and no explicit integration of normative criteria to audit satisfied controls and avoided anti-patterns. This work proposes a category- and compliance-driven alternative, where repair is conditioned on CWE-refined prototypes and anchored to a statement-level normative ground truth aligned with control inventories from the Open Worldwide Application Security Project (OWASP) and the National Institute of Standards and Technology (NIST), enabling joint evaluation of semantic correctness and auditable compliance.

2. Methods and Materials

In Figure 1, the workflow of the proposed methodology is presented.

Figure 1. Proposed system workflow.

2.1. Sample Collection

The National Vulnerability Database (NVD) [7] was consulted to identify the 15 most prevalent CWE types in 2024. Vulnerable–fixed code pairs were collected from CVEfixes v1.0.8 for Python [8,9], Software Vulnerability Datasets and Vulnerability Fix Dataset for Java [10,11], and Juliet Test Suite v1.3 from the Software Assurance Reference Dataset (SARD) for C/C++ [12]. The Java sources do not specify a single language version, and the Python source corresponds to a multi-project dataset release rather than to a fixed interpreter version. Each sample is aligned with its CWE and linked to technical metadata from the CWE taxonomy [13]. Secure fragments are validated through Static Application Security Testing (SAST) using Semgrep [14] and OWASP Dependency-Check [15]. Normative controls are mapped per fix using the Secure Software Development Framework (SSDF) from NIST SP 800-218 [16] and OWASP controls [17]. Each sample i contains the vulnerable code snippet $s_i^{\mathrm{vuln}}$ and the fixed code snippet $s_i^{\sec }$ used as the ground-truth reference, the CWE identifier ${\mathrm{cwe}}_i$, the CWE weakness description $d_i$, the required control set ${\mathcal{C}}_i^{\mathrm{req}}$ specifying controls that must be present in a valid fix, and the forbidden control set ${\mathcal{C}}_i^{\mathrm{forb}}$ specifying anti-patterns and insecure practices that must be absent, enforcing ${\mathcal{C}}_i^{\mathrm{req}}\cap {\mathcal{C}}_i^{\mathrm{forb}}=\varnothing$. The dataset includes 959 samples: 437 in Python (45.6%), 312 in Java (32.5%), and 210 in C/C++ (21.9%), covering the 15 most prevalent CWE categories, including CWE-79, CWE-89, CWE-78, CWE-22, CWE-287, CWE-798, CWE-434, CWE-352, CWE-862, and CWE-200.

2.2. Data Architecture Stage

Preprocessing transforms the raw source-code snippets $s\in \{s_i^{\mathrm{vuln}},s_i^{\sec }\}$ into normalized forms via $\mathrm{normalize}(s)=\mathrm{trim}(\mathrm{remove}\_\mathrm{comments}(s))$, which excludes comments and redundant whitespace to retain only semantically relevant information. Next, each normalized s is segmented into syntactic statements $\mathrm{statements}\left(s\right)=\{s_1,\dots ,s_m\}$, where each $s_j$ is a syntactically valid unit and the concatenation $s_1\circ s_2\circ \dots \circ s_m$ reconstructs the original snippet. For embedding generation, a shared CodeBERT encoder $E_{\mathrm{shared}}:{\mathcal{T}}^{\ast }\to {\mathbb{R}}^{768}$ is used, where ${\mathcal{T}}^{\ast }$ denotes the set of finite sequences of tokens produced by the CodeBERT tokenizer. For sample i, the vulnerable-code embedding is defined as $e_i^{\mathrm{code}}=E_{\mathrm{shared}}\left(s_i^{\mathrm{vuln}}\right)\in {\mathbb{R}}^{768}$ and the CWE-description embedding as $e_i^{\mathrm{cwe}}=E_{\mathrm{shared}}\left(d_i\right)\in {\mathbb{R}}^{768}$, where $E_{\mathrm{shared}}$ uses the CLS token representation to capture global information through multi-head attention. The final representation is obtained by concatenating both embeddings, $e_i=[e_i^{\mathrm{code}}\oplus e_i^{\mathrm{cwe}}]\in {\mathbb{R}}^{1536}$.

Representative prototypes are constructed for each vulnerability category in the dataset. Let K denote the number of categories, and for a particular category c, let $I_c=\{i:c_i=c\}$ be the index set of samples whose label equals c, and let $|I_c|$ be its cardinality. The initial prototype for category c, denoted $P_c^{\left(0\right)}$, is defined as the centroid of the category embeddings and is computed as the arithmetic mean of the vectors $e_i$ for all $i\in I_c$, as given in Equation (1).

$$P_c^{\left(0\right)}={\displaystyle \frac{1}{|I_c|}}\sum _{i\in I_c}{e}_i=\arg \underset{p}{\min }\sum _{i\in I_c}{\parallel e_i-p\parallel }_2^2$$

(1)

Here, the centroid lies in ${\mathbb{R}}^{1536}$ and constitutes the $L^2$-optimal representative for category c, as it minimizes the within-category sum of squared Euclidean distances over all candidate prototype vectors p. Prototype quality at initialization is summarized by the separation ratio $\rho =d_{\mathrm{inter}}/{\overline{d}}_{\mathrm{intra}}$, where $d_{\mathrm{inter}}$ is the mean Euclidean distance between initial prototypes ${\left\{P_c^{\left(0\right)}\right\}}_{c=1}^K$ from distinct categories and ${\overline{d}}_{\mathrm{intra}}$ is the mean Euclidean distance from each embedding $e_i$ to its assigned initial prototype $P_{c_i}^{\left(0\right)}$, averaged across categories. Values $\rho >1$ indicate that inter-category separation dominates within-category dispersion.

Prototype refinement is performed by minimizing a combined objective that increases inter-category separation while reducing within-category dispersion, initialized from the centroid-based prototypes ${\left\{P_c^{\left(0\right)}\right\}}_{c=1}^K$. Here, N is the number of training samples and the prototype set ${\left\{P_c\right\}}_{c=1}^K$ is treated as a trainable parameterization in ${\mathbb{R}}^{1536}$, initialized with $P_c\leftarrow P_c^{\left(0\right)}$ and then updated through gradient-based optimization. Since a desirable configuration satisfies $d_{\mathrm{inter}}>{\overline{d}}_{\mathrm{intra}}$, refinement minimizes a loss that jointly promotes separation and compactness.

Therefore, the total loss is defined in Equation (2) as a weighted sum of Additive Margin Softmax (AMS) [18] and Proxy Neighborhood Components Analysis (ProxyNCA) [19], with weights $\alpha$ and $\beta$ set to $\alpha =\beta =0.5$. In Equation (3), AMS enforces angular separation on the unit hypersphere using ${\theta }_{j,i}=\arccos \left({\displaystyle \frac{e_i^{\top }{P}_j}{{\parallel e_i\parallel }_2 {\parallel P_j\parallel }_2}}\right)$, additive margin $m=0.35$ radians, and scale factor $\kappa =30$. In Equation (4), ProxyNCA promotes within-category compactness by contrasting squared Euclidean distances $\parallel e_i-P_j{\parallel }_2^2$ with temperature $\tau =0.1$ over all K prototypes. Minimizing Equation (2) updates both the shared encoder and the prototype set from ${\left\{P_c^{\left(0\right)}\right\}}_{c=1}^K$ to the refined prototypes ${\left\{P_c\right\}}_{c=1}^K$ used in subsequent assignment and ranking stages.

$${\mathcal{L}}_{\mathrm{total}}=\alpha {\mathcal{L}}_{\mathrm{AMS}}+\beta {\mathcal{L}}_{\mathrm{ProxyNCA}}$$

(2)

$${\mathcal{L}}_{\mathrm{AMS}}=-{\displaystyle \frac{1}{N}}\sum _{i=1}^N\log {\displaystyle \frac{\exp \left(\kappa \cos ({\theta }_{c_i,i}+m)\right)}{\exp \left(\kappa \cos ({\theta }_{c_i,i}+m)\right)+{\sum }_{c\ne c_i}\exp \left(\kappa \cos {\theta }_{c,i}\right)}}$$

(3)

$${\mathcal{L}}_{\mathrm{ProxyNCA}}=-{\displaystyle \frac{1}{N}}\sum _{i=1}^N\log {\displaystyle \frac{\exp \left(-\parallel e_i-P_{c_i}{\parallel }_2^2/\tau \right)}{{\sum }_{c=1}^K\exp \left(-\parallel e_i-P_c{\parallel }_2^2/\tau \right)}}$$

(4)

After refinement, the refined prototype set ${\left\{P_c\right\}}_{c=1}^K$ is ranked using the score in Equation (5), which prioritizes assignment accuracy while still rewarding coverage. Let ${\widehat{c}}_i=\arg {\min }_{c\in \{1,\dots ,K\}}{\parallel e_i-P_c\parallel }_2^2$ denote the nearest-category assignment induced by the refined prototypes for validation sample i. For each category c, let $I_c^{\mathrm{val}}=\{i:{\widehat{c}}_i=c\}$ be the set of validation samples assigned to the prototype $P_c$. Coverage is defined as ${\mathrm{cov}}_c=\left|I_c^{\mathrm{val}}\right|/N_{\mathrm{val}}$, and assignment accuracy is defined as ${\mathrm{acc}}_c={\displaystyle \frac{1}{|I_c^{\mathrm{val}}|}}{\sum }_{i\in I_c^{\mathrm{val}}}\mathbf{1}\{{\widehat{c}}_i=c_i\}$.

$${\mathrm{score}}_c=0.7{\mathrm{acc}}_c+0.3\log \left(1+{\mathrm{cov}}_c\right)$$

(5)

To construct the normative ground truth for a sample i with category label $c_i$, a statement-level diff is computed between the vulnerable snippet $s_i^{\mathrm{vuln}}$ and its secure counterpart $s_i^{\sec }$; this ground-truth statement set is later queried by the repair policy conditioned on the winning refined prototype $P_{c_i}^{\ast }$, selected from the top-k ranked prototypes by maximizing the prototype score ${\mathrm{score}}_c$. Let $\mathrm{statements}\left(s\right)=\{s_1,\dots ,s_{\left|\mathrm{statements}\right(s\left)\right|}\}$ denote the set of syntactic statements extracted from snippet s. Additions are defined as ${\Delta }_{\mathrm{add}}=\mathrm{statements}\left(s_i^{\sec }\right)\setminus \mathrm{statements}\left(s_i^{\mathrm{vuln}}\right)$, removals as ${\Delta }_{\mathrm{remove}}=\mathrm{statements}\left(s_i^{\mathrm{vuln}}\right)\setminus \mathrm{statements}\left(s_i^{\sec }\right)$, and modifications as ${\Delta }_{\mathrm{modify}}=\{(u,v):u\in \mathrm{statements}\left(s_i^{\mathrm{vuln}}\right),v\in \mathrm{statements}\left(s_i^{\sec }\right),\mathrm{similar}(u,v)\wedge u\ne v\}$, where u is a vulnerable-side statement and v is its secure-side counterpart. The final normative statement set merges fully new secure statements with the secure-side revisions of modified statements, as defined in Equation (6).

$${\mathcal{N}}_{\mathrm{sentences}}={\Delta }_{\mathrm{add}}\cup \{v:(u,v)\in {\Delta }_{\mathrm{modify}}\}$$

(6)

In Equation (6), ${\mathcal{N}}_{\mathrm{sentences}}$ is the set of normative statements that constitute the ground-truth repair actions for the sample, namely, statements that must appear in the repaired code either as insertions from ${\Delta }_{\mathrm{add}}$ or as secure-side replacements selected from ${\Delta }_{\mathrm{modify}}$. Each normative statement $n_j\in {\mathcal{N}}_{\mathrm{sentences}}$ is associated with a binary control vector ${\mathrm{ctrl}}_j\in {\{0,1\}}^{M+R}$ over the OWASP and NIST control inventories introduced earlier: for an OWASP index $a\in \{1,\dots ,M\}$, ${\mathrm{ctrl}}_j\left[a\right]=1$ marks control a as required for $n_j$, and for a NIST index $r\in \{1,\dots ,R\}$, ${\mathrm{ctrl}}_j[M+r]=1$ marks the forbidden pattern associated with control r as disallowed when realizing $n_j$.

2.3. Vulnerability Fixing Stage

Repair quality is assessed using three complementary metrics capturing semantic correctness, normative compliance, and intra-category consistency. Let $N_{\mathrm{test}}$ denote the number of evaluated samples. For each sample $i\in \{1,\dots ,N_{\mathrm{test}}\}$, the system outputs a repaired snippet $s_i^{\mathrm{fix}}$, which is evaluated against the dataset secure reference $s_i^{\sec }$. Match ratio is defined in Equation (7) and measures the fraction of repairs that are semantically equivalent to the secure reference, where semantic equivalence $s_1\equiv s_2$ requires identical outputs for any admissible input in the input domain Inputs.

Compliance is defined in Equation (8) and measures adherence to the per-sample normative control sets provided by the dataset, namely the required set ${\mathcal{C}}_i^{\mathrm{req}}$ and the forbidden set ${\mathcal{C}}_i^{\mathrm{forb}}$. For each evaluated repair $s_i^{\mathrm{fix}}$, ${\mathcal{C}}_{\mathrm{req}}^{\mathrm{sat}}\left(i\right)\subseteq {\mathcal{C}}_i^{\mathrm{req}}$ denotes the subset of required controls satisfied by the repair, and ${\mathcal{C}}_{\mathrm{forb}}^{\mathrm{avoid}}\left(i\right)\subseteq {\mathcal{C}}_i^{\mathrm{forb}}$ denotes the subset of forbidden controls whose associated insecure patterns are absent in the repair, using the same control-mapping procedure applied during dataset construction.

Consistency is defined in Equations (9) and (10) and measures whether repairs associated with the same selected prototype exhibit coherent patch patterns. Let $c_{\left(1\right)},\dots ,c_{\left(k\right)}$ be the category indices of the selected top-k prototypes in ranked order, and for each $r\in \{1,\dots ,k\}$ let $I_{c_{\left(r\right)}}$ be the index set of evaluated samples whose winning category equals $c_{\left(r\right)}$. For each sample i, ${\mathrm{patch}}_i$ denotes the patch extracted from the pair $(s_i^{\mathrm{vuln}},s_i^{\mathrm{fix}})$, and ${\mathrm{centroid}}_{c_{\left(r\right)}}$ denotes the reference patch pattern for category $c_{\left(r\right)}$ computed as the most frequent patch among samples in $I_{c_{\left(r\right)}}$. In Equation (9), Bilingual Evaluation Understudy (BLEU) measures lexical similarity via n-gram overlap, and Abstract Syntax Tree (AST) similarity measures structural similarity by comparing the abstract syntax trees of the generated fix and the ground-truth fix. The system is considered successful when the thresholds in Equation (11) are simultaneously satisfied.

$$\mathrm{Match}\mathrm{Ratio}={\displaystyle \frac{1}{N_{\mathrm{test}}}}\sum _{i=1}^{N_{\mathrm{test}}}\mathbf{1}\left[s_i^{\mathrm{fix}}\equiv s_i^{\sec }\right]$$

(7)

$$\mathrm{Compliance}={\displaystyle \frac{1}{2}}\left({\displaystyle \frac{1}{N_{\mathrm{test}}}}\sum _{i=1}^{N_{\mathrm{test}}}{\displaystyle \frac{\left|{\mathcal{C}}_{\mathrm{req}}^{\mathrm{sat}}\left(i\right)\right|}{\left|{\mathcal{C}}_i^{\mathrm{req}}\right|}}+{\displaystyle \frac{1}{N_{\mathrm{test}}}}\sum _{i=1}^{N_{\mathrm{test}}}{\displaystyle \frac{\left|{\mathcal{C}}_{\mathrm{forb}}^{\mathrm{avoid}}\left(i\right)\right|}{\left|{\mathcal{C}}_i^{\mathrm{forb}}\right|}}\right)$$

(8)

$$\begin{array}{cc}\hfill {\mathrm{Consistency}}_{c_{\left(r\right)}}& ={\displaystyle \frac{1}{|I_{c_{\left(r\right)}}|}}\sum _{i\in I_{c_{\left(r\right)}}}[0.6\mathrm{BLEU}({\mathrm{patch}}_i,{\mathrm{centroid}}_{c_{\left(r\right)}})\hfill \\ \hfill & +0.4\mathrm{AST}({\mathrm{patch}}_i,{\mathrm{centroid}}_{c_{\left(r\right)}})],r=1,\dots ,k\hfill \end{array}$$

(9)

$${\mathrm{Consistency}}_{\mathrm{global}}={\displaystyle \frac{1}{k}}\sum _{r=1}^k{\mathrm{Consistency}}_{c_{\left(r\right)}}$$

(10)

$$\mathrm{Match}\mathrm{Ratio}\ge 0.75\wedge \mathrm{Compliance}\ge 0.85\wedge {\mathrm{Consistency}}_{\mathrm{global}}\ge 0.70$$

(11)

Finally, the system is considered successful when all three criteria are met simultaneously: $\mathrm{Match}\mathrm{Ratio}\ge 0.75$, $\mathrm{Compliance}\ge 0.85$, and ${\mathrm{Consistency}}_{\mathrm{global}}\ge 0.70$.

3. Results and Discussion

Across programming languages in the dataset, the system meets the Match Ratio threshold in all languages. Python achieves the highest Match Ratio (96.6%), followed by C (94.6%), C++ (83.1%), and Java (81.5%). Compliance exceeds the 0.85 threshold for Python and C (both at 0.92) but falls below it for Java (0.71) and C++ (0.69). Global consistency surpasses the 0.70 threshold across all languages, ranging from 0.73 in C++ to 0.95 in Python.

As shown in Table 1, all languages exhibit strong performance on CWE-798 (Hard-coded Credentials), CWE-78 (OS Command Injection), and CWE-89 (SQL Injection), where the required mitigations generally involve localized code modifications, such as removing embedded credentials in CWE-798 or applying input sanitization at parameter-entry points in CWE-78 and CWE-89. By contrast, CWE-862 (Missing Authorization) is more challenging in C++, as authorization checks may be dispersed across header files, framework-level mechanisms, and preprocessor directives, which obscures control mapping and lowers Compliance.

Table 1. Performance metrics by programming language.

Language	Match Ratio (%)	Compliance	Consistencyglobal
Python	96.6	0.92	0.95
C	94.6	0.92	0.90
Java	81.5	0.71	0.79
C++	83.1	0.69	0.73
Average	88.95	0.81	0.84
Standard deviation	±7.32	±0.13	±0.10

Differences across languages track structural complexity and validation clarity. Python attains the highest scores (Match Ratio (%) = 96.6, Compliance = 0.92, Consistency_global = 0.95), aided by explicit syntax and standard-library conventions that simplify rule-based validation. C matches Python in Compliance (0.92) but shows lower Consistency_global (0.90), reflecting multiple implementation patterns that satisfy the same controls. Java and C++ obtain lower Compliance (0.71 and 0.69), consistent with framework-dependent authorization and library-specific APIs that complicate normative-control mapping.

Only Python meets all three thresholds simultaneously (Match Ratio (%) $\ge 0.75$, Compliance $\ge 0.85$, Consistency_global $\ge 0.70$). Java and C++ exceed the thresholds for Match Ratio (%) and Consistency_global, but fall short on Compliance, suggesting that repair patterns are captured adequately while control mapping requires more language- and framework-aware handling.

The comparative analysis in Table 2 evaluates the proposed method against three state-of-the-art approaches in terms of programming language support, algorithmic paradigm, empirical performance, and integration of normative compliance. The comparison reveals three main gaps in the literature and the corresponding mechanisms incorporated in the proposed approach. Huang et al. [4] report 64.71% BLEU under sequence-to-sequence fine-tuning (NMT + CodeT5 + UniXcoder + PLBART); however, the absence of an explicit category-separation objective may allow heterogeneous repairs across closely related CWE categories. By contrast, prototype refinement with AMS and ProxyNCA promotes inter-category separation and intra-category compactness, yielding more stable category-conditioned repair under the selected refined prototype. VulD-Transformer [5] achieves 80.44% accuracy using Transformer encoders and FastText embeddings, yet its single-view representation and the lack of metric-learning refinement limit inter-category discriminability. In contrast, the dual-context representation $e_i^{\mathrm{code}}\oplus e_i^{\mathrm{cwe}}$ is refined through the same prototype-based metric-learning objective, improving category resolution under nearest-prototype assignment. Finally, de Fitero-Dominguez et al. [6] report 26% perfect predictions with quantized LLMs (Code Llama + Mistral (QLoRA)), suggesting performance degradation when repair is not guided by structured refinement and verification signals. In contrast, the proposed repairs are constrained by a statement-level normative ground truth aligned with ${\mathcal{C}}_i^{\mathrm{req}}$ and ${\mathcal{C}}_i^{\mathrm{forb}}$, enabling auditable compliance under the dataset control mapping.

Table 2. Comparison with related works in vulnerability detection and repair.

Work	Languages	Algorithm/Method	Performance	Normative Use
Huang et al. [4]	Java, C/C++, JavaScript	NMT fine-tuning (CodeT5, UniXcoder, PLBART)	BLEU: 64.71%	None
VulD-Transformer [5]	C/C++	Transformer + FastText	Accuracy: 80.44%	None
de Fitero-Dominguez et al. [6]	C/C++	Code Llama + Mistral + Quantized Low-Rank Adaptation (QLoRA)	Perfect Pred.: 26%	None
This work	Python, C, C++, Java	Prototype-based Deep Metric Learning	Match Ratio: 88.95%, Compliance: 0.81, Consistency: 0.84	Full (OWASP + NIST)

4. Conclusions

This work presented a prototype-based deep metric learning approach for automated vulnerability repair that integrates compliance constraints from OWASP and NIST SSDF. The method combines embeddings of vulnerable code and CWE descriptions, refines category prototypes, and validates repairs against statement-level control requirements. Evaluation on 959 samples across Python, Java, C, and C++ covering 15 CWE categories achieved a Match Ratio of 88.95%, together with 0.81 compliance and 0.84 consistency. Python satisfied all success thresholds simultaneously, while Java and C++ showed reduced compliance due to framework-dependent authorization patterns. Comparative analysis indicated that existing approaches lack normative integration and explicit category separation. The proposed framework addresses these limitations through dual-context embeddings, metric-learning refinement, and enforcement of required and forbidden control sets, enabling compliance verification. Future work will integrate LangChain for orchestration and historical repair memory, and implement the Model Context Protocol for CI/CD pipeline integration. Additional directions include extending control mapping for framework-dependent patterns and evaluating scalability on industrial codebases.