Pith. sign in

REVIEW 4 major objections 5 minor 21 references

Breaking Obfuscation: Cluster-Aware Graph with LLM-Aided Recovery for Malicious JavaScript Detection

T0 review · 4 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read The paper claims obfuscated malicious JavaScript becomes detectable when an LLM restores the code and a cluster-wise graph transformer classifies the syntax tree, reaching F1 of 94.64% and 97.71% — gains of 10.74 and 13.85 points over…

desk verdict Real gain in the controlled comparison; headline F1 numbers are inflated against weaker baselines, but the paper deserves referee time. read the letter →

arxiv 2507.22447 v1 pith:FN7CFKU7 submitted 2025-07-30 cs.CR cs.LG

Zhihong Liang , Xin Wang , Zhenhuang Hu , Liangliang Song , Lin Chen , Jingjing Guo , Yanbin Wang , Ye Tian This is my paper
classification cs.CRcs.LG
keywords maliciousJavaScriptdetectioncodeobfuscationLLMdeobfuscationabstractsyntaxtreecluster-wisegraphtransformernode-to-clusterattentionneuralnetworkslowfalse-positivesecuritythresholds
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper sets out to establish that obfuscated malicious JavaScript — code scrambled by string encoding, variable renaming, control-flow flattening, and dynamic calls — becomes detectable when the code is restored before analysis and when the analyzer respects JavaScript's nested, dynamically typed structure. Its proposed mechanism is DeCoda: a multi-stage LLM deobfuscation pipeline that rebuilds the original logic and emits a normalized abstract syntax tree (AST), followed by a Cluster-wise Graph Transformer whose node-to-cluster attention reads each AST at both node and cluster granularity. On two benchmark corpora the paper reports F1-scores of 94.64% and 97.71%, absolute gains of 10.74 and 13.85 points over the best baselines, and at the low false-positive rates (0.0001 to 0.01) that security operations demand, a true-positive rate 2.5 to 5.9 times higher than the strongest competitor. A careful reader would care because obfuscation is exactly the evasion technique that defeats static scanners and sequence models, and the paper's claim is that semantic restoration plus hierarchical graph structure, not either component alone, is what closes the gap.

What carries the argument

Two linked components carry the argument. The first is a deobfuscation gate: an obfuscation entropy score $S_{\text{obf}} = 0.4H_{\text{lex}} + 0.4H_{\text{struct}} + 0.2H_{\text{control}}$ computed from token, structure, and control-flow complexity, with samples scoring above 7 sent through a six-instruction prompt (decode strings, rename variables, unpack payloads, simplify control flow, reconstruct dynamic invocations, preserve behavior exactly) to a DeepSeek model that returns cleaned code, which is then parsed into an AST with Esprima. The second is the Cluster-wise Graph Transformer: METIS partitions each AST into 8 clusters with an assignment matrix $\mathbf{C}$, coarse features $\mathbf{X}_P = \mathbf{C}^T\mathbf{X}$ and coarse adjacency $\mathbf{A}_P = \mathbf{C}^T\mathbf{A}\mathbf{C}$ are formed, and the N2C-Attn layer computes attention that is simultaneously node-level and cluster-level through a tensor-product kernel $\kappa_B(\{Q_i,q_i\},\{K_j,k_t\}) = \kappa_C(Q_i,K_j)\,\kappa_N(q_i,k_t)$. The dual-granularity kernel is the load-bearing object: it lets a node aggregate information conditioned on its cluster's global role, which is what the paper claims bridges scope fractures and scattered semantic nodes that plain message passing loses.

What would settle it

Take the malicious samples from Dataset 2, run the deobfuscation pipeline, and execute both the original and the cleaned scripts in a headless-browser sandbox, comparing network requests, DOM mutations, and eval or Function invocations. If a meaningful fraction of cleaned malicious samples no longer perform any of the original malicious actions — or if cleaned benign samples newly do — then the semantic-preservation premise fails, and the reported F1 numbers would partly reflect relabeled data rather than better detection.

Watch

Extended reading notes

Core claim

