Back to Intelligence

CVE-2026-90817: REDCap Code Injection Actively Exploited — CISA KEV Detection and Remediation Guide

SA
Security Arsenal Team
November 18, 2026
12 min read

On November 18, 2026, CISA added CVE-2026-90817 to the Known Exploited Vulnerabilities (KEV) catalog, confirming that a code injection vulnerability in Vanderbilt University's Research Electronic Data Capture (REDCap) platform is being actively exploited in the wild. This is not a theoretical risk — exploitation is confirmed and ongoing, and federal civilian executive branch agencies are now bound by Binding Operational Directive (BOD) 22-01 timelines to remediate.

REDCap is not a niche product. It is deployed at thousands of academic medical centers, hospitals, clinical research organizations, and universities worldwide, and it sits on top of some of the most sensitive data classes in existence: protected health information (PHI), clinical trial data, genomic datasets, and personally identifiable information of research subjects. A successful compromise of a REDCap instance is simultaneously a web server takeover, a potential HIPAA reportable breach, and a foothold into research and clinical networks.

The vulnerability allows an unauthenticated attacker to execute arbitrary code on the server. The only prerequisite is knowledge of a valid public survey hash — a low bar, since public survey links are distributed by design via email, flyers, QR codes, and patient portals. If your organization hosts REDCap, treat this as an active incident response trigger, not a routine patch ticket.

Technical Analysis

Affected Product

  • Product: Vanderbilt University Research Electronic Data Capture (REDCap)
  • Vulnerability type: Code injection (CWE-94)
  • CVE: CVE-2026-90817
  • Attack vector: Network, unauthenticated remote
  • Exploitation status: Confirmed active exploitation in the wild; listed in the CISA KEV catalog as of 2026-11-18
  • Typical deployment stack: PHP application running on Apache or IIS with a MySQL/MariaDB backend, on Linux or Windows Server

