All postsThe eleven-million-euro bicycle
Manipulated a trade-in valuation into eight figures. Triaged as Informative because someone has to wheel the bike into the shop.
Process · 5 min read
A major sporting goods retailer ran an online "Second Life" buyback program.
The idea is simple: you select your used gear from their catalogue, answer eight
questions about tyre wear and frame scratches, and the website gives you an
instant buyback offer. If you accept, you drop the item off at a store and
collect the money.
The valuation API had a straightforward business logic defect: it computed the
offer from a price the browser supplied in the request body, ignoring the
catalogue SKU sent in the exact same payload.
I pushed that calculation to its integer ceiling, generated an eight-figure
quote for an entry-level commuter bike, and persisted the deposit into the
retailer's live intake pipeline.
It closed as a duplicate, and as Informative. Payout: €0.
The request#
The frontend ran on Next.js, backed by an Apollo GraphQL service. When you
finish the condition questionnaire, the browser requests an estimate:
POST /api/buyback/bff?q=ArgusEstimatedPrice HTTP/2
Host: store.example.com
Content-Type: application/json
{
"operationName": "ArgusEstimatedPrice",
"variables": {
"diagnostic": {
"item": {
"article_code": "2684941",
"buying_year": 2022,
"buying_price": {
"currency": "EUR",
"amount_in_minor_unit": 35000
}
},
"diagnostic": {
"diagnostic_template_id": "906abaea-9211-47e6-9d6d-24e166e3fc0b",
"questions": [ ...8 answers... ]
}
}
},
"query": "mutation ArgusEstimatedPrice($diagnostic: ArgusEstimatedPriceInput) { argus(diagnostic: $diagnostic) { condition diagnostic_price { amount_in_minor_unit currency } } }"
}
The response:
{
"data": {
"argus": {
"condition": "good",
"diagnostic_price": {
"amount_in_minor_unit": 21100,
"currency": "EUR"
}
}
}
}
Article 2684941 is a road bike that retails new for €350. Declaring the
honest purchase price of €350 (35000 minor units) returned a quote of
€211, or roughly 60% of original value.
The request carries article_code, so the backend knows exactly which product is
being traded in. But it never queries the catalogue. The quote is derived
directly from amount_in_minor_unit.
Scaling the offer#
Send the exact same request, keeping the condition diagnostic and the article SKU
identical, but declare an original purchase price of €35,000:
"buying_price": { "currency": "EUR", "amount_in_minor_unit": 3500000 }
The response:
{
"data": {
"argus": {
"condition": "good",
"diagnostic_price": {
"amount_in_minor_unit": 1987900,
"currency": "EUR"
}
}
}
}
The condition was still "good". The diagnostic score didn't move. But the offer
jumped from €211 to €19,879.
The field had no plausible bounds check. It accepted values up to INT32_MAX:
| Declared purchase price |
Quoted buyback offer |
Ratio |
| €350.00 (catalogue) |
€211.00 |
0.60 |
| €35,000.00 |
€19,879.00 |
0.57 |
€21,474,836.47 (INT32_MAX) |
€11,548,510.00 |
0.54 |
The endpoint required no session cookies and no Authorization header. Any
unauthenticated caller on the internet could obtain multi-million euro quotes at
will.
Persisting the record#
A quote in a JSON response is just numbers in transit. To prove impact, I logged
into a test account and completed the submission flow (memberItemDeposit).
The service didn't recalculate the offer on deposit. It accepted the inflated
figure from the client session and wrote it straight into the database. Querying
the account's trade-in history returned:
{
"data": {
"memberItems": [
{
"article_code": "2684941",
"diagnostic_price": { "amount_in_minor_unit": 1154851000 },
"performed_by": "MEMBER",
"status": "NEW"
}
]
}
}
A live, pending buyback record for €11.5 million sitting in the retailer's queue
with status: NEW.
The triage response#
I filed the report as High (CVSS 7.5), arguing integrity failure on financial
valuation data and pipeline corruption.
The report was closed in under 48 hours:
- Duplicate. Another researcher had already found that
buying_price was
trusted from the client.
- Informative (No Impact). Even without the duplicate, the program declined
severity:
"The valuation generated online is only indicative. The customer cannot
leverage it to receive an automated payout; they must bring the physical item
into a retail store, where a staff member inspects the equipment and confirms
the valuation before any payment or voucher is issued."
Payout: €0.
Where the report failed#
The technical observation was accurate: the server trusted client input on a
financial field where it held the authoritative SKU.
The failure was in understanding the boundary of execution:
1. The physical firewall#
When a software flow ends in the physical world, the human in the loop is a
security control.
If an API mints automated gift cards or deposits cash directly into an account,
an inflated quote is an immediate financial drain. But here, the API minted an
appointment. The money could only move if an employee at the service counter
inspected a €350 bicycle and handed over eleven million euros.
In my report, I included this sentence:
"No money has moved. Hand-over happens in store, where an employee inspects
the item."
I wrote that as a disclosure of scope. Triage read it as an admission that the
vulnerability could not execute.
2. Pipeline clutter is rarely High severity#
Storing an absurd figure in a database looks dramatic in a screenshot. But
corrupting your own record in a customer portal is not an integrity breach of
the system; it's an integrity breach of your own row. Unless those junk records
break the batch reconciliation jobs or crash the back-office ERP, triage treats
it as bad input sanitisation.
3. Discoverability guarantees duplicates#
An unauthenticated GraphQL query that takes a plain JSON integer and multiplies
it into a price is the most discoverable defect on an e-commerce platform.
It requires no reverse engineering, no multi-step state machine, no timing race,
and no authenticated session. Anyone who clicks through the second-hand flow
with Burp Suite running in the background sees the parameter on their first run.
If a bug can be found by typing 999999 into an obvious JSON field, someone who
hunted the program six months before you already typed it.
The takeaway#
A business logic bug is only as severe as the automated action it commands.
Before spending time documenting an eight-figure calculation, follow the chain
all the way to where the currency moves. If the chain stops at a wooden counter
with a store clerk standing behind it, you have found an odd calculation, not a
payout.