Back to Intelligence

CVE-2026-114713: Check Point & UnrealIRCd CISA KEV Alert — Immediate Detection and Remediation Guide

SA
Security Arsenal Team
November 15, 2026
12 min read

The U.S. Cybersecurity and Infrastructure Security Agency (CISA) has officially added two significant vulnerabilities to its Known Exploited Vulnerabilities (KEV) catalog, signaling confirmed active exploitation in the wild. Among these, CVE-2026-114713 stands out as a high-severity command injection flaw affecting Check Point security gateway products, carrying a CVSS score of 8.6. Simultaneously, a vulnerability in UnrealIRCd—a widely deployed Internet Relay Chat (IRC) server daemon—has been cataloged, indicating broad targeting across both enterprise network infrastructure and communication platforms.

For security teams, inclusion in the CISA KEV catalog is not merely an informational update; it is a mandatory call to action. Federal agencies are required to remediate these vulnerabilities within specified timeframes, and private organizations should treat these deadlines as best-practice minimums. The convergence of a network perimeter device (Check Point) and a backend communication server (UnrealIRCd) in a single KEV update suggests threat actors are diversifying their initial access vectors, targeting both the edge and internal collaboration infrastructure.

This analysis provides a technical breakdown of the vulnerabilities, actionable detection logic for your SOC, and immediate remediation steps to close these attack vectors before they can be leveraged for lateral movement or data exfiltration.

Technical Analysis

Affected Products and Vulnerability Details

CVE-2026-114713 – Check Point Command Injection (CVSS 8.6)

This vulnerability represents a classic yet devastating command injection flaw within the Check Point Security Gateway architecture. With a CVSS score of 8.6, this vulnerability allows unauthenticated remote attackers to execute arbitrary commands on the underlying operating system with the privileges of the Check Point management process—typically root or NT AUTHORITY\SYSTEM depending on the deployment platform.

The affected component appears to reside within the web management interface or specific API endpoints exposed by the Security Gateway. Command injection vulnerabilities in network security appliances are particularly dangerous because these devices sit at the network perimeter, often with broad visibility into internal traffic and established trust relationships with internal directory services.

Exploitation Mechanics: Attackers exploit insufficient input sanitization in HTTP request parameters processed by the Check Point management interface. By injecting shell metacharacters (such as ;, |, or $()) into vulnerable input fields, attackers can break out of the intended command context and execute arbitrary system commands. Given the 8.6 CVSS score, exploitation likely requires no authentication and minimal user interaction, making it ideal for automated mass scanning and exploitation.

UnrealIRCd Vulnerability

While the specific CVE identifier for the UnrealIRCd flaw was not fully detailed in the initial summary, its inclusion alongside CVE-2026-114713 in the KEV catalog indicates active exploitation. UnrealIRCd is one of the most widely deployed IRC server daemons globally, frequently used by organizations for internal communication, gaming communities, and legacy system coordination.

UnrealIRCd vulnerabilities typically manifest as buffer overflows, remote code execution (RCE), or privilege escalation flaws within the daemon's message parsing logic. Given that IRC servers often run on Linux infrastructure and may be internet-facing or accessible via VPN, successful exploitation provides attackers with a foothold inside the network, often on systems that are not as heavily monitored as domain controllers or database servers.

Exploitation Status

Both vulnerabilities have been added to the CISA KEV catalog, which is definitive confirmation of active, in-the-wild exploitation. Threat actors are not merely scanning for these vulnerabilities; they are successfully weaponizing them. The presence of a Check Point vulnerability (a perimeter security device) and UnrealIRCd (a backend communication server) suggests a potential campaign targeting organizations that rely on this specific technology stack, or opportunistic exploitation across multiple sectors.

Detection & Response

The following detection content is designed to identify both attempted and successful exploitation of these vulnerabilities across your environment. Given the severity and confirmed exploitation status, SOC teams should implement these detections immediately.

SIGMA Rules

YAML
---
title: Check Point Security Gateway Command Injection Attempt (CVE-2026-114713)
id: 8f3e2a91-4c5d-4e7f-9a1b-2c8d5e6f7a8b
status: experimental
description: Detects potential command injection attempts against Check Point Security Gateway web management interfaces via suspicious shell metacharacters in HTTP requests.
references:
  - https://securityaffairs.com/203040/hacking/u-s-cisa-adds-check-point-and-unrealircd-flaws-to-its-known-exploited-vulnerabilities-catalog.html
  - https://attack.mitre.org/techniques/T1059/004/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.initial_access
  - attack.t1190
  - attack.execution
  - attack.t1059.004
logsource:
  category: webserver
  product: checkpoint
