StealMyBitcoin-PoC documents a completed PHP CTF solve, corroborated by the operator and one reporter describing local reproduction in two issue threads. Our source harness installed the checkout in 6 seconds and built it in 1 second; the separate exploit-lab attempt stopped at a missing Compose prerequisite. Use this repository to study a particular exploit chain in an owned, isolated lab. Readers seeking a fleet assessment tool or an ongoing Bitcoin prize should choose another route.
What people use StealMyBitcoin-PoC for
Ehsan187228 describes local reproduction in both issue #1 and issue #2, so these are two accounts from one reporter.
| Who used it | What they did | Reported outcome |
|---|---|---|
| Ehsan187228 in issue #1 | Reproduced the chain on Alpine PHP 8.4.26 CLI-server with four workers behind nginx | Reported a fresh nonce, process identity, binary hash and dummy flag in approximately seven of ten runs. |
| The same reporter in issue #2 | Described reproduction against the documented Alpine image and worker arrangement | Reported both address leaks and final execution markers; said the Debian layout warning saved time. |
The first thread identifies the returned execution evidence and gives a small local success sample. The second describes the target arrangement and a practical setup decision. Reading them together adds detail to one reporter's experience. Both threads were closed after the author answered questions about the historical key and published target source. Their closure concerns those questions, rather than a change to the exploit's reliability. Issue #1 reproduction record, issue #2 reproduction record.
The README also gives learners a sequence to examine: memory exhaustion, two address disclosures and a final cleanup callback. Each stage has an expected response and checks that determine whether the next stage proceeds. That structure makes the repository useful for learning how an execution claim differs from a crash report. The governing research question is why this calibrated chain works against its documented target. Project explanation and stage checks.
What happened when we ran it
Our 17 November 2026 exploit-lab attempt stopped at the safety prerequisite because none of the accepted Compose filenames existed.
The run header says the repository was deployed with its own Docker Compose and loopback ports. The step record instead reports a failed prerequisite requiring a Compose file. The concrete failure determines how we describe the attempt: deployment was blocked at that step. Teardown reports ok. These records belong to the separate exploit-lab attempt, while the install and build results below belong to our source harness.
| Exploit-lab step | Recorded result | What it means |
|---|---|---|
| Safety prerequisite | FAILED: no compose.yaml, compose.yml, docker-compose.yaml or docker-compose.yml | The runner required a Compose file and stopped. |
| Deployment header | Says deployed with its own Docker Compose | Conflicts with the failed prerequisite; the step record supports a blocked attempt. |
| Teardown | ok | Cleanup completed. |
Our run of the source harness used commit ada7ff1 and recorded 3 CPUs, 8 GB RAM and image ghcr.io/astral-sh/uv:python3.12-bookworm. We measured a checkout containing 3 files, approximately 764 source lines and 0.1 MB. Installation and build completed; the harness skipped tests because there was no tests script or target. The following table preserves those measurements separately from the deployment attempt.
| Source-harness observation | Our recorded result |
|---|---|
| Checkout | 3 files, approximately 764 source lines, 0.1 MB |
| Install | Succeeded in 6 seconds; 35 dependencies recorded; 39 MB on disk |
| Build | Succeeded in 1 second |
| Tests | Skipped: no tests script or target |
| pip-audit | 0 known vulnerabilities |
| Repository signals | 0 CI workflow files, no Dockerfile, no tests directory |
The README specifies a standard-library Python client, whereas the harness records 35 dependencies in its environment. Those descriptions concern different things: the script's documented requirements and the harness's measured environment. The target recipe separately creates a PHP container and an nginx container with Docker commands. Its use of individual Docker commands also explains why readers should distinguish that documented recipe from our runner's requirement for a Compose file. Client requirements and target recipe.
Where people get stuck: the PHP build and worker layout
The README says Debian PHP 8.4.26 has a different binary layout from the calibrated Alpine build and aborts at the code-leak stage.
A matching version banner answers an earlier, simpler question than the later layout check. Issue #2's reporter specifically credits the Debian warning with saving time. The README's target uses an FPM image tag but launches php -S, so requests reach the CLI HTTP server. For someone reproducing this chain, the image, server mode and worker arrangement are concrete parts of the recipe. Documented target arrangement, reporter's setup account.
| Symptom or obstacle | Evidence-backed response | Status |
|---|---|---|
| Debian reports the expected version but the code stage aborts | Follow the documented Alpine CLI-server calibration | Documented workaround |
| Windows Git Bash produces broken Docker mounts | Use PowerShell or an explicit Windows drive path | Documented workaround |
| Workers change or die between stages | Preserve the stage result; the source describes this failure mode | Documented race |
| Earlier addresses appear convenient to reuse | Obtain both addresses in the current invocation | Deliberate constraint |
| PHP returns a memory-limit fatal or nginx returns 502 | Read the final execution markers rather than counting the crash as execution | Documented interpretation |
| The historical target is unavailable | Follow the author's link to the operator's published source | Local study route |
The Windows problem concerns bind mounts. The README says Git Bash expands $PWD to an MSYS path that Docker Desktop resolves inside its VM, creating empty directories where files should be. PowerShell or a full drive path is the documented response. A broken target assembled through these mounts needs a setup correction before its HTTP responses can usefully inform an exploit investigation. Windows mount explanation.
The README names two distinct failure outcomes from its own ten-run sample: one heap-stage miss and two callback misses, alongside seven runs with execution markers. In the heap miss, ordinary 32-byte cookies yield no accepted address. In a callback miss, both leaks succeed but the final response contains the memory-limit fatal without the markers. The documentation treats both as failures and performs no automatic retry. Author's failure examples.
Recent issue replies explain the solve
The supplied repository metadata records a last push on 3 November 2026, and the sampled issues contain replies about the key, distribution and LLM use.
The issue replies answer specific research questions. Issues #1 and #2 discuss the historical key and target source; issue #6 describes distribution identification; issue #5 contains the author's model, access, prompting and setup disclosures. Those answers help a reader interpret the artifact. For teaching, preserve the source revision and target arrangement used in the exercise so later discussion refers to the same material. Distribution reply, LLM-use discussion.
A recovered server key did not control the advertised prize
The operator says the server held a wallet-branch WIF rather than the funded address's key, then records a separate prize transfer.
That explanation separates execution, recovery of the server value and control of the prize address. The operator says server logs supported successful execution of the flag helper with exfiltration, and that the solver knew the WIF stored on the server. The same statement accepts the result as a solve and later says the transfer was made. This is the operator's account of the settlement. Operator's solve and transfer statement.
Coins's supplied X post objects to the order of publication and wallet draining. The operator's wrong-key explanation addresses why those events could occur separately. In issue #2, KillaBoi describes a 52-character, checksum-valid mainnet WIF for a compressed public key and identifies an address different from the advertised prize address. The review therefore describes a corroborated CTF solve and separate settlement, rather than a direct sweep of the prize wallet. Timing objection, key-format clarification.
Security: keep raw run artifacts private
The source warns that a run directory can contain a private WIF and tells readers to publish the source file instead.
Saved responses help explain where an attempt stopped, but the same files can preserve returned secrets. Use dummy data for a shareable teaching exercise and inspect artifacts before attaching them to an issue. The README restricts the client to the historical challenge endpoint or a loopback lab and says other destinations abort before network traffic. Its producer deliberately reaches PHP's memory limit. Artifact warning, client restrictions.
The operator's practice repository recommends an isolated Linux lab VM and explains that Docker shares its Linux host's kernel. Its practice copy contains a public dummy flag, has no wallet or prize and makes no requests to external balance APIs. That is a useful environment distinction for a researcher selecting study material. Keep a disposable target under your control and follow the practice repository's isolation guidance. Operator's practice environment.
StealMyBitcoin-PoC vs php2shell-bypass-aslr-exp and the operator's lab
The operator's repository supplies target source, while HN participant leszczy names 9bie's project as another implementation they pursued.
| Choice | What the evidence supports | Choose it when |
|---|---|---|
| StealMyBitcoin-PoC | A request sequence calibrated for four-worker Alpine PHP CLI-server, with reproduction described by one reporter in two threads | You want to study this solve and its execution checks |
| 9bie/php2shell-bypass-aslr-exp | Leszczy reports pursuing it and working on shrinking its leak request | You want comparative source study of another implementation |
| Debian PHP image instead of the Alpine recipe | The README describes a layout mismatch despite the same version banner | You are studying build differences |
| pavja2/smbc-source-oct-2026 | Target and helper source with a public dummy flag and no wallet or prize | You want to inspect the challenge environment |
Leszczy's HN comment identifies a concrete request-size obstacle in their investigation of 9bie's implementation. The operator's source answers a different question by exposing the target and helper. Its current practice description specifies eight workers; this PoC's README specifies four. Both describe the CLI HTTP server despite an FPM image name. These are configuration facts to compare when deciding which repository answers your research question. HN alternative discussion, PoC calibration, operator's runtime description.
What the other reviews get wrong
Offsecblog describes a deterministic run, while the README documents seven successes and three failures in the author's ten-run lab sample.
The client sends at most twenty HTTP requests and performs no automatic retries. That bounded sequence controls what the client sends; worker selection still affects the outcome. The author's sample names heap and callback misses, and Ehsan187228 separately reports approximately seven successes in ten local runs in issue #1. Keep those accounts attached to their owners rather than turning either into a general reliability figure. Offsecblog description, author's sample, reporter's sample.
Offsecblog also says the health check confirms the exact PHP build. The README instead describes HTTP status and PHP version indicators at that stage, followed by a code-pointer fingerprint later. This distinction matters when selecting the target image: a version response and a compatible layout answer different questions. Finally, the challenge homepage records the win on 25 October 2026 and says no bitcoins remain on the server. Historical challenge links explain a completed event. Health-check description, challenge outcome.
FAQ
The operator reports successful flag-helper execution with exfiltration, answering the question about whether the challenge produced real execution evidence.
Did the challenge demonstrate real remote code execution?
The operator says server logs supported successful execution of the flag helper with exfiltration and accepted the result as a solve. Ehsan187228 also describes local reproduction in issues #1 and #2, naming execution markers. The operator's live-server account and the reporter's local accounts concern different environments, but both describe evidence beyond a PHP error response. Operator's statement, local reproduction account.
Why was the PoC published before the prize wallet was drained?
The operator says the server contained the wrong wallet-branch key and records a separate prize transfer. This explains the distinction behind Coins's timing objection: retrieving the server value and controlling the advertised funded address were separate events. KillaBoi's issue reply also names a different associated address for the recovered WIF. Operator's settlement account, timing objection, key reply.
Will the live challenge return, possibly with a dummy flag?
The HN record describes a temporary reopening on another hostname, and issue #2's author reply points readers to the published server source after reporting probable shutdown. The homepage says more challenges may appear in the future. For a new study exercise, the concrete resource supplied here is the operator's practice repository with its public dummy flag. Availability discussion, issue #2 reply, practice repository.
Can the recovered WIF be published for independent verification?
KillaBoi published the historical WIF and its associated address in replies to issues #1 and #2. Those replies answer the disclosure request directly. Readers investigating that historical value can consult the original threads; this review does not need to repeat the key string. The source's artifact-handling advice applies to new runs, whose raw responses can contain returned secrets. Issue #1 disclosure, issue #2 clarification.
Was the recovered key a leaf key or an extended private key, and did it derive the funded address?
KillaBoi describes a 52-character, checksum-valid Bitcoin mainnet WIF for a compressed public key and names an address different from the prize address. That is the concrete format answer in issue #2. The operator calls the misplaced value a wallet-branch WIF. Read those statements together as the supplied explanation of the key-placement mistake. Key-format reply, operator's explanation.
How did the author identify the server's Linux distribution?
KillaBoi says information leaked while obtaining addresses through cookies, then describes comparing it with addresses exposed through a Docker image. The author says those addresses matched their expected locations. This is the author's account of inference and corroboration in closed issue #6. It is separate from the README's simple health endpoint, which reports the PHP version and process ID. Distribution explanation, health endpoint.
Which LLM did the author use to solve the challenge?
KillaBoi reports moving from Mythos 5.1 to Daybreak GPT-6 Sol on Max Effort with Standard Speed after the earlier model blocked the task. The disclosure appears in issue #5 alongside answers about account access, usage and prompting. It gives readers the author's reported configuration for this attempt, rather than a comparative measurement of model performance. Author's model disclosure.
Did the author's LLM account have special access or removed guardrails?
KillaBoi names Anthropic CVP and Trusted Access For Cyber, then denies removed guardrails beyond those arrangements and describes basic, blue-team versions. The access qualification belongs in the answer because the author included it. The same issue records the model choice and subsequent prompting explanation, giving context for how the author describes the attempt. Account-access reply.
How many tokens and how much money did the complete attempt consume, including dead ends?
KillaBoi says actual usage and the credit amount could not be found, while reporting use of 52.16% of a 100 Plan. That percentage is the author's account of plan consumption. The question in issue #5 explicitly asks about the complete attempt, including dead ends, so the answer needs to preserve the distinction between a plan percentage and an itemized token or monetary total. Full usage reply.
How much human prompting and steering did the LLM require?
KillaBoi reports one initial prompt followed by a /goal to reach the flag, automatic resumptions after pauses and explanatory questions about the work. The author describes asking what the model was doing and how elements such as the payload worked. These are substantive answers to the steering question and should accompany the model name when discussing the author's account of the solve. Full Q4 reply.
What prompt and custom setup did the author use?
KillaBoi supplies an initial prompt asking to inspect and solve the CTF together, with the challenge URL and a pasted LiveOverflow tweet. The author says no real custom setup was used. The reply also says the model pulled game-hacking skills from awesome-game-security, which the author describes as mainly useless for web interaction. These details appear in the full Q5 answer. Initial prompt and setup disclosure.
Why is porting a working PHP exploit to another target difficult for open models?
This repository documents concrete build-layout and worker assumptions that affect a port: the Debian image has a different layout, and the final address calculation uses the four-worker Alpine arrangement. HN participants also describe uncertainty about their local results and difficulty with a leak request. These are target-engineering observations and attributed participant experiences. Target assumptions, participants' discussion.
What we have not tested yet
Our exploit-lab attempt stopped before execution, and the supplied metadata does not establish a latest release.
The install and build measurements concern commit ada7ff1. They supply no successful exploit reproduction, controlled reliability result or comparison between alternatives. The sandbox image label records configuration rather than actual runtime or operating-system versions. The two reproduction threads belong to one reporter and provide no basis for counting separate independent samples. Support capacity, a maintained compatibility matrix and interchangeability with the operator's eight-worker practice setup also remain outside our measurements.
Issue #5 supplies prompting and setup answers, but no complete transcript or independently verified effort accounting. Its plan percentage supplies no complete token or monetary total. The HN discussion and this PoC supply no controlled ranking of open or proprietary models. The key-format reply supplies no derivation path, and we have not independently derived the funded address from the recovered material. Current remote-target availability and any future reopening have no confirmed schedule in the supplied evidence.
The README says the historical live run lacked a full original outgoing request capture and response headers, and that the remote PHP executable and helper binary were not retrieved. A reconstructed request therefore remains reconstruction. The code-pointer fingerprint also supplies no proof of identical executable bytes. Our work adds no complete client audit, cross-build study, concurrency test or repeated fresh-container experiment. Historical capture account and fingerprint explanation.
The supplied video results mix unrelated cryptocurrency material and ambiguous uses of POC, so they support no project-specific demonstration or audience estimate. Rendered layout, resolved evidence links, accessibility, related links, recommendation modules and template behavior were not tested in this text-only correction. For the intended reader, the supported next step is to study the documented stages and target source, then record fresh execution markers and every failure in a separately authorized local exercise.