On its own terms, the paper claims that JavaScript's syntactic flexibility breaks both existing detection families in distinct ways: token-sequence models (BERT, CodeBERT, LSTM, CNN) lose the pattern when obfuscation renames, encodes, and flattens code, while plain graph message passing over ASTs loses scope-chain dependencies inside deeply nested closures and lets semantically similar nodes scatter in feature space. The discovery is that pairing an LLM deobfuscation stage with a cluster-aware graph transformer recovers what each family misses — the LLM restores lexical and structural clarity before feature extraction, and node-to-cluster attention couples fine-grained node semantics with cluster-level structural roles. In the paper's experiments this combination reaches F1-scores of 0.9464 on Dataset 1 and 0.9771 on Dataset 2, versus 0.8551 and 0.8605 for the strongest baseline (CodeBERT), and at fixed false-positive rates of 0.0001, 0.001, and 0.01 it achieves true-positive rates of 0.2473, 0.3872, and 0.8008, multiples of the best baseline's 0.0513, 0.0655, and 0.3171. The paper further claims the architecture itself is obfuscation-resilient, outperforming all baselines even on raw obfuscated input, and that the LLM step is a transferable preprocessing gain that improves F1 for every baseline model, with sequence models benefiting most.

Load-bearing premise

The load-bearing premise is that the LLM's deobfuscation preserves the sample's actual behavior, so a malicious script stays malicious and a benign script stays benign after cleaning; the paper states that only semantically equivalent samples are retained but never says how that equivalence is verified.

Editorial extensions

If this is right

  • Restoring obfuscated code before classification is a transferable preprocessing step: every baseline model improves when trained on the cleaned corpus, with sequence models gaining up to 6.13 F1 points on Dataset 1, so the deobfuscation stage could be attached to existing detectors without changing their architecture.
  • The cluster-wise graph architecture is a second, independent source of gain: on raw obfuscated code it already outscores the best baseline (F1 0.9050 and 0.9256 versus 0.8551 and 0.8605), so the reported advantage does not rest on the LLM step alone.
  • Finer cluster granularity and larger ASTs combine positively: with 8 clusters the F1 score climbs from 0.9607 at 1,000 nodes to 0.9870 at 4,000 nodes, while a single cluster stalls near 0.94, indicating that node-to-cluster attention is what scales.
  • At low false-positive rates (0.0001, 0.001, 0.01) the method's true-positive rate is 2.53 to 5.91 times the best baseline's, which is the operating regime where an anti-malware tool can run without drowning operators in false alarms.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A 2x2 reading of the tables (cluster-wise graph versus plain GCN, raw versus LLM-cleaned code) shows the cluster-wise graph on raw code already scoring F1 0.9050 on Dataset 1, slightly above plain GCN on cleaned code at 0.8952; the paper does not call out that comparison, but it suggests the architecture contributes as much as the deobfuscation step.
  • An obfuscator tuned against the pipeline is the natural stress test: obfuscations beyond the prompt's six instructions, such as environment-dependent strings or prototype-pollution gadgets, could survive cleaning or be rewritten into a benign-looking form, and Section 6 concedes that dynamic execution is not covered.
  • Because the labels ride on the LLM's fidelity, a headless-browser differential test of original versus deobfuscated samples is the cheapest validation of the semantic-equivalence filter; if payloads are routinely dropped during cleaning, the training labels and the reported scores inherit the error.
  • The margin as printed in the abstract, 10.74 and 13.85 points, matches the gap to BERT on Dataset 1 and to LSTM on Dataset 2, while the strongest baseline (CodeBERT) is beaten by 9.13 and 11.66 points; readers should attach the advertised margin to the right comparison.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes DeCoda, a framework for malicious JavaScript detection that combines LLM-based deobfuscation with a cluster-aware graph transformer. The method first uses a DeepSeek model to deobfuscate JavaScript code via a structured prompt pipeline, then converts the cleaned code into AST graphs, partitions each graph into clusters with METIS, and applies a Cluster-wise Graph Transformer with node-to-cluster attention (N2C-Attn) to classify the code as benign or malicious. The authors report F1-scores of 94.64% and 97.71% on two datasets, claiming absolute gains of 10.74% and 13.85% over state-of-the-art baselines, and report TPR multipliers of 4.82x, 5.91x, and 2.53x at low FPR levels. The paper includes a limitations section, a code link, and a controlled comparison in Table 3 where baselines are also given the deobfuscated data.