detection:
  selection_uri:
    cs-uri|contains:
      - '/cgi-bin/'
      - '/api/'
      - '/webui/'
  selection_payload:
    cs-method: 'POST'
    sc-status:
      - 200
      - 302
      - 500
    cs-body|contains:
      - ';'
      - '|'
      - '$('
      - '`'
      - '&&'
      - '||'
  condition: selection_uri and selection_payload
falsepositives:
  - Legitimate administrative API calls containing pipe characters in data fields
  - Security scanning tools performing authorized vulnerability assessments
level: high
---
title: UnrealIRCd Daemon Suspicious Child Process Execution
id: 9a4f3b82-5d6e-4f8a-0b2c-3d9e6f7a8b9c
status: experimental
description: Detects suspicious process spawning from the UnrealIRCd daemon (ircd), which may indicate successful remote code execution following exploitation.
references:
  - https://securityaffairs.com/203040/hacking/u-s-cisa-adds-check-point-and-unrealircd-flaws-to-its-known-exploited-vulnerabilities-catalog.html
  - https://attack.mitre.org/techniques/T1059/004/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.execution
  - attack.t1059.004
  - attack.privilege_escalation
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|endswith: '/ircd'
  selection_child:
    Image|endswith:
      - '/bin/sh'
      - '/bin/bash'
      - '/usr/bin/python'
      - '/usr/bin/perl'
      - '/usr/bin/wget'
      - '/usr/bin/curl'
      - '/bin/nc'
      - '/usr/bin/netcat'
  condition: selection_parent and selection_child
falsepositives:
  - Legitimate administrative scripts executed by IRC operators (rare in production environments)
  - Automated maintenance scripts that interact with the IRC daemon
level: high

Microsoft Sentinel / Defender KQL

Deploy these queries in Microsoft Sentinel to hunt for exploitation attempts and successful compromise indicators across network and endpoint telemetry.

KQL — Microsoft Sentinel / Defender
// Hunt for Check Point command injection attempts via CEF/Syslog
CommonSecurityLog
| where DeviceVendor == "Check Point"
| where TimeGenerated > ago(24h)
| where RequestURL contains "/cgi-bin/" or RequestURL contains "/api/"
| where RequestMethod == "POST"
| where AdditionalExtensions has_any (";", "|", "$(", "`", "&&")
| project TimeGenerated, SourceIP, DestinationIP, RequestURL, RequestMethod, AdditionalExtensions, DeviceAction
| sort by TimeGenerated desc

// Hunt for UnrealIRCd exploitation - Process execution from ircd parent
DeviceProcessEvents
| where TimeGenerated > ago(24h)
| where InitiatingProcessFileName =~ "ircd"
| where FileName in ("sh", "bash", "python", "perl", "wget", "curl", "nc", "netcat", "chmod", "chown")
| project TimeGenerated, DeviceName, InitiatingProcessFileName, FileName, ProcessCommandLine, InitiatingProcessAccountName, SHA256
| sort by TimeGenerated desc

// Correlate network connections to UnrealIRCd servers with suspicious outbound activity
DeviceNetworkEvents
| where TimeGenerated > ago(24h)
| where LocalPort == 6667 or LocalPort == 6697 or RemotePort == 6667 or RemotePort == 6697
| where RemoteIP !startswith "10." and RemoteIP !startswith "192.168." and RemoteIP !startswith "172.16."
| join kind=inner (
    DeviceProcessEvents
    | where TimeGenerated > ago(24h)
    | where InitiatingProcessFileName =~ "ircd"
) on DeviceId
| project TimeGenerated, DeviceName, RemoteIP, RemotePort, LocalPort, FileName, ProcessCommandLine, InitiatingProcessAccountName

Velociraptor VQL

For DFIR teams and threat hunters using Velociraptor, these artifacts will help identify compromised UnrealIRCd instances and Check Point gateway artifacts.

VQL — Velociraptor
-- Hunt for suspicious processes spawned by UnrealIRCd daemon
SELECT Pid, Name, CommandLine, Exe, Username, CreateTime, 
       ProcessId as ParentPid, 
       (SELECT Name FROM pslist(pid=ProcessId)) as ParentName
FROM pslist()
WHERE ParentName =~ 'ircd'
   AND (Name =~ 'sh|bash|python|perl|wget|curl|nc|netcat|chmod'
        OR CommandLine =~ 'base64|eval|exec|/tmp/|/dev/shm/')

-- Hunt for Check Point gateway web shell artifacts or suspicious file writes
SELECT FullPath, Size, Mtime, Ctime, 
       (SELECT String FROM yara(files=FullPath, rules='rule webshell { strings: $s1 = "cmd.exe" $s2 = "system(" condition: any of them }')) as YaraHits
