On 11 November 2026, OpenSourceMalware published a write-up of a PyPI package named aurum-pay, version 1.2.0. The analysis says the package presents itself as a payment SDK for an online casino, with methods for deposits, payouts, refunds, balances, and signed webhooks, and that those methods do what a payment client is supposed to do. The same write-up says the first real payment request is the moment a remote command is fetched and run. A package threat report is linked from that page at opensourcemalware.com/pypi/aurum-pay. The next day, a public threat note from RST Cloud pointed at the same analysis and repeated the package name, the version, and the claim that import alone does not start the behavior.
This is a web-development problem before it is a malware museum piece. Payment SDKs land in checkout services, billing workers, and the small internal tools that finance asks engineering to wire up before a launch. Those processes hold API keys, customer identifiers, and payout details. A dependency that looks like a normal client, and that stays quiet until the application actually charges or pays someone, will not announce itself in the import that a reviewer runs on a laptop.
If the name aurum-pay is already in a lockfile, a requirements file, or a container image, treat the host that ran it as exposed. Isolate it, keep the logs, revoke credentials that Python process could reach, and rebuild from an image you trust. The rest of this note is about how to look, what the report is and is not willing to confirm, and why a clean import is the wrong test.
What the 11 November write-up reports
The write-up is specific about the package and the version. It names aurum-pay 1.2.0 on PyPI. It says the documented surface covers deposits, payouts, refunds, balances, and signed webhooks, and that those methods work. It also says the casino website the package points at works. That combination is the point. A broken stub is easy to reject in review. A client that returns plausible payment responses is harder, because the failure mode a developer expects from a bad SDK is an error, not a quiet side effect.
The write-up says that, as of publication, both the package and the user account were still live on the index. That sentence is dated to the article, not to a later takedown notice. A team checking on 14 November should not assume the name has vanished because a blog existed three days earlier, and should not assume it is still listed because the blog said it was listed on the 11th. The check is the lockfile in front of you, plus the index page you open yourself. This note does not claim a live listing after the publication timestamp in the write-up.
The impact line in the write-up’s key-facts table is plain: arbitrary code execution, persistence, file theft, remote payload delivery, and screenshots. The trigger line is equally plain: the first API request made through the SDK. Those two lines are enough to decide the operational response. They are not a recipe, and this article will not reconstruct the request, the shell invocation, or the later stages. Readers who need indicators should use the source page, which keeps that list with the analysis that produced it.
A public note on 12 November, from the account RST Cloud, restated the same package, the same version, and the same trigger, and linked the write-up as its source. That note is circulation, not a second laboratory. It matters because it shows the report was already being copied into threat roundups within a day, which is how a name reaches a Slack channel before it reaches a change-advisory ticket.
Where the loader sits, and why an import test misses it
The write-up draws a line that dependency reviewers often skip. Installing the package does nothing malicious. Creating a client does nothing malicious. There is no install hook and no import-time code described in the report. The loader sits in the path that sends a real API call, and it runs once per process, with errors swallowed so the payment call can continue and look ordinary.
That design punishes the review habit that treats import as a safety test. A reviewer who creates a virtual environment, imports the module, constructs a client with a dummy key, and watches for a network connection will see a quiet process. The behavior the report describes starts when the application makes the call it was written to make: a deposit, a payout, a balance read, a refund. In a web service, that call is not a curiosity. It is the request handler.
The practical reading is uncomfortable for teams that rely on a sandbox job to “exercise new dependencies.” A job that imports every top-level module and exits has not exercised this package in the way the report says matters. A job that mocks the HTTP client and never lets a request leave the process has not exercised it either. The dangerous path, on the report’s account, is a successful or attempted payment call against the default host. You should not build that path in order to confirm the report. You should treat a lockfile hit as confirmation enough to move the host into incident handling.
This is also why a typo-squat detector that only scores the name is incomplete here, and why an install-hook scanner is incomplete in the other direction. The name is not a one-character neighbor of a famous library. The write-up describes a package that claims a brand, documents a real API, and waits. Name similarity rules will not flag it. Hook scanners that watch setup.py or import side effects will not flag it. The signal the report offers a web team is the package string itself, plus any configuration that points an application at the brand domain the package advertises.
A working site is a review problem
The write-up says the package points at a casino domain for its homepage and documentation, and that the site presents a functioning casino rather than an empty landing page. It treats that site as part of the threat, not as decoration. A working website, a branded address, and a realistic API surface are what a developer uses, in a hurry, as substitutes for a maintainer history.
That substitution is common in payments work. A product manager sends a link to “the SDK the processor published.” An engineer opens the docs, sees methods that match the ticket, and adds the name to the project. The review question that usually follows is whether the methods match the contract. The question the report forces is older than the methods: who published the name, how long the project has existed, and whether the company you think you are integrating has ever told you to install this package.
The write-up is careful about the domain’s past. Passive infrastructure data, it says, suggests the name had a gambling history years ago and was likely re-registered on 7 October 2026, one day before a controller certificate became valid. It then says public evidence does not yet establish the prior expiration date or prove an ownership change, and that historical registration data would be needed to confirm it. The date pair is a hypothesis the authors label as a hypothesis. A web team should not repeat it as a settled ownership story. The usable fact is narrower. A functioning marketing site, even one with an older classification as a gambling domain, is not a publisher identity. Publisher identity is the index account, the release history, and a confirmation from the company that is supposed to be taking the payment.
The write-up also says it did not interact with the site’s deposit or registration workflows, and that it does not know whether the current operator copied an earlier casino, restored archived pages, or built a new site around an old name. That restraint is useful. It keeps the engineering response tied to the package behavior the authors analyzed, instead of a theory about who owns a casino brand. If your application never installed aurum-pay, you do not need that theory. If it did, the brand story will not change the rebuild.
Two losses, and they are not the same ticket
The report describes two harms that a web team can mix up if they file one ticket and stop.
The first is code execution on the host that made the payment call. On the write-up’s account, the response to that first request is treated as a command, and the Linux command the authors recovered installs a remote access program that persists and can run further instructions from its operator. What those later instructions were is unknown, because they would arrive live. The write-up says to assume the host is compromised if the package was used. “Used” here means a real request, not a line in a blog post. A lockfile hit without evidence of a request is still a reason to pull the dependency and to inspect the host. It is not, by itself, proof that the later stage ran. The safe operational stance is still the one the report gives: assume exposure if the package was used, and do not spend the afternoon trying to prove a negative from missing files.
The second harm does not require the later stage. The write-up says the SDK’s default API host is the same domain that delivers commands, so applications using the package may be sending bearer API keys, payment and payout details, and customer identifiers to that domain as ordinary client traffic. That is data leaving the service on the path the developer intended, toward a host the developer did not independently verify. Rotating a payment-processor key after the fact does not unsend the bodies that already left. Customer identifiers in those bodies are a privacy incident of their own, separate from whether a remote shell landed.
A single “we removed the package” commit can close neither ticket. Removal stops future installs from that lockfile. It does not rebuild a host that already ran a request. It does not rotate keys that were present in the process environment. It does not tell you which customers were in the payloads that already went out. Those are three workstreams. Collapsing them into a dependency bump is how this class of report turns into a repeat incident a month later, when someone restores a machine image that still has the old environment.
If the name is already in a lockfile
Search for the string. In a Python web repo the usual places are requirements.txt, requirements-*.txt, pyproject.toml, poetry.lock, Pipfile.lock, uv.lock, and any vendored wheel directory. Container build files count, including a pip install line in a Dockerfile and a constraints file copied in during the image build. So do notebooks and one-off scripts under scripts/ that a billing cron still runs. The import name the report associates with the package is aurum_pay. A search that only looks for the hyphenated distribution name will miss that import form, and a search that only looks for the import form will miss the distribution name. Search both.
Do not install the package in order to inspect it. Do not run a small script that constructs a client and calls a balance method “to see if we are affected.” That call is the trigger the report describes. If a developer already did that on a laptop, the laptop joins the host list. Curiosity is not a staging environment.
If you find the name, write down where it was found before you delete the line. The path, the lockfile version, the commit that introduced it, and the service that built from that commit are the evidence a later review will ask for. Then follow the report’s response order: isolate affected hosts, preserve endpoint and network evidence, revoke credentials the Python process could reach, and rebuild from a trusted image. Preservation comes before a tidy uninstall. A rebuilt image is the end state, not the first command, because a rebuild that discards logs also discards the chance to see whether the request path ran.
Credentials in scope are wider than the payment key. A checkout worker often has a database URL, a session secret, a cloud role, and a webhook signing secret in the same environment. The report’s phrase is credentials the Python process could reach. That is the list to rotate, not the one key named in the README of the SDK. After rotation, confirm the new values are what the rebuilt service actually loaded. A rotation that updates a secret manager and leaves the old container running has not finished.
Tell the people who own customer notice. Engineering can establish whether payment bodies may have left the service. Engineering cannot decide, alone, whether that fact requires a customer message. Hand the date range, the fields the SDK would have sent, and the hosts involved to whoever owns that decision. Do not invent a customer count you did not query.
Searching a repository without running the package
A useful search is boring, and that is a virtue. Start with the distribution name and the import name. Then search configuration for the brand domain the write-up names, because an application can carry a base URL in settings after someone has already deleted the dependency line. A settings module, an environment sample file, and a Helm values file are all places a base URL survives a “remove the package” pull request.
Look at git history, not only at the default branch. A package can be added on a feature branch, used in a preview deployment, and removed before merge. Preview environments are still hosts. If your platform keeps preview logs, the host list includes those deployments for the days the branch existed. If preview environments share a cloud role with production, the credential list includes that role even when the branch never merged.
CI caches deserve a look. A job that ran pip install against an unpinned file, or against a branch that briefly contained the name, may have left a wheel in a cache that a later job reused. The defensive check is the cache key and the date, not a command that fetches the package again. If you cannot tell whether a cache is clean, throw the cache away and rebuild. A few minutes of cold installs are cheaper than a debate about whether a wheel was present.
Transitive dependencies are the other place the name hides. A direct search of your top-level requirements can miss a package pulled in by something else. Lockfiles exist so you can answer that question without resolving the index again. Read the lockfile. If you do not have one, that absence is its own finding: you cannot prove the name was absent, and you should generate a lock from a known-good date before you call the tree clean. Generating that lock should use the index as it is now only if you also pin hashes. A fresh resolve that is allowed to float can introduce a different problem while you are looking for this one.
None of this requires running the SDK. None of it requires the command lines, addresses, or tokens in the source write-up. Those belong in the detection work of people who already have endpoint tooling and who are reading the indicator list on the source page. A web team that pastes that list into a wiki, stripped of context, tends to copy the wrong half: the fascinating strings, and not the response order.
What a provenance tab does not settle
PyPI’s project pages now carry a Security tab that shows where a release file came from and when that story looks incomplete. We covered that interface, and a separate AWS bulletin about awswrangler logs, in PyPI’s Security tab and the awswrangler 3.18.0 patch. The tab is a reading aid for release files. It is not a verdict on what a module does the first time an application calls it.
Provenance, in that design, is about whether files in a release carry attestations, and of what type. An attestation can say a trusted publisher uploaded the file, or that a build produced the file from a given commit. Neither sentence says the commit is safe to put in a checkout service. A malicious project can publish from a repository it controls, with a publisher it controls, and still match the mechanical story the tab knows how to display. The absence of an attestation is a warning. The presence of one is a narrower fact about the upload path.
That distinction matters this week because the two stories will sit next to each other in the same Slack channel. One is an index interface that helps you read a release. The other is a named package whose documented behavior, according to a third-party analysis, includes a loader on the first real request. Using the tab as a reason to skip the lockfile search confuses a general improvement with a specific incident. Using this incident as a reason to ignore the tab confuses a specific incident with the ordinary work of reading a release before you pin it. Do both. They answer different questions.
The same split showed up when pip 26.2.2 dropped emSign while an operating-system trust store lagged. A packaging change and a host trust store are different clocks. Here, the index user interface and a package’s runtime behavior are different clocks. A team that updates its reading habits and does not search for this name has done half the week. A team that searches for this name and never looks at how it decides to trust the next payment SDK has done the other half.
A test suite that never pays
Many Python web codebases test payment integrations with a fake transport. The test builds the client, asserts on the URL it would have called, and returns a canned JSON body. That is a good test for your own request builder. It is a useless test for the question this report raises, and it can create a false sense that “CI ran the SDK.”
CI ran your mock. The report’s trigger is a real request through the package’s own method, against the host the package uses by default. A green pipeline that never lets that method open a socket has not cleared the dependency. It has cleared your assertions. Those are different objects, and the difference is the entire finding.
There is a second testing trap. Some suites mark a single contract test as allowed to hit the sandbox of a real processor, using a test key. If that test was pointed at this package’s default host, even once, the worker that ran it is in the host list. Check the job history for the days the dependency was present, not only the latest successful build on the default branch. Scheduled jobs, manual workflow runs, and a developer running the contract test locally all count.
Do not add a “detection test” that calls the live method and greps the process table afterward. That is how a news article becomes the trigger. Detection for this report, at the web-team layer, is a string search and a deployment inventory. Detection at the host layer is for the people reading the indicator section of the source, on machines already isolated.
Questions to ask before the next payment SDK
The report is one package. The review habit that would have caught it is older than the package, and it is the part worth keeping after the name is gone from your tree.
Ask who told you to install it. A link in a chat, a result from a code assistant, or a docs page on a domain you have never contracted with is not an instruction from a processor. Payment integrations should start from a vendor you already have a contract with, and from a package name that vendor’s own documentation names. If the only docs are on a site that appeared with the package, stop. The write-up’s description of a functioning casino is what that failure looks like when it is done well: the site exists, the methods exist, the contract does not.
Ask how long the project has published, and whether the releases carry a history you can read. A first upload that already claims production payment methods is a reason to slow down, not a reason to praise a small dependency. You do not need a download-count threshold invented for this article. You need a human who can say, in the pull request, which company operates the service and which URL on that company’s site names the package. If that sentence cannot be written, the package does not go in.
Ask what the process will hold when the client runs. A billing worker with a cloud role, a database password, and a payment key is a poor place for an unfamiliar client, even when the client is legitimate. Split the process if you can. A worker that can charge a card does not also need to read every other secret in the account. The report’s second harm, data sent to the default host, is worse when the same process could also reach unrelated credentials, because the rotation list grows with the environment, not with the SDK’s README.
Ask whether the lockfile is hashed. An unpinned name is how a review of “the SDK” becomes a review of whatever the index serves tomorrow. Hash-pinned installs will not detect a malicious first release you chose on purpose. They will stop a later swap from entering the build without a diff. That is the property you want on a checkout service. We have written about supply-chain pins in other incidents, including the LiteLLM release that had to be yanked. The habit is the same: the version in the chat is not the version in the image until the lockfile says so.
Ask what the rollback is. If the new client misbehaves, can you return to the previous processor integration without a schema migration and a weekend? A payment change that cannot be reversed is a payment change that should not ride along with an unfamiliar package. The report does not discuss rollback. The omission is normal for a malware analysis. It is not normal for a launch checklist.
What the report leaves open
A careful reading has edges, and the write-up marks several of them. It does not claim to know what an operator sent after a connection was established. It does not claim to have watched live traffic from the controller. It does not claim to have used the casino site’s deposit or registration flows. It labels the domain re-registration story as a hypothesis that needs historical registration data. It says it does not know whether the current site was copied, restored, or newly built around an old name.
Those gaps do not weaken the package finding. They limit what you should say in a status update. “The 11 November analysis says aurum-pay 1.2.0 fetches and runs a remote command on the first API request, and says the package and account were still listed at publication” is a sentence you can source. “The casino operator is the same party that registered the domain in 2019” is not a sentence the write-up lets you source. “Every host on the internet that resolved that domain is compromised” is not a sentence anyone should write. Exposure follows use of the package, on the report’s own terms, not a DNS lookup by a curious engineer.
There is also no CVE number in the write-up we are citing. Do not invent one for the ticket title. The package name, the version, and the date of the analysis are the identifiers that match the source. A ticket titled with a guessed identifier will not match the vendor mail you send, and it will not match the search a teammate runs next week.
The write-up is a third-party analysis, not a statement from the index and not a statement from a payment network. Treat it as that. It is detailed, it names a version, and it separates what was recovered from what was inferred. It is still one team’s account. If your own telemetry contradicts it, record the contradiction and keep the host isolated while you sort the conflict. Do not resolve the conflict by running the package.
A short audit for this week
Set a boundary of a few hours, not a research project. The goal is to know whether the string is in anything you ship, and to have a host list if it is.
Start with source control. Search the default branch and the branches that deployed in the last month for aurum-pay and aurum_pay. Include lockfiles and environment samples. Note the commits, even if the line was later removed.
Move to images and hosts. Compare running images with the commits you just listed. A cluster that has not rolled since before the dependency was added is a different case from a cluster that built on the day the line existed. Write the image digests down. If you cannot map a digest to a commit, treat that service as unknown until you can, and unknown means you do not call it clean.
Check the jobs that are easy to forget. Cron workers, preview apps, a laptop used for a demo, a notebook on a shared machine, a one-off data pull that imported a payments helper. The report’s trigger is a request from a Python process. Any process that could have made one belongs on the list if the package was installed there.
If the list is empty, say so in the ticket and stop. An empty search is a result. Do not expand the work into a general tour of every payment library you use, and do not install aurum-pay in a lab to “see the behavior.” If the list is not empty, start the response the write-up already states, and hand customer-notice questions to the people who own them.
Then write the review rule you wish you had last week, in one paragraph, in the repository that adds dependencies. Name the rule: a payment client comes from a vendor you have a contract with, the package name appears on that vendor’s site, the lockfile carries hashes, and the process that holds the client does not also hold every other secret in the account. That paragraph will outlast the package name. The package name still has to be searched this week, because a rule written on Friday does not rewrite Thursday’s image.
The index will keep changing. Project pages will keep getting easier to read. Neither of those facts reviews the next pull request. A web team that can say, with a search and a host list, whether aurum-pay 1.2.0 ever entered a service it runs, has done the work this report asks for. A web team that can also say who is allowed to add the next payment SDK has done the work the report implies, which is the part that still matters after this name is gone from the news.
Discussion
Leave a comment
No comments yet
Be the first to start the conversation.