Significance. If the controlled results are accurate, the paper makes a useful empirical contribution: Table 3 shows that LLM deobfuscation improves all models, and the proposed graph architecture outperforms the best baseline even on the same deobfuscated input (by 4.81 pp on Dataset1 and 7.05 pp on Dataset2). The authors provide a public code repository and a thoughtful limitations section that acknowledges the lack of dynamic analysis and the choice of a cheaper LLM. However, the central quantitative claim is overstated: the abstract and introduction report gains against weaker baselines and against models denied deobfuscation, not against the best baseline in a controlled setup. In addition, the semantic-equivalence filter in Section 3.1.6 is unverified, which puts the reliability of the dataset labels in question. The novelty of the graph component is limited because it is directly adopted from Huang et al. (2024); the main contribution is the integration with LLM deobfuscation and its empirical evaluation.

major comments (4)
  1. [Abstract, Section 1, Conclusion, Tables 2 and 3] The claimed 'absolute improvements of 10.74% and 13.85% over state-of-the-art baselines' are not supported by the tables. In Table 2, the best baseline on both datasets is CodeBERT (F1 0.8551 on Dataset1, 0.8605 on Dataset2), so the actual gaps to the best baseline are 9.13 pp and 11.66 pp. The 10.74 pp figure is the gap to BERT and the 13.85 pp figure is the gap to LSTM. Moreover, Table 2 is not a controlled comparison because DeCoda receives LLM deobfuscation while the baselines are evaluated on original code. The controlled comparison in Table 3 shows gains of 4.81 pp and 7.05 pp over the best deobfuscated baseline (CodeBERT). The abstract, introduction, and conclusion should be revised to report the controlled numbers and to identify the actual best baseline.
  2. [Section 3.1.6] The statement 'Quality filtering ensures that only successfully deobfuscated samples with semantic equivalence are retained' is not accompanied by any concrete verification method. If the LLM removes or introduces malicious behavior during deobfuscation, the labels used for training and evaluation become wrong and all reported performance numbers are unreliable. The authors should specify how semantic equivalence is checked (e.g., differential execution, AST diff, manual audit of a sample) or explicitly acknowledge that semantic equivalence is assumed and justify that assumption.
  3. [Sections 3.1.1-3.1.5 and 4.4] The method description is internally inconsistent about which LLM is used. Sections 3.1.1 through 3.1.5 describe DeepSeek-R1, its Multi-head Latent Attention, its Mixture of Experts components, and a deobfuscation loss in Eq. (6) that includes an undefined L_semantic, which implies a fine-tuning procedure. However, Section 4.4 states that 'DeepSeek-Coder-7B-Instruct' was accessed through an API interface, and no fine-tuning is mentioned anywhere. Please clarify which model is actually used, whether Eqs. (1)-(6) describe an actual training pipeline or a conceptual derivation, and define L_semantic.
  4. [Table 4 and Abstract] The claim in the abstract of '4.82x, 5.91x, and 2.53x higher TPR compared to the best-performing baseline' is inaccurate at the 0.01 FPR level. According to Table 4, at FPR=0.01 the GCN baseline has TPR 0.3813, which is higher than CodeBERT's 0.3171, so the best baseline is GCN and the multiplier for DeCoda is 0.8008/0.3813 = 2.10x, not 2.53x. The abstract and the corresponding text should either compute the multiplier relative to the best baseline at each FPR level or explicitly name the baseline used for each multiplier.
minor comments (5)
  1. [Section 3.1.2] The obfuscation entropy threshold S_obf > 7 and the weights alpha=0.4, beta=0.4, gamma=0.2 are presented without any ablation or justification; please provide a sensitivity analysis or a reference to support these choices.
  2. [Abstract and Section 3.1.3] The abstract describes a 'multi-stage refinement' pipeline, but Section 3.1.3 presents a single static prompt template with no explicit stages; please clarify what the stages are or revise the abstract.
  3. [Section 3.4 and Related Work] The Cluster-wise Graph Transformer with N2C-Attn is attributed to Huang et al. (2024), but the paper often refers to it as 'our proposed method' without clearly delineating which components are novel to this work; please specify the new contributions relative to Huang et al. explicitly.
  4. [Figure 1 and Section 2.2] There are typos in the figure and text, e.g., 'Cluster-leveal embedding' and 'Graph-leveal embedding' in Figure 1, and 'code garph' in Section 2.2; these should be corrected.
  5. [Section 5.4] The scalability analysis in Table 5 uses synthetic node counts (1000, 2000, 4000) and cluster counts but does not report which dataset is used, whether these are real or generated ASTs, or any runtime measurements; please add these details to make the experiment reproducible.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the detection pipeline is an empirical construction whose reported gains are experimental outcomes, and the self-citations are contextual rather than load-bearing.

full rationale

