I rebuilt Apache backwards on a DirectAdmin box this week, on purpose. A fresh install already came up on the fixed release, so to show the real patch I pinned CustomBuild to the vulnerable 2.4.70, confirmed every vhost still spoke HTTP/2, and then walked it forward again. Along the way I tried to switch HTTP/2 off without patching, and both of the obvious config tricks let it through somewhere.
These are my notes for anyone running DirectAdmin with Apache from CustomBuild who needs to close CVE-2026-119618 in mod_http2. You’ll get the exposure check, the build that fixes it, a rollback copy that I actually restored, the auto-update setting and what changes behind nginx or LiteSpeed. I ran all of it in November 2026 on a Rocky Linux 9.8 GCP VM with DirectAdmin 1.714 and CustomBuild 2.0, and every output below comes from that box.
Checking whether your DirectAdmin box is exposed
The Apache on a DirectAdmin server is not the httpd package from the distro. CustomBuild compiles it from the Apache tarball into /usr/sbin/httpd, so dnf update will not touch it, and the advice in the RHEL, Rocky and AlmaLinux patch notes does not apply to it. The first thing to read is the version, followed by whether mod_http2 is in the binary:
httpd -v
httpd -M 2>/dev/null | grep -i http2
grep -rn "^Protocols" /etc/httpd/conf/
On my box the module came back as http2_module (static). That word matters. A static module is compiled into httpd itself, so there’s no LoadModule line you can comment out, and the usual “unload mod_http2” mitigation simply doesn’t exist here. The grep found the switch that turns it on in httpd-phpmodules.conf, a file CustomBuild writes for you:
/etc/httpd/conf/extra/httpd-phpmodules.conf:1:ProtocolsHonorOrder On
/etc/httpd/conf/extra/httpd-phpmodules.conf:2:Protocols h2 h2c http/1.1
There’s no panel option behind that line anymore. DirectAdmin’s 1.658 changelog removed the http2 setting from directadmin.conf and made HTTP/2 always on, so every DirectAdmin Apache server since early 2024 offers h2, and on my 1.714 box the generated line also offers cleartext h2c on port 80. My box showed all three signs of exposure:
httpd -v: Apache/2.4.70, inside the affected 2.4.55 to 2.4.70 rangehttpd -M: http2_module compiled in as static- Protocols line: h2 and h2c offered before http/1.1
If yours matches the first line, treat the box as exposed whatever the other two say. The module is always there on a CustomBuild Apache, and I could not find a supported way to take h2 out of that generated file.
Probing what the vhosts actually negotiate
Config files tell you what Apache was asked to do. I wanted proof of what it does on the wire, for every hosted domain on the IP DirectAdmin bound it to. This loop reads each domain and its IP from DirectAdmin’s user data and asks curl for HTTP/2 twice, once over TLS and once as h2c with prior knowledge:
for f in /usr/local/directadmin/data/users/*/domains/*.conf; do d=$(basename "$f" .conf); ip=$(grep -m1 '^ip=' "$f" | cut -d= -f2); printf '%-18s %-15s tls=%s h2c=%s\n' "$d" "$ip" "$(curl -sk --http2 --resolve "$d:443:$ip" -o /dev/null -w '%{http_version}' "https://$d/")" "$(curl -s --http2-prior-knowledge --resolve "$d:80:$ip" -o /dev/null -w '%{http_version}' "http://$d/")"; done
Run it as root on the server itself. On a cloud VM the public IP usually isn’t on the interface (GCP NATs it), so I had to bind it to loopback with ip addr add 203.0.113.10/32 dev lo before curl could reach DirectAdmin’s IP-bound vhosts locally. Remove it afterwards with ip addr del 203.0.113.10/32 dev lo. The baseline on 2.4.70 had the test domain shop.example.com answering HTTP/2 both ways:

A 2 in either column means that listener reaches the vulnerable code. I also ran the same probe against the bare IPs in /usr/local/directadmin/data/admin/ip.list, because DirectAdmin’s default and shared IP vhosts answer requests that don’t match a hosted domain:
for ip in $(cat /usr/local/directadmin/data/admin/ip.list); do printf '%-15s tls=%s h2c=%s\n' "$ip" "$(curl -sk -m 5 --http2 -o /dev/null -w '%{http_version}' "https://$ip/")" "$(curl -s -m 5 --http2-prior-knowledge -o /dev/null -w '%{http_version}' "http://$ip/")"; done
Keep both loops in a file. You’ll run them again after the build, and I leaned on the IP version hardest when the config workarounds below looked like they had worked.
Trying to switch HTTP/2 off without patching
My first instinct was the server-wide line that works on packaged Apache. I appended Protocols http/1.1 to /etc/httpd/conf/extra/httpd-includes.conf, the one include CustomBuild promises not to overwrite. httpd -t said Syntax OK, I restarted, and the probe still printed tls=2 h2c=2. A second server-level Protocols line doesn’t replace the one in httpd-phpmodules.conf, which matches what the HTTP/2 mitigation write-up found on Ubuntu. Running da build rewrite_confs kept my line and changed nothing either.
The second attempt went per vhost. DirectAdmin’s custom template tokens let you inject lines into every user’s virtual hosts, so I wrote the Protocols line into the token file that applies to all virtual_host2* templates and regenerated the configs:
mkdir -p /usr/local/directadmin/data/templates/custom
echo "Protocols http/1.1" > /usr/local/directadmin/data/templates/custom/cust_httpd.CUSTOM.post
da build rewrite_confs
That half worked, which is worse than not working at all, because it looks fine if you only test the site over HTTPS:

The domain’s TLS column dropped to 1.1, yet h2c on port 80 still answered 2, and both server IPs still negotiated HTTP/2 on both ports. Those IP vhosts live in ips.conf and httpd-vhosts.conf, which the user templates never reach. Did anything I tried close every listener? No, and the three attempts ended like this:
- Server-wide line in
httpd-includes.conf: no change anywhere - Token in
cust_httpd.CUSTOM.post: domain TLS on 1.1, h2c and IP vhosts still on 2 - Unloading the module: impossible, it’s static
So on DirectAdmin Apache I don’t trust any interim. Since CustomBuild already ships the fixed release, the build below is the fix, and I removed the token file and ran rewrite_confs again before going on.
Checking what CustomBuild already ships
CustomBuild decides versions from its own versions.txt, and on my box it already listed apache2.4:2.4.71: when I installed on 12 November. Updating DirectAdmin itself first is cheap, then da build versions compares what’s installed with what CustomBuild would build:
da update
da build versions
I’ve trimmed the output to the Apache lines. DirectAdmin was already current at 1.714, and CustomBuild offered the fix:

If your box shows 2.4.71 as “Latest” too, skip straight to the rollback copy. If it still says 2.4.70 is latest, the box hasn’t pulled the new list yet. Since DirectAdmin 1.643, CustomBuild and its configuration files ship with DirectAdmin updates, so da update is what brings the list in. Do not reach for da build update_versions here: the CustomBuild upgrade docs list it as updating all software components, the same as Update All in the panel. Also check /usr/local/directadmin/custombuild/custom_versions.txt, since an apache2.4 line there overrides versions.txt and will quietly rebuild the old release. That’s exactly how I pinned 2.4.70 for this test.
Keeping a rollback copy before the build
CustomBuild keeps the old source tarball in its cache, but rebuilding from it takes as long as the forward build. A copy of the running binary, its modules and its config comes back in seconds, and on my box it was 5.9 MB:
tar czf /root/apache-2.4.70-before-cve-2026-119618.tgz /usr/sbin/httpd /usr/lib/apache /etc/httpd/conf 2>/dev/null
ls -lh /root/apache-2.4.70-before-cve-2026-119618.tgz
Those three paths are where CustomBuild puts Apache on an EL box: the binary, the shared modules in /usr/lib/apache and the configs under /etc/httpd/conf. Your PHP-FPM pools and user data aren’t in it and don’t need to be, because the Apache build doesn’t touch them. The config directory also holds the server certificate and ips.conf, so a restore rolls back any certificate renewal or IP change made after the copy. Take the copy right before the build.
Rebuilding Apache with CustomBuild
The build is one command. I wrapped it in time and sent the log to a file, because the interesting part is short and I didn’t want to scroll a compiler run to find it:
cd /usr/local/directadmin/custombuild
(time da build apache) > /root/build-2471.log 2>&1
grep -E "Restarting apache|^real" /root/build-2471.log
httpd -v
It took 2m0.4s of wall time on a 4 vCPU e2-standard-4 VM. The log shows two Apache restarts after the compile, while CustomBuild rewrites the IP and httpd configs. I didn’t time the outage itself, but the old process keeps serving until that first restart. On a busy server I’d still run it outside peak hours, since a restart drops any long downloads in flight.

Check the “Server built” timestamp as well as the version. It should be a minute or two old, which proves the running binary is the one you just compiled and not a stale one left in place by a failed build.
Doing the same update from the panel
If you’d rather click, DirectAdmin Evolution has the same action on the admin-level CustomBuild page, Update Software. Logged in as admin, the quickest way there is typing “CustomBuild” into the Search for pages box (Ctrl+J). Before my build the page showed the Apache row I’ve marked as Apache 2.4.70 to 2.4.71, with its own Update button at the end of the row:

- 1Apache 2.4.70 to 2.4.71
- 2Update
I used the shell for the timed run, so I can’t tell you how the panel reports a build that fails. The same page after my CLI build is the quickest check that nothing’s left pending, and it went empty once Apache was on the new release:

“No items to show” covers every CustomBuild package, not only Apache, so it is also a good place to spot a PHP or Exim update that has been waiting. I would not click Update All here during an incident, though, because it rebuilds everything listed and turns a two minute Apache job into a much longer one.
Reprobing after the build
This is the part that confused me for a minute. I reran both probe loops and every listener still negotiated HTTP/2:

That’s correct. The fix lives in mod_http2’s code, not in a config switch, so a patched server keeps serving HTTP/2 exactly as before. The probe proves HTTP/2 still works for your users after the build, nothing more. I count the box as patched when these three agree:
httpd -vprints 2.4.71- “Server built” is minutes old, not days
da build versionsshows installed and latest matching
Do not expect the probe to change after patching, and do not “fix” it by disabling HTTP/2 afterwards. You would lose the protocol for every visitor while gaining nothing, because the vulnerable code is no longer there.
Rolling back if the new build breaks a site
I didn’t want to keep a rollback copy I’d never restored, so I restored it. Extracting the tarball over the new build and restarting put 2.4.70 back immediately:
tar xzf /root/apache-2.4.70-before-cve-2026-119618.tgz -C / && systemctl restart httpd && httpd -v
CustomBuild noticed straight away and offered the update again, and a second da build apache took 2m3.9s to get me back to 2.4.71:

A rollback puts the vulnerable release back, so only use it to keep sites up while you work out what broke, and only for hours. The slower route is a pin, the same one I used to stage this test, which costs a full rebuild:
cd /usr/local/directadmin/custombuild
echo "apache2.4:2.4.70:" >> custom_versions.txt
da build apache
If you pin, delete that line again the moment you’re done. Left in place it blocks this fix and every Apache release after it, including the automatic updates in the next section.
Letting CustomBuild patch the next one itself
Would a box like mine have patched itself overnight? No, because a fresh install only checks. The three options that matter came up like this in options.conf:
cron=yes: the scheduled job runscron_frequency=daily: once a dayupdates=no: it checks but builds nothing
Flipping updates makes CustomBuild build whatever versions.txt offers on that daily run, Apache included:
da build set updates yes
da build cron
da build cron prints the schedule it now follows, and a grep of options.conf confirms the switch:

The panel shows the same settings under CustomBuild, Edit Options. I’ve marked cron: Yes, which is the default, and updates: Yes, along with the text DirectAdmin prints under that option:

- 1cron: Yes
- 2updates: Yes
“WARNING: not recommended in production!” is DirectAdmin’s own advice, and I’d mostly agree. The setting rebuilds every CustomBuild package, PHP and Exim included, so one bad upstream release can restart your whole stack overnight. If you host customer sites, I’d rather turn on notifications with a real email and build by hand within a day. The default address on my box was the placeholder [email protected], so set both: da build set notifications yes and da build set email [email protected]. The case for updates=yes is a box nobody watches, where an unattended build is safer than an unpatched mod_http2 for a week.
Reading the nginx_apache and LiteSpeed setups
I didn’t switch this box to another webserver value. A rebuild into a new stack would have cost the lab more time than the answer was worth, so I read the templates CustomBuild ships instead. Who terminates HTTP/2 decides how much this CVE matters:
| webserver value | Who speaks HTTP/2 to visitors | What I’d do |
|---|---|---|
apache | Apache mod_http2 (static), h2 and h2c | Build 2.4.71 now |
nginx_apache | nginx, from http2 on; in nginx_server_secure.conf | Build 2.4.71 anyway |
litespeed or openlitespeed | The LiteSpeed server’s own HTTP/2 stack | Not this CVE; patch LiteSpeed on its own schedule |
What I read in each template comes down to three lines:
nginx_server_secure.conf:http2 on;on the 443 listenernginx-vhosts.conf(nginx_reverse):http2 on;on the hostname listener,proxy_passto|PORT_8080|- OpenLiteSpeed templates: no h2 directive at all
With nginx_apache, nginx holds ports 80 and 443 and proxies to Apache on a back port; the line I read was proxy_pass http://|IP|:|PORT_8080|. Visitors coming through nginx talk h2 to nginx, not to Apache, which cuts the exposure a lot as long as your firewall keeps Apache’s back port (8080 in the template I read; I did not check the HTTPS one) closed from outside. I would still build, since it’s the same CustomBuild httpd with mod_http2 compiled in, and I haven’t checked whether its Protocols line answers h2c on the back port. On OpenLiteSpeed I found no h2 directive in CustomBuild’s templates at all, because HTTP/2 there is LiteSpeed’s own code, not mod_http2.
What I still don’t know
I went looking for CustomBuild’s cron file and found none. After da build cron nothing new appeared under /etc/cron.d or /etc/cron.daily, and no root cron entry mentioned custombuild. That turned out to be by design: the DirectAdmin 1.645 changelog moved the CustomBuild cronjob off the cron service and into the main DirectAdmin binary. What I don’t know is when in the day that run fires, so if you rely on updates=yes, check /usr/local/directadmin/custombuild/custombuild.log the morning after.
I also haven’t seen a DirectAdmin staff statement on this CVE. The only thread on their forum I found was a user quoting the Apache advisory, so I can’t say when versions.txt changed, only that a fresh install on 12 November already built the fixed release. The Apache 2.4 vulnerability list is the source for the affected range. If you run several DirectAdmin boxes, the habits from my PHP2Shell rebuild on DirectAdmin carry straight over: copy, build, check the build time, then reprobe. If you’re building a fresh lab first, the DirectAdmin install on Rocky Linux walkthrough gets you a box like mine, and you’ll find the same steps for distro-packaged Apache in the Debian and Ubuntu patch notes.