> ## Content Index
> Fetch the complete content index at: https://sudosecurity.org/llms.txt
> Use this file to discover other available public pages before exploring further.

# Jellyfin's Threat Model Is Your Brother-in-Law
- URL: https://sudosecurity.org/jellyfin-2026-security-version-12/
- Published: 2026-11-21T05:40:00.000Z
- Updated: 2026-11-21T05:40:00.000Z
- Description: Four Jellyfin CVEs landed in 2026 and not one of them needs an admin account. One needs only the ability to name a file. Meanwhile Jellyfin 12 shipped in September, the version numbers stopped starting with 10, and every "am I patched" check you wrote is now wrong.
- Author: Santhdium
- Tags: Self Host Saturday, Jellyfin, Self Hosting, RCE, CVE, Server Security, Exploits, Vulnerabilities, Cybersecurity

Most self-hosted services are things you run for yourself. You are the only account, the threat is the internet, and the hardening question is "what can an unauthenticated stranger reach."

A media server isn't that. A media server is the one thing in the rack that you deliberately hand accounts to. Your partner, your parents, the friend who watches one show a year, your brother-in-law who asked if you had anything to watch on a flight. Six accounts, four of them belonging to people who could not tell you what a reverse proxy is, all behind a login you set up in about ninety seconds because the person wanted to watch something.

Which makes Jellyfin's 2026 unusually worth reading, because four CVEs landed and **not one of them requires an administrator account.** One of them requires only the ability to put a file in the library with a name of your choosing.

