Tina is a headless content management system

CVE-2026-28792 is a browser-driven attack chain in @tinacms/cli where Tina's local dev server exposes permissive CORS and can be paired with path traversal to let a malicious website read, write, and delete files on the developer machine while tinacms dev is running. Authoritative descriptions from NVD and the GitHub advisory say the issue affects versions *before* 2.1.8, with the default dev server running on http://localhost:4001; the advisory page's affected-version widget also shows <= 2.1.15, which conflicts with its own narrative and patched-version field, so treat 2.1.8 as the vendor-intended fix unless Tina corrects the record.

paragraphs

Why this verdict

• Downgraded for attacker position: the attacker is nominally remote, but the exploit still *implies successful delivery to a developer browser* and an active local dev session. That is materially narrower than a pre-auth internet-facing service flaw.
• Downgraded for exposed population: most enterprises do not run TinaCMS at scale across endpoints, and even in shops that do, only a fraction of developers will have tinacms dev listening on localhost:4001 at any given time.
• Held above LOW for blast radius on the wrong endpoint: compromise of a developer workstation can expose secrets, poison source, and create supply-chain follow-on risk. The impact per victim is real even if the reachable population is small.

Why not higher?

This is not a wormable edge-service bug and not a broadly reachable production-server issue. The chain needs multiple compounding prerequisites: a Tina developer, a vulnerable CLI version, an active dev session, and successful user interaction with malicious browser content.

Why not lower?

If you *do* have Tina developers, the affected endpoint class is high-value: source trees, package tokens, cloud creds, and CI paths often live there. Arbitrary file read/write/delete on a developer box is too potent to dismiss as hygiene-only backlog.

1. Inventory Tina developer endpoints — Find repos and workstations with @tinacms/cli installed so you are acting on the real population, not your whole fleet. For a MEDIUM verdict there is no mitigation SLA — go straight to the 365-day remediation window, but do this discovery now so the package does not disappear into dev-tool blind spots.
2. Move secrets off developer disks — Use short-lived cloud credentials, secret managers, and minimal local .env storage so that a localhost file-read becomes less valuable. There is no mitigation SLA for this severity, but it is the best structural control to reduce impact before the patch lands within the remediation window.
3. Use isolated dev environments — Run Tina in disposable dev containers, VMs, or tightly managed browser/dev profiles where practical, so a malicious webpage hits a sandbox instead of a privileged daily-driver workstation. Treat this as a compensating control while you remediate within 365 days.
4. Harden developer browsing — Apply ad/script filtering, remote browser isolation for risky browsing, and EDR coverage on developer endpoints to reduce the user-interaction leg of the chain. Again, no mitigation SLA applies here, but this lowers exploitability immediately without pretending perimeter controls solve a localhost issue.
5. Shut dev servers when idle — Train teams and wrapper scripts to stop tinacms dev when they are not actively editing. That directly removes the vulnerable listening window and is worth doing until the package is upgraded inside the 365-day remediation window.

Run this on the developer workstation or in a repo checkout that may use Tina. Invoke it with python3 check_tina_cve_2026_28792.py /path/to/project or omit the path to scan the current directory; no admin privileges are required. It checks local node_modules and common lock/package files for @tinacms/cli and reports VULNERABLE, PATCHED, or UNKNOWN.

#!/usr/bin/env python3
# check_tina_cve_2026_28792.py
# Detect vulnerable @tinacms/cli versions for CVE-2026-28792.
# Exit codes: 0=PATCHED, 1=VULNERABLE, 2=UNKNOWN, 3=SCRIPT_ERROR

import json
import os
import re
import sys
from pathlib import Path

FIXED = (2, 1, 8)
PKG = '@tinacms/cli'


def parse_semver(version):
    if not version:
        return None
    v = version.strip()
    v = v.lstrip('^~<>=v ')
    m = re.match(r'^(\d+)\.(\d+)\.(\d+)', v)
    if not m:
        return None
    return tuple(int(x) for x in m.groups())


def cmp_ver(a, b):
    return (a > b) - (a < b)


def load_json(path):
    try:
        with open(path, 'r', encoding='utf-8') as f:
            return json.load(f)
    except Exception:
        return None


def find_in_package_json(root):
    path = root / 'package.json'
    data = load_json(path)
    if not data:
        return None, None
    for section in ('dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies'):
        deps = data.get(section, {})
        if isinstance(deps, dict) and PKG in deps:
            return str(path), deps[PKG]
    return None, None


def find_in_package_lock(root):
    path = root / 'package-lock.json'
    data = load_json(path)
    if not data:
        return None, None

    packages = data.get('packages', {})
    if isinstance(packages, dict):
        node = packages.get('node_modules/@tinacms/cli')
        if isinstance(node, dict) and node.get('version'):
            return str(path), node.get('version')

    deps = data.get('dependencies', {})
    node = deps.get('@tinacms/cli') if isinstance(deps, dict) else None
    if isinstance(node, dict) and node.get('version'):
        return str(path), node.get('version')

    return None, None


def find_in_node_modules(root):
    path = root / 'node_modules' / '@tinacms' / 'cli' / 'package.json'
    data = load_json(path)
    if data and data.get('version'):
        return str(path), data.get('version')
    return None, None


def walk_roots(start):
    roots = [start]
    if (start / 'packages').is_dir():
        for p in (start / 'packages').iterdir():
            if p.is_dir():
                roots.append(p)
    return roots


def evaluate(found):
    parsed = []
    for source, version in found:
        sv = parse_semver(version)
        parsed.append((source, version, sv))

    installed = [x for x in parsed if x[2] is not None]
    if not installed:
        return 'UNKNOWN', 'No parseable @tinacms/cli version found.'

    vuln = [x for x in installed if cmp_ver(x[2], FIXED) < 0]
    if vuln:
        details = '; '.join([f'{src} -> {ver}' for src, ver, _ in vuln])
        return 'VULNERABLE', details

    patched = [x for x in installed if cmp_ver(x[2], FIXED) >= 0]
    details = '; '.join([f'{src} -> {ver}' for src, ver, _ in patched])
    return 'PATCHED', details


def main():
    try:
        start = Path(sys.argv[1]).resolve() if len(sys.argv) > 1 else Path.cwd()
        if not start.exists():
            print('UNKNOWN - path does not exist')
            sys.exit(2)

        found = []
        seen = set()
        for root in walk_roots(start):
            for finder in (find_in_node_modules, find_in_package_lock, find_in_package_json):
                src, ver = finder(root)
                if src and (src, ver) not in seen:
                    found.append((src, ver))
                    seen.add((src, ver))

        status, details = evaluate(found)
        print(f'{status} - CVE-2026-28792 check for {PKG}; fixed version is 2.1.8; {details}')
        if status == 'PATCHED':
            sys.exit(0)
        elif status == 'VULNERABLE':
            sys.exit(1)
        else:
            sys.exit(2)
    except Exception as e:
        print(f'UNKNOWN - script error: {e}')
        sys.exit(3)


if __name__ == '__main__':
    main()

Sources

1. NVD CVE-2026-28792
2. GitHub advisory GHSA-8pw3-9m7f-q734
3. TinaCMS CLI documentation
4. CISA Known Exploited Vulnerabilities Catalog
5. FIRST EPSS API documentation
6. FIRST EPSS overview
7. TinaCMS GitHub repository