FROM glob(globs='/opt/CPsuite-*/**/cgi-bin/*.pl,/opt/CPsuite-*/**/cgi-bin/*.cgi,/opt/CPshrd-*/**/web/*.jsp')
WHERE Mtime > ago('7d')
   AND (FullPath =~ '.*\.jsp$|.*\.pl$|.*\.cgi$' AND Size < 50000)

-- Network connections from UnrealIRCd processes
SELECT Pid, Name, LocalAddress, LocalPort, RemoteAddress, RemotePort, Status,
       (SELECT CommandLine FROM pslist(pid=Pid)) as CommandLine
FROM netstat()
WHERE Name =~ 'ircd'
   AND Status == 'ESTABLISHED'
   AND RemoteAddress !~ '^10\\.|^192\\.168\\.|^172\\.(1[6-9]|2[0-9]|3[01])\\.'

Remediation Script

Use this Bash script to identify vulnerable Check Point gateways and UnrealIRCd servers, check for signs of compromise, and apply initial mitigations. Run this on your security management server or a bastion host with network access to the target systems.

Bash / Shell
#!/bin/bash
# CVE-2026-114713 and UnrealIRCd KEV Response Script
# Run with appropriate privileges on management infrastructure

echo "=== CISA KEV Response: Check Point CVE-2026-114713 & UnrealIRCd ==="
echo "Date: $(date)"
echo ""

# Configuration - Update these variables
CHECKPOINT_MGMT_SERVERS=("192.168.1.10" "192.168.1.11")  # Add your Check Point management IPs
UNREALIRCD_SERVERS=("192.168.1.50" "192.168.1.51")       # Add your UnrealIRCd server IPs
LOG_FILE="/var/log/kev_response_$(date +%Y%m%d_%H%M%S).log"

# Function to check Check Point version and patch status
check_checkpoint() {
    echo "[+] Checking Check Point Gateways..." | tee -a $LOG_FILE
    
    for cp_server in "${CHECKPOINT_MGMT_SERVERS[@]}"; do
        echo "  Checking $cp_server..." | tee -a $LOG_FILE
        
        # Attempt to identify version via SNMP or API (requires existing credentials)
        # Check for suspicious processes indicating compromise
        ssh -o ConnectTimeout=5 -o BatchMode=yes admin@$cp_server "show version all" 2>/dev/null | tee -a $LOG_FILE || echo "    [!] Unable to connect to $cp_server" | tee -a $LOG_FILE
        
        # Check for web server anomalies (indicative of web shell deployment)
        ssh -o ConnectTimeout=5 admin@$cp_server "find /opt/CPshrd-R81*/web/ -name '*.jsp' -mtime -7 -ls" 2>/dev/null | tee -a $LOG_FILE
    done
    
    echo "[!] ACTION REQUIRED: Verify Check Point Security Gateway is updated to the latest Jumbo Hotfix" | tee -a $LOG_FILE
    echo "    Download from: https://supportcenter.checkpoint.com/" | tee -a $LOG_FILE
    echo ""
}

# Function to check UnrealIRCd version and process integrity
check_unrealircd() {
    echo "[+] Checking UnrealIRCd Servers..." | tee -a $LOG_FILE
    
    for irc_server in "${UNREALIRCD_SERVERS[@]}"; do
        echo "  Checking $irc_server..." | tee -a $LOG_FILE
        
        # Check UnrealIRCd version
        ssh -o ConnectTimeout=5 root@$irc_server "/home/ircd/unrealircd/unrealircd version 2>/dev/null || /usr/local/unrealircd/bin/unrealircd version 2>/dev/null" | tee -a $LOG_FILE
        
        # Check for suspicious child processes
        echo "    Checking for suspicious child processes..." | tee -a $LOG_FILE
        ssh -o ConnectTimeout=5 root@$irc_server "ps auxf | grep -A 5 'ircd' | grep -E '(sh|bash|python|perl|wget|curl|nc |netcat)' | grep -v grep" 2>/dev/null | tee -a $LOG_FILE
        
        # Check for recently modified configuration files (persistence mechanism)
        echo "    Checking for recently modified configs..." | tee -a $LOG_FILE
        ssh -o ConnectTimeout=5 root@$irc_server "find /home/ircd/ -name '*.conf' -mtime -3 -ls 2>/dev/null" | tee -a $LOG_FILE
        
        # Check listening ports - ircd should only be on 6667/6697 typically
        echo "    Checking listening ports..." | tee -a $LOG_FILE
        ssh -o ConnectTimeout=5 root@$irc_server "netstat -tlnp | grep ircd" 2>/dev/null | tee -a $LOG_FILE
        
    done
    echo ""
}