The paper's chain is: obfuscated JavaScript is deobfuscated via the DeepSeek API, parsed into ASTs, partitioned with METIS, and classified with a Cluster-wise Graph Transformer whose N2C-Attention equations are explicitly attributed to the external published work of Huang et al. (2024), not to the present authors. No parameter is fitted to a subset of labels and then renamed as a prediction, and no quantity used in the method is defined in terms of the target F1/AUC/TPR results. The many self-citations in the reference list (Wang, Tian, Song, Liu, etc.) appear in the introduction and related work as context for JavaScript threats and graph learning; none of them supplies the uniqueness theorem, the architecture, or the benchmark numbers that support the central claim. The paper's own Tables 2 and 3 do contain an empirical-validity concern: the abstract's '10.74% and 13.85% absolute improvements over state-of-the-art baselines' are not the gaps to the best baseline shown in Table 2 (the gap to CodeBERT is 9.13 and 11.66 percentage points), and Table 2 is not a controlled comparison because DeCoda receives LLM deobfuscation while baselines see original code. However, an overstated or unfairly framed comparison is a correctness/experimental-design issue, not a circularity issue, because the reported numbers are measured outcomes rather than consequences of the method's own definitions or of a self-citation chain. The unverified 'semantic equivalence' filter in Section 3.1.6 is likewise a soundness gap about label reliability, not a circular derivation. Therefore the derivation itself is self-contained and no circular step can be exhibited from the paper's equations.

Assumptions & free parameters 4 free parameters · 5 assumptions · 0 invented entities

The central claim relies on a chain of unverified assumptions about deobfuscation faithfulness, graph representational power, and transferability of an existing graph transformer. These are not fitted parameters in the classical sense, but they are assumptions the reader is asked to accept.

free parameters (4)
  • Obfuscation entropy weights alpha, beta, gamma = 0.4, 0.4, 0.2
    Chosen by hand in Eq. (3) to compute S_obf; no sensitivity analysis is provided.
  • S_obf threshold = 7
    Arbitrary cutoff deciding whether a sample is deobfuscated; affects which code goes through the LLM, hence influences results.
  • Number of clusters m in METIS = 8
    Selected in Section 4.4 without justification; Table 5 shows performance varies with this number.
  • Model hyperparameters (layers, hidden dim, heads, dropout) = 3 layers, 128 hidden, 8 heads, dropout 0.1
    Set in Section 4.4; no sensitivity reported except for cluster count.
assumptions (5)
  • domain assumption LLM deobfuscation preserves semantic equivalence and the benign/malicious label
    Section 3.1.6 claims quality filtering but no concrete procedure is given. If deobfuscation changes behavior, labels are invalid.
  • domain assumption AST graph with data/control-flow edges captures behavior needed for classification
    Section 3.2 extends AST edges without evaluating whether this representation is sufficient.
  • domain assumption METIS partitioning into 8 clusters retains enough structure
    Section 3.3 and Table 5 show cluster count matters; no theoretical grounding is given.
  • standard math Cluster-wise Graph Transformer of Huang et al. (2024) transfers to JavaScript ASTs
    The method adopts the existing attention mechanism; it is assumed to work outside the original graph domains.
  • domain assumption Esprima parser correctly parses cleaned code
    Used in Section 3.2; parser errors could change graphs and labels.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Breaking Obfuscation: Cluster-Aware Graph with LLM-Aided Recovery for Malicious JavaScript Detection." pith.science (2026). https://pith.science/paper/FN7CFKU7

@misc{pith2026250722447,
  author       = {Pith},
  title        = {Pith review of: Breaking Obfuscation: Cluster-Aware Graph with LLM-Aided Recovery for Malicious JavaScript Detection},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/FN7CFKU7}},
  note         = {Machine review of arXiv:2507.22447}
}
read the original abstract