This is Self Hosting Saturday. Last week was [a pre-auth RCE in Nextcloud's bundled Collabora server](https://sudosecurity.org/nextcloud-collabora-code-cve-2026-110447/), which was a stranger-on-the-internet problem. This week is the opposite shape and I think the harder one to think about.

## What to Do First

Jellyfin **12.4** is current, released 26 October 2026\. If you are on anything in the 10.11 line, you are missing a major version. If you are on anything before 10.11.10, you are missing security fixes that have been public since May.

The short version: get to 12.x. The longer version is the whole back half of this article, because the migration is not a patch-level bump and the version numbering changed underneath it.

## The Four, and Who Can Reach Them

Here is the year, sorted by the thing that actually matters — not severity, but what an attacker needs to have already. Five CVEs, and the top two need no Jellyfin account whatsoever.

| CVE            | What it is                                              | What the attacker needs                     | Fixed in |
| -------------- | ------------------------------------------------------- | ------------------------------------------- | -------- |
| CVE-2026-48793 | FFmpeg command injection via a filename                 | The ability to name a file in the library   | 10.11.10 |
| CVE-2026-49246 | MKV attachment filename path traversal, titled "to RCE" | The ability to put an MKV in the library    | 10.11.10 |
| CVE-2026-49247 | Path traversal to arbitrary file write                  | Any user account                            | 10.11.10 |
| CVE-2026-35032 | SSRF and arbitrary file read via the LiveTV tuner       | Any user account                            | 10.11.7  |
| CVE-2026-35031 | Path traversal to file write, chained to RCE            | Admin, *or* the Upload Subtitles permission | 10.11.7  |

Read the third column downward. That's the article.

### The one that needs a filename

`CVE-2026-48793` (GHSA-wwwm-px48-fpvq, CVSS 8.8) is my favourite and my least favourite. Jellyfin interpolated a media path straight into an FFmpeg argument that was already inside double quotes, and never escaped the double-quote character. A `"` in the filename closes the quoting early, and the rest of the name lands outside it.

The fix is one line and it says everything:

```diff
-                arg.Append(" -i file:\"").Append(subtitlePath).Append('\"');
+                arg.Append(" -i file:\"").Append(subtitlePath.Replace("\"", "\\\"", StringComparison.Ordinal)).Append('\"');

```

That is commit `a8da0664a`, "Fix GHSA-wwwm-px48-fpvq," in `EncodingHelper.cs`. It also fixed the identical pattern one line over on `state.AudioStream.Path`, and routed three paths in `SubtitleEncoder.cs` through `EncodingUtils.NormalizePath()`. So this is not only subtitles — audio stream paths were interpolated the same way, which widens the set of files that can carry the payload.

If that sounds familiar it should, because it's the same bug as last week's. Collabora's `proxy.php` built a `bash -c` string out of request headers; Jellyfin built an FFmpeg invocation out of a filename. Different project, different language, different decade of code — identical root cause. A string that came from outside reached a place where something else decides what is data and what is instruction, and nothing in between made that decision explicit. In both cases the fix was four lines or fewer, which tells you the bug was never difficult. It was only invisible.

The practical shape of it: an attacker needs to get a file with a chosen name into your library. On a single-user server that is nobody. On a server where anyone can upload — a shared drop folder, an `*arr` stack pulling from indexers, a family member with write access to a share — that's a much wider set of people than it sounds like, and none of them need a Jellyfin password at all. The filename is the payload. The library scan is the delivery mechanism.

### The one that needs a filename *inside* a file

`CVE-2026-49246` (GHSA-f47c-m7gr-q92j) is the same class one level deeper, and it is the reason the "who can name a file" column matters more than it looks.

An MKV is a container, and the things inside it carry their own metadata. Attachments — the mechanism that ships fonts alongside a video for subtitle rendering — have a filename tag. Jellyfin trusted that tag and passed it into `Path.Combine` without sanitising it, so a crafted attachment name redirects extraction to any absolute path on the host.

The trigger is the part worth knowing: per the CVE record, "any playback action of the affected video" by a client that burns in subtitles by default. Nobody has to click anything unusual. Somebody presses play on a file, Jellyfin extracts the attachments so it can render the subtitles, and the extraction goes where the filename says.

So the attacker does not even need to control the name of the file in your library. They need to control a string *inside* it — which is a thing you cannot see by looking at your filesystem, cannot grep for with `find`, and which survives every rename you might do on the way in. Fixed in 10.11.10.

`CVE-2026-49247` (GHSA-jg92-mrxq-vv75, CVSS 8.8) is almost comically direct. The `POST /ClientLog/Document` endpoint took the `Client` and `Version` fields out of the `Authorization` header and used them to build the filename it saved to. A traversal sequence in `Client` escapes the log directory and writes wherever you like, with `.log` forced onto the end.

That suffix is the only thing standing between it and something much worse, and "the extension is constrained" is a mitigation that holds exactly until somebody finds a place where a `.log` file is dangerous. Any user with a login can do it.

The fix, commit `4fb779920`, "Sanitize ClientLog upload filename to prevent path traversal," does the job properly — it runs both fields through `PathHelper.GetSafeLeafFileName()`, adds a GUID, and then checks the result with `PathHelper.IsContainedIn()` before opening the stream, which is a belt-and-braces check on top of the sanitization rather than instead of it.

There is also a server setting in front of this endpoint that nobody seems to mention:

```csharp
    public bool AllowClientLogUpload { get; set; } = true;

```

Default `true`, in `ServerConfiguration.cs`, and the controller returns `Forbid()` when it is off. Client log upload exists so that users can send you diagnostics. If nobody has ever sent you one, turning it off removes this endpoint from your attack surface entirely, patched or not.

`CVE-2026-35032` (GHSA-8fw7-f233-ffr8) is the one I'd be most worried about on a shared server. The LiveTV M3U tuner endpoint did not validate the tuner URL. Hand it an HTTP URL and you have [SSRF](https://sudosecurity.org/what-is-ssrf/) from inside your network. Hand it a non-HTTP path and you have arbitrary file read.

The documented chain is the part to sit with: add a tuner pointing at a server you control, serve back a crafted M3U that references Jellyfin's own database, exfiltrate the database, and pull admin session tokens out of it. Ordinary user to administrator, through a feature for watching television.

And the reason an ordinary user could reach it was a default. I checked this in the repository rather than taking anyone's word for it, and the fix commit is the proof — `3c9b71e12`, "Fix GHSA-8fw7-f233-ffr8 with improved sanitization," touched two files, and one of them was not a parser:

```diff
         entity.Permissions.Add(new Permission(PermissionKind.EnableLiveTvAccess, true));
-        entity.Permissions.Add(new Permission(PermissionKind.EnableLiveTvManagement, true));
+        entity.Permissions.Add(new Permission(PermissionKind.EnableLiveTvManagement, false));

```

That is `Jellyfin.Data/UserEntityExtensions.cs`, in `AddDefaultPermissions()`, which `UserManager` calls once per user at creation. Every account created before that commit got Live TV management switched on.

The other half of the same commit added the thing that was actually missing from the parser:

```csharp
        private static bool IsValidChannelUrl(string url)
        {
            return Uri.TryCreate(url, UriKind.Absolute, out var uri)
                && (string.Equals(uri.Scheme, "http", StringComparison.OrdinalIgnoreCase)
                    || string.Equals(uri.Scheme, "https", StringComparison.OrdinalIgnoreCase)
                    || string.Equals(uri.Scheme, "rtsp", StringComparison.OrdinalIgnoreCase)
                    || string.Equals(uri.Scheme, "rtp", StringComparison.OrdinalIgnoreCase)
                    || string.Equals(uri.Scheme, "udp", StringComparison.OrdinalIgnoreCase));
        }

```

A scheme allowlist, which is what kills the arbitrary file read — before it, an M3U line that was a bare filesystem path or a `file://` URL got treated as a channel source. Note what the allowlist still permits, though: `http` and `https` to any host. The file read is closed. **SSRF is narrowed, not eliminated** — it is still possible to point a channel at something on your internal network, and what contains that now is the authorization change rather than the parser.

Because a sibling commit the same day, `740e9f874`, "Lock down tuner API to be admin-only," moved ten endpoints off the Live TV permissions entirely:

```diff
-    [Authorize(Policy = Policies.LiveTvManagement)]
+    [Authorize(Policy = Policies.RequiresElevation)]

```

Eight were on `LiveTvManagement` and two on `LiveTvAccess`, which is default-`true` and still is. So the fix was three things at once: validate the URL, stop granting the permission to new users, and require admin regardless.

**Here is the part that matters more than any of it.** Defaults are applied once, at account creation, and written into the database as a row. Flipping the default in code does not revoke anything. If you created accounts on a Jellyfin older than April 2026 — which is most people with a family server — those accounts **still have `EnableLiveTvManagement` set to true today**, on 12.4, fully patched. The admin-only lockdown is what protects you now, not the default.

Which means the permission audit later in this article isn't belt-and-braces. It is the only way that grant ever comes off, because no upgrade will do it for you.

### The one with the long chain

`CVE-2026-35031` (GHSA-j2hf-x4q5-47j3) is the headline-grabber and, I would argue, the least urgent of the four for most readers.

The subtitle upload endpoint (`POST /Videos/{itemId}/Subtitles`) did not validate the `Format` field, so a crafted extension gave path traversal and arbitrary file write. From there the public write-ups chain it: arbitrary file read via `.strm` files, database extraction, privilege escalation to admin, and finally code execution as root by writing `ld.so.preload`.

That last hop is why the scoring on this one's a mess, which is the next section. But note the prerequisite: an administrator account, or a user you granted Upload Subtitles. That's a narrower door than the other three. If you have never handed out that permission, this one's largely about defence in depth; the other three are about Tuesday.

A public proof-of-concept exists for this CVE. I'm not linking it and I'm not reproducing any part of it, but you should know it exists, because "is there a working exploit in the wild" is a real input to how fast you move. For what it's worth, EPSS puts exploitation probability under one percent and it is not in CISA's KEV catalogue.

---

> If you're enjoying what you've read so far, we recommend [The Complete Self-Hosted Productivity Stack: Nextcloud, Vaultwarden, Immich, Jellyfin, and Paperless in 2026](https://sudosecurity.org/self-hosted-productivity-stack-nextcloud-vaultwarden-immich-jellyfin-paperless-2026/) as your next read.

---

## Three Scores, One Bug, and Two Sources That Got It Wrong

CVE-2026-35031 is published with three different severities depending on where you look: 10.0 from GitHub as the CNA, 9.9 from NVD's secondary scorer, and 8.8 from NIST as NVD primary. That's a big enough spread to change whether a change-control board treats it as drop-everything or next-sprint.

The entire difference is one metric. Here are the two vectors:

```
GitHub:  CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
NIST:    CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H

```

`S:C` versus `S:U`. Scope Changed versus Scope Unchanged. Everything else is identical.

I ran both through the CVSS 3.1 formula rather than trusting anybody's arithmetic:

```
S:C  impact = 6.0477   exploitability = 3.1096   base = roundup(1.08 x 9.1573) = 9.9
S:U  impact = 5.8731   exploitability = 2.8353   base = roundup(8.7084)       = 8.8

```

Two things fall out of that.

First, the real disagreement is 9.9 against 8.8, not 10.0 against 8.8\. The GitHub vector computes to **9.9**, not the 10.0 that gets published alongside it. One vulnerability database I checked states that this vector "computes to 10.0" and that the 9.9 therefore looks wrong; it has it backwards. 9.9 is what the vector produces. The published 10.0 is the outlier.

Second, the metric they disagree about is the right one to disagree about, and NIST is arguably wrong. Scope Changed means the vulnerability lets you affect resources beyond the security authority of the vulnerable component. A bug in Jellyfin that ends with code execution as root via `ld.so.preload` has unambiguously left Jellyfin's security authority — it owns the host now. Scoring that `S:U` prices it as "the worst thing that happens is inside Jellyfin," which isn't what the chain does.

While I was in there I checked CVE-2026-35032 too, where one source states the published 8.1 disagrees with its vector and should be 7.7:

```
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N  ->  impact = 5.1771  exploitability = 2.8353  base = 8.1

```

8.1 is correct. That source is wrong as well.

And then there is CVE-2026-49246, which goes the other way and is stranger than either. Its title is "Potential MKV attachment filename path traversal to RCE." Its CVSS 4.0 vector is:

```
CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N/E:U

```

Base score: **1.7, Low.** Read the impact metrics. `VC:N` — no confidentiality impact. `VI:L` — low integrity impact. `VA:N` — no availability impact. A vulnerability whose own title ends in "to RCE" is scored as though the worst outcome is a small unauthorised write, with `E:U` for unproven exploit knocking it down further.

Both readings are defensible and that is the problem. The CNA scored the primitive it could demonstrate — an arbitrary file write — rather than the code execution the write plausibly leads to. That is arguably the conservative and correct thing to do. But the practical consequence is a 1.7 on a bug that writes attacker-controlled content to an arbitrary absolute path on your server, triggered by someone pressing play. If you sort your patching queue by severity, this one sorts below a cosmetic CSS issue.

I'm not writing any of this to dunk on vulnerability databases or CNAs, which do a thankless job at enormous scale. I'm writing it because two out of two third-party CVSS annotations I checked were arithmetically wrong, and a third score is defensible but will mislead anyone triaging by number. The formula is four lines you can run yourself in less time than it takes to read a disagreement about it. If a score is load-bearing for a decision you are making, compute it — and then read the title and decide whether the vector matches what the title says.

## Jellyfin 12 Exists, and It Breaks How You Check Your Version

Here's the part that's going to cause support threads for the next year.

Jellyfin shipped 12.0 in early September 2026\. Not 10.12 — **12.0**. From the 12.0 RC7 release notes, verbatim:

> Starting with this release, we are dropping the preceding `10.` from our versioning.

The `10.` has been decoration since 2018, a holdover from the Emby fork. It is now gone. The releases since have come fast: 12.1 in September, 12.2 in early October, 12.3 and then 12.4 on 26 October.

This breaks things in two different ways, and the second is worse than the first.

The obvious one is pattern matching. Anything that identifies Jellyfin by a version shaped like `10.something` stops matching:

```console
$ for v in 10.11.10 12.4; do
>   printf '%-10s ' "$v"; case "$v" in 10.*) echo "matches 10.*";; *) echo "NO MATCH";; esac
> done
10.11.10   matches 10.*
12.4       NO MATCH

```

If your inventory, your dashboard, or your "which hosts are behind" query keys off that shape, Jellyfin quietly drops out of the results. Not flagged as outdated. Absent. And absent looks like fine.

The second one is older and nastier, and version 12 only exposes it. A minimum-version gate written as a string comparison does not do what it reads like it does:

```console
$ python3 -c "
for v in ['10.11.9','10.11.10','12.4']:
    print(f'{v:10} >= \"10.11.10\" lexically: {v >= \"10.11.10\"}')"
10.11.9    >= "10.11.10" lexically: True
10.11.10   >= "10.11.10" lexically: True
12.4       >= "10.11.10" lexically: True

```

Look at the first line. **`10.11.9` passes a check for "at least 10.11.10"**, because lexically `9` sorts after `1`. A patch-level gate written the obvious way reports a vulnerable server as compliant. That has nothing to do with version 12 and has been true the whole time. The renumbering is just the event that finally makes people go and read their own checks.

Version-aware comparison gets all of it right:

```console
$ python3 -c "
from packaging.version import Version
print(Version('12.4') > Version('10.11.10'))"
True
$ printf '10.11.10\n12.4\n' | sort -V | tail -1
12.4

```

`sort -V` and a real version type are both fine. String `>=` in Python and `[ "$a" \> "$b" ]` in shell are not. A lot of homelab glue is the second kind. Mine was.

The other half of the migration: 12.0 is a major release, not a patch. And the 10.11 line is done. Its last security release was 10.11.10 on 24 May 2026, carrying three advisories; the last release of any kind was 10.11.11 on 6 June 2026\. I checked the tag list rather than the release notes, because tags do not editorialise:

```console
$ git ls-remote --tags origin | grep -oE '10\.11\.[0-9]+$' | sort -V | tail -2
10.11.10
10.11.11

```

Five months with no release on that branch, while 12.x has shipped five times since September. Nobody has announced an end of life that I could find, but a branch that has not moved in five months is not a branch receiving security backports, and you should not plan as though it is. Treat 12.x as where support lives, take a database backup and an inventory of your plugins before you migrate, and expect plugin compatibility to be the thing that bites. It always is.

---

> If you're enjoying what you've read so far, we recommend [The SSO Tax: Why Self-Hosted Projects Are Gating Login Behind a Paywall](https://sudosecurity.org/sso-tax-self-hosted-login-paywall/) as your next read.

---

## Going Looking, and Narrowing the Blast Radius

If you have been on an old version with accounts handed out, the permissions are where to start, because they're what turns these CVEs from theoretical into reachable.

For each user who is not you, in the Jellyfin admin dashboard:

- Turn off **Live TV management** unless that person actually manages tuners. As established above, this was default-`true` until April 2026 and the patch did not take it back, so on any server older than that it is still switched on for accounts you created. Almost nobody needs it.
- Turn off **Upload subtitles**. This is CVE-2026-35031's prerequisite for non-admins. It has always defaulted to off, so if a user has it, somebody granted it.
- Audit who has administrator. The honest answer on most home servers is "more people than remember having it."

Then, in Dashboard → Advanced, consider turning off **Allow client log upload**. It defaults on, it is the entry point for CVE-2026-49247, and unless you are actively collecting diagnostics from your users it does nothing for you.

Then check what can write into your library paths, because CVE-2026-48793 doesn't care about Jellyfin accounts at all — it cares who can create a file:

```bash
# Who can write into the library, and is anything group- or world-writable
find /srv/media -maxdepth 2 -type d \( -perm -g+w -o -perm -o+w \) -ls

# Filenames containing shell metacharacters, which should essentially never happen
find /srv/media -type f \( -name '*"*' -o -name "*'*" -o -name '*$*' -o -name '*`*' \) -print

```

That second command's worth running even if you're fully patched. A media library shouldn't contain a file with a double-quote in its name, and if one's there, you want to know how it arrived before you decide it was a weird rip.

What neither command will find is CVE-2026-49246, because that payload is a string inside the container rather than the name of the file holding it. If you want to look, `mkvmerge -J` dumps the container as JSON and `attachments` is the first key in it:

```console
$ mkvmerge -J movie.mkv | head -3
{
  "attachments": [],
  "chapters": [],

```

Each entry carries the declared `file_name`, and anything with a `/` or a `..` in it is not a font. But this is the point at which "just be on 10.11.10 or later" is a far better use of your evening than auditing a library one container at a time.

And the structural fix, which is more effective than any of the above: don't put the login page on the public internet. Most of these need an account, and an attacker can't use an account they can't reach. A [zero-trust access layer or VPN in front of it](https://sudosecurity.org/zero-trust-access-for-homelabbers/) turns "any authenticated user" from an internet-wide population into the six people you actually gave accounts to — which doesn't fix the bugs, but it means the only people who can exploit them are people you could phone.

## What This Doesn't Cover

I haven't reproduced any of these. I didn't stand up a vulnerable Jellyfin and attack it, and I wouldn't publish that if I did — there's a public PoC for one of these already and that's sufficient.

What I did do is clone the repository and read the fixes. The permission-default flip, the M3U scheme allowlist, the tuner authorization change, the FFmpeg quote escaping, the ClientLog sanitization and the `AllowClientLogUpload` default are all quoted above from the actual commits and the actual files, and the version-comparison output is from running the commands. Where I have given you a diff or a default, that is verified.

Where I have described an *exploitation chain* — the `ld.so.preload` hop in CVE-2026-35031, the database-exfiltration path in CVE-2026-35032 — that comes from published advisory and write-up descriptions, not from my own tracing. Those paragraphs are accurate summaries of what others reported. Treat the "how the fix works" material as first-hand and the "how the attack works" material as second-hand, because that is what they are.

The three advisories in 10.11.10 are now all accounted for — GHSA-wwwm-px48-fpvq, GHSA-jg92-mrxq-vv75 and GHSA-f47c-m7gr-q92j, the last of which is CVE-2026-49246 above. What I still cannot enumerate is four of the five security items in the 10.11.7 release, which aren't individually described anywhere I could verify. So the table is five CVEs I could pin down, not a complete accounting of everything fixed in 2026.

Also out of scope: the 12.x migration mechanics in any detail, plugin compatibility, hardware transcoding, the `*arr` stack that feeds most of these libraries, and whether Jellyfin or Plex is the better choice. That last one is a real argument and the answer depends on who else uses your server, which is, as it happens, the theme of this entire article.

## The Actual Point

The hardening advice for most self-hosted things is about keeping strangers out. For a media server that is only half the job, and it's the half everyone does.

The other half is that you've issued credentials to people, and every account you issued is a position inside the perimeter. Three of 2026's four Jellyfin CVEs start from "has an account." One starts from "can name a file." None of them start from "is an administrator." That isn't a Jellyfin indictment — it's what the attack surface of a multi-user service looks like, and Jellyfin's permission defaults are generous because the product is designed for a household where everyone is more or less trusted.

Your server probably isn't a household. It's a household plus whoever your household vouched for, which is a trust boundary with no clear edge and no revocation process beyond someone eventually remembering.

So: get to 12.4, turn off Live TV management and subtitle upload for everyone who is not you, and when you give the next person an account, give it to them with the same deliberateness you would use handing out an SSH key. Because functionally, on a server running anything older than May, that's a fair description of what you were doing.