# Function to apply temporary mitigations
apply_mitigations() {
    echo "[+] Applying Temporary Mitigations..." | tee -a $LOG_FILE
    
    # Block suspicious IPs at the perimeter (example - update with your threat intel)
    MALICIOUS_IPS=("203.0.113.0/24" "198.51.100.0/24")  # Replace with actual IOCs
    
    for ip in "${MALICIOUS_IPS[@]}"; do
        echo "  Blocking $ip at perimeter firewall..." | tee -a $LOG_FILE
        # iptables -I INPUT -s $ip -j DROP
        # firewall-cmd --permanent --add-rich-rule="rule family='ipv4' source address='$ip' reject"
    done
    
    # Disable UnrealIRCd if not business critical (uncomment to enable)
    # echo "  Stopping UnrealIRCd services temporarily..." | tee -a $LOG_FILE
    # for server in "${UNREALIRCD_SERVERS[@]}"; do
    #     ssh root@$server "systemctl stop unrealircd && systemctl disable unrealircd" 2>/dev/null
    # done
    
    echo "[!] Manual step: Apply Check Point hotfix immediately via SmartUpdate or CPUSE" | tee -a $LOG_FILE
    echo "[!] Manual step: Update UnrealIRCd to the latest version from https://www.unrealircd.org/download" | tee -a $LOG_FILE
}

# Main execution
check_checkpoint
check_unrealircd
apply_mitigations

echo "=== Scan Complete. Review log: $LOG_FILE ==="
echo ""
echo "CRITICAL ACTIONS:"
echo "1. Apply Check Point hotfix for CVE-2026-114713 immediately"
echo "2. Update UnrealIRCd to version 6.1.8 or later (check vendor advisory)"
echo "3. Review logs for IOCs mentioned in detection section"
echo "4. Consider isolating affected systems if compromise is suspected"

Remediation

Immediate action is required for all organizations running Check Point Security Gateways or UnrealIRCd servers. CISA's KEV catalog addition indicates these are not theoretical risks.

Immediate Actions (Within 24-48 Hours)

For Check Point CVE-2026-114713:

  1. Isolate Management Interfaces: Ensure Check Point management interfaces (typically TCP ports 443, 18264, 19009) are not exposed to the internet. If remote management is required, implement strict IP whitelisting or VPN-only access.
  2. Apply Vendor Patch: Check Point has released hotfixes addressing this command injection vulnerability. Apply the latest Jumbo Hotfix Take for your specific version (R80.40, R81, R81.10, or R81.20) immediately. Verify installation via SmartUpdate or CPUSE.
  3. Audit Logs: Review /opt/CPshrd-R81*/log/ and web server logs for suspicious POST requests containing shell metacharacters (;, |, $(), backticks).

For UnrealIRCd:

  1. Update Immediately: Upgrade to UnrealIRCd version 6.1.8 or later (or the latest stable release addressing this vulnerability). Download only from the official site: https://www.unrealircd.org/download
  2. Verify Integrity: Check the integrity of existing ircd binaries using package manager verification (rpm -V or dpkg -V) or compare SHA256 hashes against known good versions.
  3. Network Segmentation: Ensure IRC servers are not exposed to the internet unless absolutely necessary. If internal-only, verify firewall rules restrict access to internal IP ranges only.

Verification Steps

After patching, verify remediation:

  • Check Point: Run cpstat fw -f and verify the hotfix take number matches the patched version. Attempt to access the management interface with malicious payloads (in a controlled manner) to confirm input sanitization is active.
  • UnrealIRCd: Run /home/ircd/unrealircd/unrealircd version and confirm the build date is after the vulnerability disclosure date. Monitor process trees for 24-48 hours to ensure no unauthorized child processes spawn from the ircd parent.

CISA Deadlines

Federal Civilian Executive Branch (FCEB) agencies must remediate these vulnerabilities according to the Binding Operational Directive (BOD) 22-01 schedule. While private organizations are not legally bound by CISA deadlines, treating the standard 2-3 week remediation window as a maximum is strongly recommended given the active exploitation status.

Long-term Hardening

  1. Network Segmentation: Ensure IRC servers and security management interfaces reside in isolated VLANs with strict ACLs preventing direct internet access.
  2. Process Monitoring: Implement EDR solutions that alert on non-standard process trees (e.g., ircd spawning shells, or httpd processes on Check Point appliances spawning command shells).
  3. Vulnerability Management: Integrate CISA KEV monitoring into your vulnerability management workflow. Any addition to the KEV catalog should trigger an immediate patch cycle, bypassing standard testing delays for internet-facing systems.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.