• The new Python extension is now available. It allows customers to deploy and manage WSGI-based Python applications on their websites directly from Plesk.
  • The Plesk Mobile apps for iOS and Android and the Plesk Mobile Center extension have been deprecated, and are no longer available for new installations. In Plesk Obsidian 18.0.84, the Plesk Mobile Center extension will be removed from servers during the upgrade, and the Plesk Mobile apps will lose their server management features.
  • The Social Login extension has been deprecated and will be removed in Plesk Obsidian 18.0.84. After that, it will no longer be possible to log in to Plesk with a Google, Facebook, GitHub account, or with a passkey. Plesk usernames and passwords, as well as logging in with a WebPros Account, are not affected.

Issue NGINX HTTP/2 - CVE-2026-123633 and CVE-2026-123007

Fede Marsell

Basic Pleskian
Server operating system version
AlmaLinux release 8.10
Plesk version and microupdate number
18.0.81 Update #8
Hi,

Two critical vulnerabilities affecting NGINX HTTP/2 have recently been disclosed: CVE-2026-123633 and CVE-2026-123007, potentially allowing remote code execution.

Is the Plesk team aware of these vulnerabilities, and are there plans to release updated NGINX packages to address them?

In the meantime, would disabling HTTP/2 in NGINX be an effective mitigation until patched packages become available?

If so, is there a recommended way to disable HTTP/2 globally in Plesk without affecting existing websites or having the configuration overwritten?

Thanks,

Fede
 
I disabled http2 until a patch is released and sctp (not needed anyway on my server).
Then added a check for crashes to my server monitoring script. GitHub - cmelius/plesk-monitoring-server-Report: A single bash script for a Plesk server on Linux that writes an hourly health and security report (optionally) uploads it to cloud storage with rclone.

That's not a fix or anything but it tells you when crashes occur.

See changelog.

Disable in plesk.
plesk bin http2_pref --disable
systemctl restart nginx
 
Indeed, plesk bin http2_pref --disable disables HTTP/2 globally in Plesk.

A restart of NGINX afterwards is recommended to ensure the changes are fully applied and no old worker processes remain active.

You can verify this using curl -I --http2 https://yourdomain.com, which should return HTTP/1.1 instead of HTTP/2.
 
Indeed, plesk bin http2_pref --disable disables HTTP/2 globally in Plesk.

A restart of NGINX afterwards is recommended to ensure the changes are fully applied and no old worker processes remain active.

You can verify this using curl -I --http2 https://yourdomain.com, which should return HTTP/1.1 instead of HTTP/2.
But don't forget to disable sctp... It seems that needs to be done also.
 
Quick fix if you have more cfg files:

curl -sk -o /dev/null -w 'HTTP version: %{http_version}\n' --http2 Example Domain

grep -RInE 'http2' /etc/nginx/ --include='*.conf'

tar czf /root/nginx-config-backup-$(date +%Y%m%d-%H%M%S).tar.gz /etc/nginx

ls -lh /root/nginx-config-backup-*.tar.gz

find /etc/nginx -name '*.conf' \( -type f -o -type l \) -print0 |
while IFS= read -r -d '' file; do
target=$(realpath -e "$file") || continue
[ -f "$target" ] || continue

sed -i -E \
-e '/^[[:space:]]*http2[[:space:]]+on[[:space:]]*;/d' \
-e '/^[[:space:]]*listen[[:space:]]/s/[[:space:]]+http2([[:space:];])/ \1/g' \
"$target"
done


nginx -t

systemctl reload nginx

curl -sk -o /dev/null -w 'HTTP version: %{http_version}\n' --http2 Example Domain
HTTP version: 1.1

grep -RInE 'http2' /etc/nginx/ --include='*.conf'
0


# ON YOUR OWN RISK -)

cheers Michael
 
Just to add, what about HTTP/3 (QUIC)?

CVE-2026-121810 also appears to affect Nginx 1.30.6, and HTTP/3 is enabled on my Plesk server alongside HTTP/2.