With the rapid expansion of web-based applications and cloud services, malicious JavaScript code continues to pose significant threats to user privacy, system integrity, and enterprise security. But, detecting such threats remains challenging due to sophisticated code obfuscation techniques and JavaScript's inherent language characteristics, particularly its nested closure structures and syntactic flexibility. In this work, we propose DeCoda, a hybrid defense framework that combines large language model (LLM)-based deobfuscation with code graph learning: (1) We first construct a sophisticated prompt-learning pipeline with multi-stage refinement, where the LLM progressively reconstructs the original code structure from obfuscated inputs and then generates normalized Abstract Syntax Tree (AST) representations; (2) In JavaScript ASTs, dynamic typing scatters semantically similar nodes while deeply nested functions fracture scope capturing, introducing structural noise and semantic ambiguity. To address these challenges, we then propose to learn hierarchical code graph representations via a Cluster-wise Graph that synergistically integrates graph transformer network, node clustering, and node-to-cluster attention to simultaneously capture both local node-level semantics and global cluster-induced structural relationships from AST graph. Experimental results demonstrate that our method achieves F1-scores of 94.64% and 97.71% on two benchmark datasets, demonstrating absolute improvements of 10.74% and 13.85% over state-of-the-art baselines. In false-positive control evaluation at fixed FPR levels (0.0001, 0.001, 0.01), our approach delivers 4.82, 5.91, and 2.53 higher TPR respectively compared to the best-performing baseline. These results highlight the effectiveness of LLM-based deobfuscation and underscore the importance of modeling cluster-level relationships in detecting malicious code.

Figures

Figures reproduced from arXiv: 2507.22447 by the authors.

Figure 1
Figure 1. Architecture of the our method. code garph. As demonstrated by Sheng et al. (2025); Liu et al. (2025b); Sun et al. (2025), GNNs excel at modeling complex structural patterns in graph data. JStrong Fang et al. (2022) apply graph convolutional networks to learn joint structural-semantic features, and JStrack Rozi et al. (2021) employs hierarchical GNNs to preserve syntactic information while analyzing nested code stru… view at source ↗
Figure 2
Figure 2. ROC curves • Multi-granularity Feature Fusion: The node-to￾cluster attention mechanism enables the model to capture features at multiple levels of abstraction, from local code constructs to global patterns, facilitating a deeper understanding of the code’s behavior. These advantages establish our method as a superior solution in terms of precision and generalization, making it an ideal choice for demanding security … view at source ↗

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

21 extracted references · 13 canonical work pages

  1. [8]

    Relationship- aware code search for javascript frameworks, in: Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering, pp. 690–701. Liang,H.,Yang,Y.,Sun,L.,Jiang,L.,2019. Jsac:Anovelframeworktode- tectmaliciousjavascriptviacnnsoverastandcfg,in:2019International Joint Conference on Neural Networks (IJCNN), I...

    work page 2016

  2. [9]

    Computer Networks 253, 110707

    Transurl:Improvingmaliciousurldetectionwithmulti-layertransformer encoding and multi-scale pyramid features. Computer Networks 253, 110707. Liu, R., Wang, Y., Xu, H., Qin, Z., Zhang, F., Liu, Y., Cao, Z., 2025a. Pmanet:Maliciousurldetectionviapost-trainedlanguagemodelguided multi-level feature attention network. Information Fusion 113, 102638. Liu, R., Wa...

    work page arXiv

  3. [11]

    Technical Report

    JS150k: A Dataset of JavaScript Programs with Rich and Diverse Semantics. Technical Report. SRI International. URL: https://www.sri.inf.ethz.ch/js150. accessed: 2025-07-07. Riedmiller,M.,Lernen,A.,2014. Multilayerperceptron. Machinelearning lab special lecture, University of Freiburg

    work page 2025

  4. [12]

    Jstrack: Enriching malicious javascript detection based on ast graph analysis and attention mechanism, in: Neural Information Processing: 28th International Conference, ICONIP 2021, Sanur, Bali, Indonesia, December 8–12, 2021, Proceedings, Part II 28, Springer. pp. 669–680. Rozi, M.F., Kim, S., Ozawa, S.,

    work page 2021

  5. [13]

    Deep neural networks for malicious javascript detection using bytecode sequences, in: 2020 International Joint Conference on Neural Networks (IJCNN), IEEE. pp. 1–8. Schrittwieser, S., Katzenbeisser, S., Kinder, J., Merzdovnik, G., Weippl, E.,

    work page 2020

  6. [16]

    WebGuard++:Interpretable Malicious URL Detection via Bidirectional Fusion of HTML Subgraphs and Multi-Scale Convolutional BERT

    Web- guard++: Interpretable malicious url detection via bidirectional fusion of html subgraphs and multi-scale convolutional bert. arXiv preprint arXiv:2506.19356 . Wang, Y., Xu, H., Guo, Z., Qin, Z., Ren, K.,

    work page Pith review arXiv

  7. [17]

    A large-scale pretrained deep model for phishing url detection, in: ICASSP 2023- 2023 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), IEEE. pp. 1–5. Wei, L., Wang, Y., Li, X., Li, J., Huang, Y., Liu, Z.,

    work page 2023

  8. [18]

    Javascript: the first 20 years. Proc. ACM Program.Lang.4. URL: https://doi.org/10.1145/3386327,doi: 10.1145/ 3386327. Xiao, W., Shi, C., Chen, M., Liu, Z., Chen, M., Song, H.H.,

    doi:10.1145/3386327

