Cybersecurity12 minUpdated:

OJS Under Attack: From Log Noise to an MITRE ATT&CK Dissection of a Real Intrusion

Real forensic analysis of an OJS attack using MITRE ATT&CK. Learn to distinguish automated scanning from actual compromise in your journal.

Published by OJS ONE

We have operated OJS since 2012, starting with version 2.4.

Technically reviewed on

Attacks against academic publishing platforms are not hypothetical. Journals running Open Journal Systems (OJS) are highly attractive targets for SEO spam injection, cryptomining, and credential theft campaigns. For incident response teams and sysadmins, however, the hardest part is often not stopping the attack — it is interpreting the logs correctly.

In a real-world case involving two OJS instances (3.1.2.4 legacy and 3.3.0.22), we observed firsthand how these campaigns operate. The most important lesson was not purely technical, but analytical: an HTTP 200 OK in the access log does not prove compromise, but a plugin execution chain does.

The Attack Map: Observed Kill Chain

Before getting into the tactical mapping, this is the anatomy of the intrusion we reconstructed by correlating historical log evidence with filesystem artifacts:

Phase Tactic Description
1 Reconnaissance Path scanning and SQLi probes
↓
2 Exploitation Attempt Injection through submissionId
↓
3 Privilege Escalation Abuse of UserImportExportPlugin
↓
4 Delivery Vector Upload of allowedUploads.tar.gz
↓
5 Persistence and Evasion Webshell in defaultTranslation.php

The Noise: Reconnaissance and the False Alarm of 200 OK

Every incident starts with reconnaissance. In the early stages, we observed a sharp rise in automated traffic probing for exposed secrets (/.env, /.git/config) and generic administrative paths (/wp-login, /owa/auth).

The campaign quickly narrowed in on an OJS-specific target: the citation plugin.

Log Evidence: Exploitation Attempt

The attacker launched an automated SQL injection campaign against the citationstylelanguage endpoint, obfuscating the submissionId parameter with payload families such as EXTRACTVALUE, UPDATEXML, and UNION.

Sanitized access log sample:

GET /index.php/revista/citationstylelanguage/get/vancouver?submissionId=283%20AND%20EXTRACTVALUE(1,CONCAT(0x5c,(SELECT%20USER()))) HTTP/1.1" 200 542 "-" "Mozilla/5.0..."

The interpretation error: Seeing 200 OK in a log like this often triggers immediate panic in Tier 1 SOC teams. In OJS, however, a 200 response here only means the web application successfully handled the URL. It does not mean the database returned stolen data to the attacker. Treating this as proof of successful exploitation leads to bad triage and bad conclusions.

MITRE ATT&CK: T1595 Active Scanning (Reconnaissance), T1190 Exploit Public-Facing Application (Initial Access)

If the SQL injection traffic was just noise, how did the attacker actually get in? A deeper review of historical logs from March 2026 exposed the real tactic. Once a valid session was obtained — whether through brute force, cookie theft, or some other session compromise — the attacker did not rely on an exotic exploit. Instead, they abused a native system function: a textbook living-off-the-land move.

They used the UserImportExportPlugin to inject new high-privilege accounts through malicious XML imports.

The Exploitation Chain

From malicious IP space, we identified a clear five-step sequence completed in under five minutes:

  1. GET .../management/importexport/plugin/UserImportExportPlugin (staging)
  2. POST .../uploadImportXML (upload of the malicious XML payload)
  3. POST .../importBounce (processing and parsing of the XML)
  4. GET .../import?temporaryFileId=99/100/101 (confirmation of the injected account set)
  5. POST .../user-grid/update-user (assignment of critical roles such as role_id=1)

Threat Hunting Takeaway

We also found isolated requests to user-grid/add-user in the logs. On their own, those are not enough. The difference between legitimate administration and an automated intrusion is the sequence. The appearance of uploadImportXML, immediately followed by importBounce and update-user, from an unusual source IP is the real behavioral indicator of compromise.

MITRE ATT&CK: T1078.003 Valid Accounts: Local Accounts, T1136.003 Create Account: Web Application, T1098 Account Manipulation

Persistence: The Webshell Arrives

With a rogue Site Admin account in place, the attacker moved into persistence. The objective was clear: maintain access even if the malicious user was deleted or passwords were reset.

The Delivery Vector

