Student or educator? Sign up with your school email and get 6 months of Pro free.

The DOI matches its Crossref record; 52 of the 52 references it cites were found in a registry or an index; 14 of the 27 sources its claims cite were checked for support.

Detecting Automatic Software Plagiarism via Token Sequence Normalization

Open access
Sağlam, Timur, Brödel, Moritz, Schmid, Larissa, Hahner, Sebastian·2024·Proceedings of the IEEE/ACM 46th International Conference on Software Engineering

Abstract

While software plagiarism detectors have been used for decades, the assumption that evading detection requires programming proficiency is challenged by the emergence of automated plagiarism generators. These generators enable effortless obfuscation attacks, exploiting vulnerabilities in existing detectors by inserting statements to disrupt the matching of related programs. Thus, we present a novel, language-independent defense mechanism that leverages program dependence graphs, rendering such attacks infeasible. We evaluate our approach with multiple real-world datasets and show that it defeats plagiarism generators by offering resilience against automated obfuscation while maintaining a low rate of false positives.

Overview

CoChat Summary

TL;DR

The paper presents token sequence normalization, a language-independent defense mechanism that uses a token normalization graph to remove dead statements and topologically sort independent statements before token-based plagiarism comparison. Evaluated with JPlag on four Java datasets, it defeats insertion- and reordering-based automatic obfuscation while leaving false positives and runtime largely unchanged.

Key findings

  • For insertion-based attacks, JPlag without the defense computes an average similarity score to original (SSO) of less than 25% across all four datasets, dropping below 10% for TicTacToe; with the defense, mean SSO rises to over 99% for PROGpedia-19, PROGpedia-56, and TicTacToe, and over 96% for BoardGame.
  • For reordering-based attacks, without the defense TicTacToe and BoardGame average SSO never drops below 95%, while PROGpedia datasets range between 90% and 95%; with the defense, all mean SSOs rise above 98%.
  • For combined insertion-after-reordering attacks, without the defense average SSO is less than 20% for PROGpedia and BoardGame and below 10% for TicTacToe; with the defense, all SSOs rise to over 95%.
  • The defense leaves unrelated-solution similarity nearly unchanged: changes are less than 2%, and over 95% of individual unrelated comparisons have a similarity below 1%; runtime overhead is 0.89 seconds for TicTacToe and 6.45 seconds for BoardGame.

Methods

  • Design: a language-independent defense mechanism that enriches the token sequence with semantic information, constructs a token normalization graph (TNG) based on program dependence graphs, removes dead nodes, removes variable flow edges, and uses topological sorting to generate a normalized token sequence before pairwise comparison.
  • Data: four Java datasets—PROGpedia Task 19 (27 submissions, mean 131 LOC, median 106 LOC), PROGpedia Task 56 (28 submissions, mean 85 LOC, median 77 LOC), TicTacToe (626 submissions, mean 236 LOC, median 225 LOC), and BoardGame (434 submissions, mean 1529 LOC, median 1487 LOC)—totaling 1,115 originals and 285 plagiarism instances.
  • Analysis: implemented for JPlag and evaluated using the Goal-Question-Metric method against insertion-based, reordering-based, and combined automated obfuscation attacks, comparing similarity scores with and without normalization, false-positive rate, and runtime.

Limitations

  • The paper states that complex attacks such as refactoring or reimplementation (e.g., converting for-loops to while-loops) are not addressed, and the approach’s impact on them remains unclear; the threat model assumes obfuscation preserves program behavior.
  • The paper states that AI-based attacks, especially LLM-based obfuscation or fully generated solutions, are not optimized for and require additional defense mechanisms beyond the paper’s scope.
  • The text makes evident that evaluation is limited to Java datasets due to limited real-world dataset availability, although the mechanism is claimed to be language-independent; two datasets cannot be fully published due to sensitive data, and the PROGpedia datasets are too small for meaningful runtime measurements.

Model-written summary. Check it against the paper before relying on it.

Integrity signals

Registry

Crossref · 10.1145/3597503.3639192

Cites

52 of 52 references verified0 citation errors · 0 not checkable

Statistics

Nothing to recompute.

Figures

