A Converter That Reads the Server's Own Files: CVE-2026-108694
On 11 October 2026 a vulnerability was published in ConvertX, a self-hosted file-conversion app, affecting every version up to and including 0.19.0. The one-line version is unsettling for anyone who runs a converter: an ordinary authenticated user could upload a document and get back the contents of files on the server that they were never supposed to see.
It is worth walking through, not to pile on a project that has already shipped a fix, but because the bug is a clean example of a mistake that is very easy to make the moment your product's whole job is to open files that strangers send you.
What the bug actually does
CVE-2026-108694 is an arbitrary file read rated CVSS 4.0 7.1 and classed as CWE-73: External Control of File Name or Path. The ingredients are mundane, which is the point:
- ConvertX supports reStructuredText as an input format.
- reStructuredText has an
includedirective, whose entire job is to pull the contents of another file into the document. - The conversion was run by the document tool Pandoc, invoked without the
--sandboxflag, so that directive was honoured against the server's real filesystem.
Put those together and the attack is a single uploaded file:
.. include:: /etc/passwd Convert that document, download the result, and the output contains whatever the conversion process was allowed to read: the password file, an application config with database credentials, a private key, the app's own source. No memory corruption, no clever chain, no second request. The feature worked exactly as written; it was simply pointed at the host.
Why converters keep walking into this
Here is the part that matters beyond this one project. This is not a missing patch. It is the shape of the pipeline. A file converter's reason to exist is to take bytes from an untrusted stranger and feed them to a powerful parser. Many of those parsers have features such as includes, external entities, remote references and embedded scripts, which are genuinely useful when you author the document and actively dangerous when an attacker does.
The markup include directive is one instance of a family you have almost certainly met before:
- XML external entities (XXE) that resolve
file:///etc/passwdwhile parsing an innocent-looking.xmlor.svg. - HTML and CSS that fetch
<iframe src="http://169.254.169.254/...">or a remote stylesheet when a renderer turns a page into a PDF. - Spreadsheet and document formats with external links, remote images, or macro hooks.
Every one of these is the same bug wearing a different format's clothes: a parser that is allowed to reach outside the document, handed a document written by someone who wants it to.
The fix that shipped, and the fix underneath it
ConvertX's own remediation was correct and direct: upgrade to 0.19.1, which runs Pandoc with --sandbox. If you run it yourself and cannot upgrade this minute, you can add the flag or disable the include directive in the reader. If you are a ConvertX user, do that; it closes the hole.
But notice how narrow that patch is. It depends on one flag, on one tool, for one format. The next format you add, or the next tool you shell out to, starts the clock again. A flag you have to remember to pass is a flag you will eventually forget.
The sturdier way to think about it is to stop trusting the parser to behave and instead make misbehaviour pointless:
- No host filesystem. The conversion should see its own input and nothing else: not
/etc, not the app's config, not other jobs' files. Theninclude:: /etc/passwdresolves to nothing. - No network. Cut network access at the operating-system layer, not with a setting inside the parser. A reference to an internal address or a metadata endpoint should have no route to travel, so a bypass in the parser layer still goes nowhere.
- No secrets, no persistence. Credentials should not be reachable from the process at all, and nothing should survive the job. The less a conversion can touch and the less it leaves behind, the less any single parser feature can ever expose.
The theme is defence in depth. The --sandbox flag would be enough if you never forgot it and the parser never had another trick; OS-level isolation would be enough if the sandbox flag were never missed. Assume both can fail and require an attacker to defeat two unrelated layers, and a single missing flag stops being a breach.
How we build around it
To be clear about the obvious question first: PrivConvert does not run ConvertX, and this CVE does not affect us. But we convert untrusted files for a living, so the class of bug is exactly what we design against.
Every conversion on PrivConvert runs inside its own isolated sandbox with no network and no access to the host filesystem or to any credentials. Files are processed in memory and erased the moment the job finishes, and one job can never see another's data. An include directive, an external entity, or a remote reference that tries to reach /etc/passwd or an internal address finds that the path and the route simply are not there. We treat the parser as hostile and let the sandbox, not a single flag, be the thing that holds.
If you want the longer version of that reasoning, we have written about why parser CVEs land on converters first, about why an SVG upload deserves the same suspicion, and about the same network-isolation argument in the context of HTML-to-PDF rendering.
If you run any file converter
You do not have to run ConvertX for the lesson to apply. Before you expose a conversion endpoint to the public, it is worth asking three questions about every format you accept:
- Can this format reference other files or URLs? Includes, entities, linked resources, remote images. If yes, assume an attacker will use them.
- What can the conversion process read and reach? If the answer is more than "its own input," that gap is the size of your exposure.
- If the parser is fully compromised, where does the attacker land? The honest answer should be "a sealed box with nothing in it and no way out."
Features that read files are not bugs. They become bugs the moment the thing reading is a stranger's upload and the thing being read is your server. Keep those two apart and a published CVE like this one is a patch note, not an incident.