Is Plesk planning to address this vulnerability in the same update? And should administrators temporarily disable HTTP/3 as well as HTTP/2 while waiting for the patched package?
 
Good afternoon:
Is it true that CVE-2026-123007 requires a 128 GB constant stream of data to execute malicious code?
If so, would it be possible to detect the start of an attack and block it using fail2ban?
 
don't forget /etc/sw-cp-server/conf.d/plesk.conf and systemctl restart sw-cp-server.service
 
@bernes_stainz idea is great, because it circumvents the enormous risk gap of a webserver reconfiguration process run by Plesk on servers with many domains. But the script does not catch many confs, and it has no backup if something fails. I suggest a different solution:

Code:
#!/usr/bin/env python3
"""Temporarily change HTTP/2 in Nginx's included Plesk configuration files."""

import argparse
import difflib
import os
import re
import subprocess
import sys
import tempfile
from pathlib import Path


CONFIG_FILE = re.compile(rb"(?m)^# configuration file (.+):$")
HTTP2_ON = re.compile(rb"(?m)^([ \t]*http2[ \t]+)on(?=[ \t]*;)")
HTTP2_OFF = re.compile(rb"(?m)^([ \t]*http2[ \t]+)off(?=[ \t]*;)")
LISTEN = re.compile(rb"(?m)^[ \t]*listen[ \t]+[^#;\r\n]+;")
LEGACY_HTTP2 = re.compile(rb"[ \t]+http2(?=[ \t;])")
LEGACY_MARKER = b" # plesk-nginx-http2: restore listen http2"
DISABLED_LISTEN = re.compile(
    rb"(?m)^([ \t]*listen[ \t]+[^#;\r\n]+);"
    + re.escape(LEGACY_MARKER)
    + rb"(?=[ \t\r\n#]|$)"
)


def included_files():
    dump = subprocess.check_output(["nginx", "-T"])
    paths = {Path(os.fsdecode(name)).resolve(strict=True)
             for name in CONFIG_FILE.findall(dump)}
    if not paths:
        raise ValueError("Could not identify included files in nginx -T output.")
    return paths


def disable_http2(config, mark_legacy=True):
    def disable_listen(match):
        directive = match[0]
        disabled = LEGACY_HTTP2.sub(b"", directive)
        return disabled + LEGACY_MARKER if mark_legacy and disabled != directive else disabled

    config = HTTP2_ON.sub(rb"\g<1>off", config)
    return LISTEN.sub(disable_listen, config)


def enable_http2(path, current, backup):
    if backup is None:
        enabled = HTTP2_OFF.sub(rb"\g<1>on", current)
        return DISABLED_LISTEN.sub(rb"\g<1> http2;", enabled)

    saved = backup / path.relative_to("/")
    if not saved.is_file():
        return current

    original = saved.read_bytes()
    if current == original:
        return current
    if current not in (disable_http2(original), disable_http2(original, mark_legacy=False)):
        raise ValueError(
            f"{path} differs from the disabled version of {saved}. "
            "Compare the two files and restore the HTTP/2 directives manually "
            "to preserve other changes."
        )
    return original


def show_changes(changes):
    for path, before, after in changes:
        name = os.fsencode(path)
        diff = difflib.diff_bytes(
            difflib.unified_diff,
            before.splitlines(keepends=True),
            after.splitlines(keepends=True),
            fromfile=name + b" (current)",
            tofile=name + b" (proposed)",
            n=0,
        )
        for line in diff:
            sys.stdout.buffer.write(line if line.endswith(b"\n") else line + b"\n")
    sys.stdout.buffer.flush()
    print(f"Staging: {len(changes)} file(s) would change.")