Figure 1 Token-based plagiarism detection process of JPlag.
Figure 1 Token-based plagiarism detection process of JPlag.CC-BY · From the PDF
Figure 2 Program dependence graph of the running example showing control dependencies (solid arrows) and data dependencies (dashed arrows).
Figure 2 Program dependence graph of the running example showing control dependencies (solid arrows) and data dependencies (dashed arrows).CC-BY · From the PDF
Figure 3 Token normalization graph for the PDG in Figure 2, fixed order edges (solid), variable order edges (dashed), and variable flow edges (dotted). The critical (C), fixed-order (F), and loop (L) flags, with the variable access sets (r for read, w for write), are included for illustrative purposes.
Figure 3 Token normalization graph for the PDG in Figure 2, fixed order edges (solid), variable order edges (dashed), and variable flow edges (dotted). The critical (C), fixed-order (F), and loop (L) flags, with the variable access sets (r for read, w for write), are included for illustrative purposes.CC-BY · From the PDF
Figure 4 Token normalization graph after the dead nodes and removal of variable flow edges, still present are fixed order edges (solid) and variable order edges (dashed).
Figure 4 Token normalization graph after the dead nodes and removal of variable flow edges, still present are fixed order edges (solid) and variable order edges (dashed).CC-BY · From the PDF
Figure 7 Detailed SSOs for the datasets' individual programs with our mechanism disabled (solid) and enabled (dashed).
Figure 7 Detailed SSOs for the datasets' individual programs with our mechanism disabled (solid) and enabled (dashed).CC-BY · From the PDF
Figure 8 The similarity scores of unrelated solutions with our defense mechanism enabled (orange) and disabled (blue).
Figure 8 The similarity scores of unrelated solutions with our defense mechanism enabled (orange) and disabled (blue).CC-BY · From the PDF

Verification

Claims the paper makes

13 Valid · 0 Not valid · 2 Not checked · 76 Own results and interpretations

28 more claims

Create a free account to see all 91 claims and to verify the 3 references still open.

See all claims — free account
  • Probably not a substantial claim. 29
  • It may state two separate claims as one. 42
  • The quote only partly states this claim. 1

Create a free account to see these claims.

Citations

Cites

Show all 51 references

Research works printed but not linked: 1

  1. Michael Wise. 1993. String Similarity via Greedy String Tiling and Running Karp-Rabin Matching. Unpublished Basser Department of Computer Science Report (01 1993).

Cited by

See all 9

Metadata

Authors
Sağlam, T., Brödel, M., Schmid, L., & Hahner, S.
Affiliations
Karlsruhe Institute of Technology (DE)
Venue
Proceedings of the IEEE/ACM 46th International Conference on Software Engineering
Publisher
ACM
Published
2024-04-12
Pages
1-13
ISSN
0270-5257 (ISSN-L)
OpenAlex
W4394769395
Cited by
9
References
51
Citations by year
2026: 3 · 2025: 2 · 2024: 4
FWCI
3.43
Type
conference paper
Language
en
Open access
Locations
  • ACM/IEEE International Conference on Software Engineering: Companion Proceedings (ICSE-Companion) (publishedVersion, cc-by)
  • Repository KITopen (Karlsruhe Institute of Technology) (submittedVersion)
Funders
Bundesministerium für Wirtschaft und Klimaschutz (19S21002)
Topics
  • Physical Sciences › Computer Science › Information Systems › Software Engineering Research
  • Social Sciences › Education › Academic integrity and plagiarism
  • Physical Sciences › Computer Science › Hardware and Architecture › Physical Unclonable Functions (PUFs) and Hardware Security
Keywords
software plagiarism detection, program dependence graph, false positives

About these checks

Registry, retraction, Cites and statistics results are computed, not judged, with one exception: a printed reference that no index lists is read once by a model before it counts as a citation error. Claims are extracted by a model and kept only when their quote appears verbatim in the text; each cited source is then checked, with a model’s help, for whether it says what the claim relies on. Those verdicts can be wrong — read the claim’s quote and the cited source before relying on one.

The claim verdicts this report counts are experimental: their accuracy is not yet measured.

A language model drew the claims from the paper on 2026-10-10, under version 3 of the claim definition (model deepseek-v4.1-flash, prompt extract-v3).

A second model labelled each claim on 2026-10-10 (model jev-1.13-20260917, definition revision gold-guideline-v0.2).

Cited sources are checked with a language model’s help (gpt-6-sol).

Statistics and arithmetic are recomputed, not judged.

Confidence bands are shown only for fields calibrated on our annotated test set. None is calibrated yet, so no band is shown.

What counts as a claim ›How we measure confidence ›How we check this ›

Are you an author, or do you see a problem with this page? Request a review

How to cite

Cite CoChat for the checks on this page, and the paper for its own findings.

This page
CoChat. (2026). Citation check: Detecting Automatic Software Plagiarism via Token Sequence Normalization. https://app.cochat.ai/papers/10.1145/3597503.3639192
The paper
Sağlam, T., Brödel, M., Schmid, L., & Hahner, S. (2024). Detecting Automatic Software Plagiarism via Token Sequence Normalization. Proceedings of the IEEE/ACM 46th International Conference on Software Engineering. https://doi.org/10.1145/3597503.3639192

Data sources

Bibliographic data: Semantic Scholar, OpenAlex, Crossref.

Contains information from the Semantic Scholar Academic Graph Datasets, made available under the ODC Attribution License (ODC-BY 1.0).

Semantic Scholar’s data is described in: Kinney, R., et al. (2023). The Semantic Scholar Open Data Platform. arXiv:2301.10140.