Engineering Blog

Vulnerability case studies.

Technical write-ups of real-world vulnerability patterns analysed by Questor, covering source-to-sink traces, negative controls, and remediation details.

A substring match on service name opened an SSRF

Match a service name with contains instead of equals and a caller can pick services you never meant to reach, then make your server call them.

Any script on your page can send telemetry as you

A global event listener takes whatever detail it's handed and ships it with your app's bearer token. A third-party widget can forge data in your name.

An unchecked test URL steers a browser through your tunnel

A configurable URL feeds a remote browser while a local tunnel is open. Set it to an internal address and the session reaches whatever the tunnel can.

A config object that can rewrite your hash function's guts

A hashing library merged caller-supplied config with an unrestricted property copy. Slip in a __proto__ key and you can move the object's prototype, or replace its finalize step outright.

One field name is all it takes to reparent a credential object

A credential's per-language value used the language name as a key on a plain object. A crafted item sets the prototype instead, and the tampered object rides along in the processed credential.

Turning a MAC into a String quietly breaks the MAC

Raw HMAC bytes got decoded into a default-charset string before comparison. That mangles invalid byte sequences, so two different MACs can compare equal. Enough to defeat the check.

When the last status entry wins, revoked disappears

Your verifier keys each result by a value the credential carries. Feed it two entries with the same key and the second overwrites the first. Guess which one the attacker wants to land last.

An unquoted variable in your test script is a code path

A test script dropped an environment variable into a command without quotes. Word splitting turns its value into extra arguments, and the right value loads attacker-chosen code during CI.

A short GCM tag is a forgeable GCM tag

The cipher wrapper took the authentication tag length as a plain constructor argument with no floor. Pass a small value and integrity gets cheap to forge.

Secrets in the query string end up everywhere you did not expect

A re-encryption endpoint took ciphertext key material as a URL parameter. Query strings end up in access logs and browser history, so that value now lives in a dozen places you never audited.

A null allowlist that quietly allows every field

Your template fills placeholders from a credential, gated by an allowlist. When the allowlist is null the gate is skipped, and a caller-picked pointer can pull the whole object into the output.

One shared device field crosses your BLE peers

Every connection callback overwrites the same device reference. Two centrals at once, and notifications meant for the first can land on the second.

Returning a Credential You Never Verified

Your service calls a backend, gets a credential-shaped response, and returns it as issued. If that hop is ever tampered with, you just handed out a forgery.

A few kilobytes of ZIP can be gigabytes in your heap

Loading arbitrary bytes as a ZIP and reading an entry fully into memory, with no ratio or size cap, is the textbook decompression bomb waiting to happen.

A public method takes an endpoint string and just calls it

No check on the endpoint at all. Whoever can influence it makes your server POST wherever they point it, internal services included.

Last session's blink still counts this session

Global liveness counters that never reset let a blink from one scan satisfy the next. The check passes for a photo because a real person passed it earlier.

Credential text dropped straight into an SVG becomes script

A rendering step pasted credential values into an SVG template without escaping. A value carrying markup breaks out of its slot and adds a live script to whatever renders the image.

A caller-set response URL sends your credentials anywhere

The destination for the credential response came straight from caller input. Point it at your own server and the signed payload follows.

Ask for a longer key, get zeros on the end

The KDF honored the requested key length but only generated as many bytes as the input held. The tail stayed zero-padded, and that padding shipped as key material.

Two Face Scans, One Set of Globals

Your liveness pipeline stashes landmarks in module-level variables. Two scans overlap and one person's face data lands in the other's accept decision.

A Build Variable That Picks Which Plugin Runs

Someone sets a version string in your CI config. The build script pastes it into a plugin coordinate, then downloads and runs that plugin. Whoever sets the string owns the build.

Who supplies the reference face wins the match

A face match is only as trustworthy as the reference it compares against. If the caller supplies both sides, the caller decides the result.

A second BLE connection can hijack the first's data

The peripheral tracks one peer in one field, replaced on every connect. An attacker who connects at the right moment becomes the destination for someone else's notifications.

Scan your repository.

Run Questor against a service repository and review the signed case dossier: verified vulnerabilities, filtered false positives, and offline-verifiable audit records.

© Copyright MACH41 (UK) Ltd. All rights reserved.