def apply_changes(changes):
    backup = Path(tempfile.mkdtemp(prefix="nginx-http2-", dir="/root"))
    for path, before, _ in changes:
        saved = backup / path.relative_to("/")
        saved.parent.mkdir(parents=True, exist_ok=True)
        saved.write_bytes(before)

    print(f"Backup of {len(changes)} file(s): {backup}", flush=True)
    attempted = []
    try:
        for path, before, after in changes:
            if path.resolve(strict=True) != path or path.read_bytes() != before:
                raise ValueError(f"{path} changed during the run.")
            # Modify the resolved file in place to preserve its metadata and aliases.
            attempted.append((path, before, after))
            path.write_bytes(after)
        subprocess.run(["nginx", "-t"], check=True)
    except (OSError, ValueError, subprocess.CalledProcessError, KeyboardInterrupt):
        for path, before, after in reversed(attempted):
            try:
                current = path.read_bytes()
                # A failed write may leave a prefix of the intended contents.
                if path.resolve(strict=True) != path or not after.startswith(current):
                    print(f"{path} changed during rollback. See {backup}.", file=sys.stderr)
                else:
                    path.write_bytes(before)
            except OSError as error:
                print(f"Could not restore {path}: {error}. See {backup}.", file=sys.stderr)
        raise


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    modes = parser.add_subparsers(dest="mode")
    disable = modes.add_parser("disable", help="Disable HTTP/2 in included files")
    enable = modes.add_parser("enable", help="Enable HTTP/2 in included files")
    enable.add_argument("--from-backup", type=Path, metavar="DIRECTORY",
                        help="Restore the original HTTP/2 settings from a disable run")
    for mode in (disable, enable):
        mode.add_argument("--dry-run", "--stage", action="store_true",
                          help="Show the diff without editing files or restarting Nginx")
    args = parser.parse_args()
    if args.mode is None:
        parser.error("Choose disable or enable.")

    backup = args.from_backup if args.mode == "enable" else None
    if backup is not None and not backup.is_dir():
        parser.error(f"Backup directory does not exist: {backup}")

    changes = []
    for path in sorted(included_files()):
        before = path.read_bytes()
        after = (disable_http2(before) if args.mode == "disable"
                 else enable_http2(path, before, backup))
        if before != after:
            changes.append((path, before, after))

    if args.dry_run:
        show_changes(changes)
    elif changes:
        apply_changes(changes)
        try:
            subprocess.run(["systemctl", "restart", "nginx"], check=True)
        except (OSError, subprocess.CalledProcessError):
            print("The validated configuration is on disk, but Nginx restart failed.",
                  file=sys.stderr)
            raise
    else:
        print("No files need changing.")


if __name__ == "__main__":
    try:
        main()
    except (OSError, ValueError, subprocess.CalledProcessError) as error:
        sys.exit(str(error))
    except KeyboardInterrupt:
        sys.exit(130)

Code:
Usage:
# Preview either change
python3 plesk-nginx-http2.py disable --stage
python3 plesk-nginx-http2.py enable --stage

# Apply either change
python3 plesk-nginx-http2.py disable
python3 plesk-nginx-http2.py enable

The script does not only cover the /var/www/system/<domain>/conf nginx.conf files, but also the webmail configurations and possible "additional Nginx directives" where a http2=on could reside. It also backups the files before it changes them to /root/nginx-http2-<random> and is able to
a) turn http/2 back on using the current .conf file or
b) turn http/2 back on by restoring the file from a previous backup. For the later use
python3 plesk-nginx-http2.py enable --from-backup /root/nginx-http2-XXXXXXXX [--stage]

I grant no warranty whatsoever. Use at your own risk. But I can tell you that it was successfully used in production on many dedicated servers on Alma 8, 9, 10 with a medium 5-digit-number of domain configuration files.

Downside: This does not change the Plesk database, so if a user applys changes to his hosting configuration, Plesk will overwrite the "quick change" done by the script.
 
Maybe a stupid question - but since the Nginx updates are already out, why does it take so long to release them to Plesk customers and why is there no article on support.plesk.com yet?
 
It's pretty disappointing that customers have to help each other deal with such a critical security vulnerability while there's barely any communication from Plesk and we're still waiting for a patch. Especially after yet another price increase, you'd expect much better support for such expensive licenses.
 
Back
Top