I recently discovered that a Django repository I had received in what appeared to be a technical interview assignment from Upwork contained a Remote Terminal Agent.
What initially looked like an ordinary banking application turned out to be something considerably more dangerous: code designed to establish persistent remote terminal access to the developer's machine.
The incident is a reminder that running an unfamiliar codebase is not simply a matter of trusting its application logic. Development commands can execute arbitrary Python code, and seemingly harmless setup instructions can have consequences beyond the project directory.
This is my attempt to document what happened, what I found, and what other developers can learn from it.
How it started
On Sept 30th, I received a repository presented as a Django-based core banking application called Meridian Core Banking. The owner had instructions for bidding: "Clone the repo, run the three commands for setup, and attach the screenshot in your application"
Repository:
https://github.com/williams0025/Meridian-Core-Banking.git
I cloned it onto my Ubuntu 24.04 laptop, created a virtual environment, installed its dependencies, and proceeded with the usual Django setup.
I ran the three commands:
At the time, I had no reason to believe that these commands would install a remote access mechanism on my computer, sent the screenshot, and waited.
A few hours later, Upwork emailed me about a possible malicious file download from the said user, so I deleted the repository and did not think much of it.
Today I came across a tweet talking about a similar style of interview where the interviewee ran the repo through Claude during a live interview before cloning it, and it made the Interviewer furious enough to disconnect the call. Turns out it was a VS-code config kind of attack. So it triggered me to revisit the incident, restored the repository from Trash, and investigated what had happened with the assistance of Chat-GPT.
The discovery
The most important finding was in:
config/settings/load.py
The file contained an obfuscated Remote Terminal Agent implementation.
Its capabilities included:
Identifying the host machine.
Establishing a WebSocket connection to a remote relay.
Repeatedly attempting to reconnect.
Receiving remote session instructions.
Creating a pseudo-terminal and launching the machine's shell.
Forwarding terminal output to the remote endpoint and accepting remote input.
It was remote terminal access functionality embedded inside a Django project.
How Django became the execution trigger
The malicious module was imported from the project's base settings:
from .load import cli
cli()
The settings were used by the project's local and test configurations.
This meant that importing Django settings could execute the malicious code.
Consequently, commands such as migrations, tests, and starting the development server could trigger the malicious functionality.
The important lesson is that Django management commands are not inherently safe simply because they are familiar commands. The settings import chain matters.
Persistence: the more serious discovery
The agent also implemented persistence mechanisms for Windows, macOS, and Linux.
On my Ubuntu machine, it installed:
The service was disguised with the name browser-updater.service, but its actual description was:
Remote Terminal Agent
Its configuration included:
Description=Remote Terminal Agent
Restart=always
RestartSec=5
User=root
The service was enabled for startup and configured to run the copied agent using the Python interpreter inside the project's virtual environment.
This was particularly concerning because the service was configured to run as root.
Deleting the repository did not remove the system-wide service or the copied agent.
The timeline and an important uncertainty
The installation files have timestamps from September 30, 2026, when I originally installed and ran the project.
After deleting the repository, the systemd service remained, but its configured Python interpreter was inside the deleted virtual environment.
On November 14, 2026, after restoring the repository, I inspected the service.
Systemd showed that it had successfully started the agent at 00:18:53 EAT, with a running Python process.
The service logs also showed thousands of previous restart attempts ending in 203/EXEC, consistent with the configured executable being unavailable.
I stopped the service, and systemd subsequently reported it as inactive.
What remains unknown: I have not established whether the agent successfully connected to its remote controller, either during the original September installation or after its successful start in November. Nor have I established whether an operator ever opened a remote shell.
The successful local execution of the agent is confirmed. Successful command-and-control communication is not.
Why this matters
There are several lessons worth highlighting:
A repository is executable trust. Installing dependencies and running management commands can execute code you have not inspected.
Django settings are an execution surface. Imports and function calls in settings modules can execute during seemingly routine management operations.
Deleting a project is not incident remediation. A malicious program can create system-wide services, scheduled tasks, startup entries, or other persistence mechanisms outside the project directory.
Service names can be deceptive. A service called browser-updater may have nothing to do with browser updates.
Root-level persistence changes the severity of an incident. A process configured to run as root can potentially expose the entire machine.
Evidence matters. Distinguishing confirmed execution from suspected remote access is essential when documenting security incidents.
What I recommend to developers
Before running an unfamiliar repository:
Inspect Django settings and their import chains.
Search for subprocess creation, shell execution, network connections, and persistence mechanisms.
Review installation scripts, dependency declarations, and post-install hooks.
Avoid running unfamiliar projects with elevated privileges.
Use disposable virtual machines or isolated environments for untrusted code.
Remember that a Python virtual environment is not a security sandbox.
If you discover that malicious code has executed, disconnect the machine from the network, preserve evidence, rotate potentially exposed credentials from a trusted device, and consider a clean operating system reinstall.
Closing
I am publishing this investigation because fake technical assignments and malicious repositories can turn an ordinary developer workflow into a security incident.
The objective is not to discourage developers from exploring unfamiliar projects. It is to encourage a more deliberate approach to running code that comes from people and organizations we have not independently verified.
I hope this analysis helps other developers recognize the warning signs earlier, and gives security researchers useful material for further investigation.
Is there anywhere trustworthy that the malicious code might be useful in helping fight such kind of attacks? If you know, kindly advise.