Show all 21 references
  1. [20]

    arXiv preprint arXiv:1409.2329

    Recurrent neural network regularization. arXiv preprint arXiv:1409.2329 . Zhang, T., Du, C., Zhou, Y., Guan, Q., Liu, Z., Huang, X., Gong, Z., Deng, L., Li, Y.,

    arXiv

  2. [21]

    https://github.com/ZZN0508/JavaScript_Datasets

    JavaScript_Datasets: JavaScript Malicious Code Dataset. https://github.com/ZZN0508/JavaScript_Datasets. GitHub repository, Accessed: 2025-07-07. Zhihong Liangholds a Master of Engineering in Computer Applications from South China Univer- sity of Technology. He is a Senior Prof...

    2025

  3. [49]

    Sheneamer, A.,

    URL:https: //doi.org/10.1145/2886012, doi:10.1145/2886012. Sheneamer, A.,

    doi

  4. [2014]

    Modeling and discovering vulnerabilities with code property graphs, in: 2014 IEEE symposium on security and privacy, IEEE. pp. 590–604. Zaremba, W., Sutskever, I., Vinyals, O.,

    2014

  5. [2016]

    arXiv preprint arXiv:1609.02907

    Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907 . Koroteev, M.V.,

    arXiv

  6. [2019]

    Nl2type: Inferring javascript function types from natural language information, in: 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE), IEEE. pp. 304–315. Raff, E., et al.,

    2019

  7. [2020]

    arXivpreprintarXiv:2002.08155

    Codebert: A pre-trained model for programmingandnaturallanguages. arXivpreprintarXiv:2002.08155. GeeksOnSecurity,

    2002 arXiv

  8. [2021]

    arXiv preprint arXiv:2103.11943

    Bert: a review of applications in natural language processing and understanding. arXiv preprint arXiv:2103.11943 . Lee, C., Son, S.,

    arXiv

  9. [2022]

    GitHub repository, Accessed: 2025-07-07

    JS-Malicious-Dataset: A Collection of Malicious JavaScript for Security Research.https://github.com/geeksonsecurity/ js-malicious-dataset. GitHub repository, Accessed: 2025-07-07. Greff, K., Srivastava, R.K., Koutník, J., Steunebrink, B.R., Schmidhuber, J.,

    2025

  10. [2023]

    3505–3518

    Adcpg: Classifying javascript code property graphswithexplanationsforadandtrackerblocking,in:Proceedingsof the 2023 ACM SIGSAC conference on computer and communications security, pp. 3505–3518. Li, X., Wang, Z., Wang, Q., Yan, S., Xie, T., Mei, H.,

    2023

  11. [2024]

    URL: https://arxiv.org/abs/2401.14196, arXiv:2401.14196

    Deepseek-coder: Whenthelargelanguagemodelmeetsprogramming–theriseofcodein- telligence. URL: https://arxiv.org/abs/2401.14196, arXiv:2401.14196. Huang,S.,Song,Y.,Zhou,J.,Lin,Z.,2024. Cluster-wisegraphtransformer withdual-granularitykernelizedattention. AdvancesinNeuralInforma- ...

    2024 arXiv

  12. [2025]

    arXiv preprint arXiv:2501.12948

    Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948 . Guo,D.,Zhu,Q.,Yang,D.,Xie,Z.,Dong,K.,Zhang,W.,Chen,G.,Bi,X., Wu, Y., Li, Y.K., Luo, F., Xiong, Y., Liang, W.,

    arXiv

  13. [3440]

    Scriptnet: Neural static analysis for malicious javascript detection, in: MILCOM 2019-2019 IEEE Military Communications Conference (MILCOM), IEEE

    Stokes,J.W.,Agrawal,R.,McDonald,G.,Hausknecht,M.,2019. Scriptnet: Neural static analysis for malicious javascript detection, in: MILCOM 2019-2019 IEEE Military Communications Conference (MILCOM), IEEE. pp. 1–8. Sun, H., Chen, M., Weng, J., Liu, Z., Geng, G.,

    2019

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.