How the Attack Works (Defender's View)

Based on the CISA KEV entry and vendor guidance, the attack chain is as follows:

  1. Access via a public survey context. The attacker reaches REDCap through the public survey endpoint, which is intentionally exposed to unauthenticated participants. A valid survey hash — the alphanumeric token embedded in every public survey URL — is required to reach the vulnerable code path. Survey hashes are widely distributed and frequently leaked, scraped, or enumerated from phishing lures, so this prerequisite provides virtually no protection.

  2. Unintended controller route traversal. From the public survey context, the attacker crafts HTTP requests that reach a controller route that was never intended to be accessible from the unauthenticated survey flow. This is a routing/authorization design flaw: the framework resolves the request to a controller tied to data import processing without enforcing the expected authentication boundary.

  3. Code injection via data import processing. The vulnerable controller accepts a file-path or stream parameter during import processing. By supplying a crafted value — for example a PHP stream wrapper or a path pointing to attacker-influenced content — the attacker causes the server to evaluate or include attacker-controlled input as code, achieving arbitrary code execution in the context of the web server service account (typically www-data, apache, or the IIS application pool identity).

  4. Post-exploitation. Confirmed in-the-wild exploitation means defenders should assume webshell deployment, credential harvesting from database.php configuration files, database exfiltration of survey/PHI records, and lateral movement attempts from the web tier.

Why This Is Severe

  • No authentication required beyond a public survey hash.
  • Direct RCE on the application server.
  • High-value data at rest — PHI and clinical research data subject to HIPAA, 21 CFR Part 11, and institutional IRB obligations.
  • KEV listing means CISA has reliable evidence of active exploitation, and BOD 22-01 remediation deadlines apply to federal agencies. Every other organization should treat the KEV due date as their own deadline.

Detection & Response

The detections below target the observable behaviors described in the KEV entry: crafted requests to survey endpoints carrying stream-wrapper or path parameters, and the web server process executing code or dropping payloads.

Sigma Rules

YAML
---
title: REDCap CVE-2026-90817 Web Server Process Spawning Shell or Script Interpreter
id: 3f7a2c91-8d4e-4b6a-9c1d-2e5f8a0b3d7e
status: experimental
description: Detects the web server or PHP process spawning command shells or script interpreters, consistent with post-exploitation after code injection in a PHP web application such as REDCap (CVE-2026-90817).
references:
  - https://www.cisa.gov/known-exploited-vulnerabilities-catalog?search_api_fulltext=CVE-2026-90817
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/11/19
tags:
  - attack.execution
  - attack.t1059
  - attack.t1190
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\httpd.exe'
      - '\apache.exe'
      - '\php-cgi.exe'
      - '\php.exe'
      - '\w3wp.exe'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\rundll32.exe'
      - '\certutil.exe'
      - '\bitsadmin.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Rare administrative plugins or REDCap cron jobs invoking scripts; validate against change windows
level: high
---
title: REDCap Public Survey Requests Containing PHP Stream Wrappers in Import Parameters
id: 8b2e4d16-5f7a-4c3b-a1e9-6d0c2f4b8e3a
status: experimental
description: Detects HTTP requests to REDCap public survey endpoints containing PHP stream wrapper schemes (php://, phar://, file://, data://) or directory traversal sequences in parameters, consistent with CVE-2026-90817 exploitation via crafted file-path or stream parameters during data import processing.
references:
  - https://www.cisa.gov/known-exploited-vulnerabilities-catalog?search_api_fulltext=CVE-2026-90817
  - https://attack.mitre.org/techniques/T1190/
author: Security Arsenal
date: 2026/11/19
tags:
  - attack.initial_access
  - attack.t1190
logsource:
  category: webserver
detection:
  selection_uri:
    cs-uri|contains:
      - '/surveys/'
      - 'index.php'
  selection_payload:
    cs-uri|contains:
      - 'php://'
      - 'phar://'
      - 'file://'
      - 'data://'
      - 'expect://'
      - 'zip://'
      - '../'
      - '..%2f'
      - '%2e%2e'
  condition: selection_uri and selection_payload
falsepositives:
  - None expected in legitimate REDCap survey traffic; any match warrants investigation
level: critical
---
title: Webshell File Creation in REDCap Web Root by Web Server Process
id: 5c1d9e27-3a8b-4f6d-b2c7-9e4a1f5d7c2b
status: experimental
description: Detects the web server or PHP process creating new script files (php, phtml, phar, aspx) in web-accessible directories, consistent with webshell deployment following REDCap code injection (CVE-2026-90817).
references:
  - https://www.cisa.gov/known-exploited-vulnerabilities-catalog?search_api_fulltext=CVE-2026-90817
  - https://attack.mitre.org/techniques/T1505/003/
author: Security Arsenal
date: 2026/11/19
tags:
  - attack.persistence
  - attack.t1505.003
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|endswith:
      - '/apache2'
      - '/httpd'
      - '/php-fpm'
      - '/php'
      - '/nginx'
  selection_shell:
    Image|endswith:
      - '/sh'
      - '/bash'
      - '/dash'
      - '/curl'
      - '/wget'
      - '/python'
      - '/python3'
      - '/perl'
      - '/nc'
      - '/ncat'
  condition: selection_parent and selection_shell
falsepositives:
  - REDCap cron-driven report generation may invoke shell tools; tune against the cron service account and known schedules
level: high

KQL — Microsoft Sentinel / Defender

The primary hunt below targets web access log telemetry (IIS, Apache, or a WAF/reverse proxy) ingested into Sentinel via CommonSecurityLog or AzureDiagnostics, hunting for the stream-wrapper and traversal payloads in survey requests. The secondary query hunts for web server process execution on the host via Defender for Endpoint.

KQL — Microsoft Sentinel / Defender
// Hunt 1: Suspicious REDCap survey requests with stream wrappers or traversal sequences
let lookback = 14d;
let payload_patterns = dynamic(["php://", "phar://", "file://", "data://", "expect://", "zip://", "../", "..%2f", "%2e%2e"]);
CommonSecurityLog
| where TimeGenerated > ago(lookback)
| where RequestURL has_any ("/surveys/", "redcap")
| extend DecodedURL = url_decode(RequestURL)
| where DecodedURL has_any (payload_patterns)
| project TimeGenerated, SourceIP, RequestURL, DecodedURL, RequestMethod, HttpUserAgent, DeviceAction, DestinationHostName
| sort by TimeGenerated desc;

// Hunt 2: Web server or PHP processes spawning shells/interpreters on REDCap hosts
DeviceProcessEvents
| where TimeGenerated > ago(lookback)
| where InitiatingProcessFileName in~ ("httpd.exe", "apache.exe", "php-cgi.exe", "php.exe", "w3wp.exe", "httpd", "apache2", "php-fpm", "nginx")
| where FileName in~ ("cmd.exe", "powershell.exe", "pwsh.exe", "sh", "bash", "curl", "wget", "nc", "ncat", "python", "python3", "perl")
| project TimeGenerated, DeviceName, InitiatingProcessFileName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, AccountName
| sort by TimeGenerated desc;

// Hunt 3: New script files written to web directories (webshell triage via Sysmon/FileCreation events)
DeviceFileEvents
| where TimeGenerated > ago(lookback)
| where FolderPath has_any ("\\wwwroot\\", "\\htdocs\\", "/var/www/", "/redcap/", "\\redcap\\")
| where FileName endswith ".php" or FileName endswith ".phtml" or FileName endswith ".phar" or FileName endswith ".aspx"
| where InitiatingProcessFileName in~ ("httpd.exe", "php-cgi.exe", "php.exe", "w3wp.exe", "httpd", "apache2", "php-fpm")
| project TimeGenerated, DeviceName, FolderPath, FileName, InitiatingProcessFileName, SHA256
| sort by TimeGenerated desc

Velociraptor VQL

Use this artifact across REDCap web servers to surface webshell candidates — recently created script files in web directories — and suspicious child processes of the web server, in a single hunt.

VQL — Velociraptor
-- REDCap CVE-2026-90817 triage: webshell candidates and web server child processes
LET webroots = ('C:/inetpub/wwwroot/**', 'C:/Apache*/htdocs/**', '/var/www/**', '/opt/redcap/**', '/usr/share/redcap/**')
LET suspicious_files = SELECT FullPath AS Path, Size, Mtime AS Modified
  FROM glob(globs=webroots, accessor='auto')
  WHERE Path =~ '(?i)\.(php|phtml|phar|php5|aspx|ashx)$'
    AND Mtime > now() - 1209600  -- modified in last 14 days
LET suspicious_procs = SELECT Pid, Name, CommandLine, Exe, Username, CreateTime
  FROM pslist()
  WHERE CommandLine =~ '(?i)(cmd\.exe|powershell|pwsh|/bin/(ba)?sh|curl |wget |ncat|nc -)'
    AND Name =~ '(?i)(httpd|apache|php|w3wp|nginx|sh|cmd|powershell)'
SELECT * FROM chain(a=suspicious_files, b=suspicious_procs)

Triage and Hardening Script

Run the following on Linux REDCap hosts to (a) identify potentially malicious files recently written to the web root, (b) check for unexpected child processes and cron persistence, and (c) apply compensating PHP hardening while patching is scheduled. This does not replace applying the vendor fix.

Bash / Shell
#!/bin/bash
# REDCap CVE-2026-90817 triage & compensating hardening (Linux/Apache-PHP)
# Run as root. Review output before taking destructive action.

WEBROOTS=("/var/www/html" "/var/www/redcap" "/opt/redcap" "/usr/share/redcap")
OUT="/root/redcap_triage_$(date +%Y%m%d_%H%M%S).log"

echo "=== [1] Script files modified in last 14 days under web roots ===" | tee -a "$OUT"
for d in "${WEBROOTS[@]}"; do
  [ -d "$d" ] && find "$d" -type f \( -name '*.php' -o -name '*.phtml' -o -name '*.phar' \) -mtime -14 -printf '%TY-%Tm-%Td %TH:%TM  %u  %p\n' | tee -a "$OUT"
done

echo "=== [2] Files with suspicious PHP constructs (eval/assert/create_function/include from input) ===" | tee -a "$OUT"
for d in "${WEBROOTS[@]}"; do
  [ -d "$d" ] && grep -rlE '(eval|assert|create_function)\s*\(|include(_once)?\s*\(?\s*\$_(GET|POST|REQUEST|COOKIE)|php://input' "$d" --include='*.php' 2>/dev/null | tee -a "$OUT"
done

echo "=== [3] Web server child processes (shells/interpreters) ===" | tee -a "$OUT"
ps auxf | grep -E '(apache2|httpd|php-fpm)' -A2 | grep -E '(sh|bash|curl|wget|nc |ncat|python|perl)' | tee -a "$OUT"

echo "=== [4] Persistence check: cron entries for web users ===" | tee -a "$OUT"
for u in www-data apache nginx; do
  echo "-- crontab for $u --" | tee -a "$OUT"
  crontab -u "$u" -l 2>/dev/null | tee -a "$OUT"
done
ls -la /etc/cron.d/ 2>/dev/null | tee -a "$OUT"

echo "=== [5] Compensating PHP hardening (stream wrapper & dangerous function restrictions) ===" | tee -a "$OUT"
PHPINI=$(php --ini 2>/dev/null | awk -F': ' '/Loaded Configuration File/{print $2}')
if [ -n "$PHPINI" ] && [ -f "$PHPINI" ]; then
  cp "$PHPINI" "${PHPINI}.bak_$(date +%Y%m%d)"
  sed -i 's/^;\?\s*allow_url_include\s*=.*/allow_url_include = Off/' "$PHPINI"
  sed -i 's/^;\?\s*allow_url_fopen\s*=.*/allow_url_fopen = Off/' "$PHPINI"
  grep -q '^disable_functions' "$PHPINI" || echo 'disable_functions = "exec,passthru,shell_exec,system,proc_open,popen,create_function"' >> "$PHPINI"
  echo "Hardened $PHPINI (backup saved). Restart Apache/php-fpm to apply: systemctl restart apache2 php*-fpm" | tee -a "$OUT"
else
  echo "php CLI not found; locate your web SAPI php.ini manually and set allow_url_include=Off, allow_url_fopen=Off" | tee -a "$OUT"
fi

echo "=== [6] Access log scan for stream-wrapper payloads on survey endpoints (last 100k lines) ===" | tee -a "$OUT"
for log in /var/log/apache2/access.log /var/log/httpd/access_log /var/log/apache2/ssl_access.log; do
  [ -f "$log" ] && tail -n 100000 "$log" | grep -Ei '(/surveys/|redcap)' | grep -Ei '(php%3a%2f%2f|phar%3a%2f%2f|file%3a%2f%2f|data%3a%2f%2f|php://|phar://|file://|data://|%2e%2e|\.\./)' | tee -a "$OUT"
done

echo "Triage complete: $OUT — preserve this host for forensics if any hits are found."

If any section returns hits — especially Sections 1, 2, 5, or 6 — treat the host as compromised: isolate it from the network (do not power off), capture memory and disk images, rotate all credentials in REDCap's configuration (database, SMTP, API tokens), and begin breach assessment against HIPAA's 60-day notification clock if PHI may have been accessed.

Remediation

  1. Apply the vendor fix immediately. Vanderbilt University has released guidance for CVE-2026-90817. REDCap administrators should upgrade to the patched release referenced in the official REDCap release notes and vendor advisory as distributed through the REDCap Consortium. Confirm your exact running version under Control Center → General Configuration and compare against the vendor's fixed-version guidance. Do not assume auto-update has covered this — verify the version string and the update timestamp.

  2. Meet the CISA BOD 22-01 deadline. Federal civilian agencies must remediate by the due date published in the KEV catalog entry. All other organizations — particularly healthcare and research institutions — should treat that date as binding. Track the catalog entry here: https://www.cisa.gov/known-exploited-vulnerabilities-catalog?search_api_fulltext=CVE-2026-90817

  3. If you cannot patch within 24 hours, apply compensating controls:

    • Disable or restrict public survey functionality at the application or WAF layer where operationally feasible.
    • Deploy WAF/reverse-proxy rules blocking requests to survey endpoints containing php://, phar://, file://, data://, expect://, zip://, or traversal sequences (../, %2e%2e) in any parameter.
    • Enforce allow_url_include = Off and allow_url_fopen = Off in PHP configuration (script above).
    • Restrict outbound egress from the REDCap web tier to only required destinations (SMTP, Vanderbilt update servers) to blunt post-exploitation C2.
  4. Hunt before you patch, and after. Patching does not evict an established attacker. Run the detections in this article across at least the last 14–30 days of web access logs, process telemetry, and file integrity data. Prioritize instances with internet-facing public surveys.

  5. Rotate secrets and review integrity. Rotate the REDCap database credentials, API tokens (including project-level tokens used by integrations and mobile app sync), SMTP credentials, and any service accounts configured in Control Center. Review user accounts and project-level audit logs (REDCap's built-in Logging module) for unauthorized exports, added users, or modified project configurations.

  6. Assess breach obligations. Given confirmed in-the-wild exploitation and the nature of REDCap data, coordinate with privacy/legal counsel early. If PHI or clinical trial data may have been accessed, HIPAA Breach Notification Rule timelines and, for research data, sponsor and IRB notification obligations may apply.

  7. Verify and document. After patching, re-run the triage script, validate the fixed version, and record remediation evidence — version screenshots, change tickets, and detection results — for your KEV/audit trail.

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.