Logs showed immediate follow-on activity in plugin management: settings-plugin-grid/upload-plugin-file.

File analysis within that time window uncovered an uploaded artifact named allowedUploads.tar.gz.

This was not a legitimate plugin package. Its purpose was to abuse OJS plugin handling to overwrite trusted files and drop a backdoor webshell into:

ojs/plugins/generic/defaultTranslation/defaultTranslation.php

The Artifact: Webshell Characteristics

The modified file displayed classic evasion patterns designed to bypass shallow inspection, embedding a hidden file manager inside an otherwise legitimate plugin execution path.

Conceptual snippet of the evasion mechanism observed:

<?php
/* Injected code at the start of the legitimate plugin file */
if(isset($_POST['ojs_auth_key']) && $_POST['ojs_auth_key'] === 'attacker_hash_here') {
    $payload = "base64_encoded_string_here...";
    eval(gzuncompress(base64_decode($payload)));
    die();
}
/* Legitimate defaultTranslation.php flow continues below */
?>

This design required a specific POST parameter (ojs_auth_key). Without that secret, the webshell stayed dormant and returned the plugin's normal behavior, evading investigators and security tools that only issued GET requests.

MITRE ATT&CK: T1505.003 Server Software Component: Web Shell, T1027 Obfuscated Files or Information, T1059 Command and Scripting Interpreter

The Operational Challenge: Triage and Eradication in OJS

Understanding attacker tradecraft changes how the environment must be defended. But remediation for a compromise of this kind is not a matter of deleting random files. It requires disciplined forensic handling.

A. Privilege Audit and Database Persistence Review

The first critical step is not hunting for webshells. It is identifying asymmetric privilege escalation in the database. At OJS One, we use targeted audit queries directly against the transactional database to trace unauthorized assignments of Site Admin (Role 1) or Journal Manager (Role 16) privileges that may never be obvious from application logs alone. Poor cleanup at this layer can leave behind "ghost accounts" that restore attacker access later.

B. Threat Hunting and Obfuscation Detection

Modern attackers do not leave obvious filenames behind. Manual hunting for modified PHP files is not enough. Our incident response workflows rely on multi-layer obfuscation scans that detect nested eval, base64_decode, and in-memory decompression patterns such as gzuncompress, especially when they are surgically inserted into legitimate OJS plugin code, as seen in defaultTranslation.php.

C. Architectural Hardening and Isolation

The only reliable way to keep this vector from being reused is to enforce least privilege at the operating system layer:

Webroot isolation: the PHP runtime user should never have write access to core OJS components such as plugins/, lib/, or classes/.

Upload segregation: article storage (files_dir) must live outside the public web tree, preventing direct execution of disguised payloads.

Conclusion

Using MITRE ATT&CK is not just a reporting exercise. It turns thousands of chaotic log lines into a structured, defensible intrusion narrative. In this case, the attack moved from noisy probing to targeted abuse of XML import functionality, and ended with a webshell packaged as a fake plugin artifact.

In OJS security operations, the most valuable signal is not how many IPs your firewall blocked today, or how many SQL payloads appeared in your access logs.

In OJS, the exploit attempt tells you the attacker is interested. The role change in the database and the obfuscated webshell confirm the compromise.

Does Your OJS Infrastructure Show Signs of This Attack Pattern?

Reviewing access logs and spotting a 200 OK is not enough when dealing with advanced threats. If you have doubts about the integrity of your journal or suspect a silent intrusion, you need precise technical response.

OJS One is a cybersecurity firm specialized exclusively in Incident Response, Threat Hunting, and Hardening for Open Journal Systems environments. We do not provide generic website security. We handle deep compromise in academic publishing infrastructure.

Check your journal with the free OJS compromise scan or request an OJS cybersecurity audit: triage, eradication and hardening with evidence.

Cybersecurity for OJS

Is your OJS patched and free of prior compromise?

We audit the installation, apply OJS and PHP patches with evidence, hunt for webshells and persistence, and respond if an incident has already happened.

  • OJS-specific audit and hardening
  • Patches with a tested restore
  • Incident response

Cybersecurity for OJS

Is your OJS patched and free of prior compromise?

We audit the installation, apply OJS and PHP patches with evidence, hunt for webshells and persistence, and respond if an incident has already happened.

Review my OJS

Share