Back to Intelligence

ZDI-26-614: Unpatched PDF Architect Out-of-Bounds Write Enables RCE — Detection and Mitigation Guide

SA
Security Arsenal Team
August 31, 2026
10 min read

The Zero Day Initiative has published ZDI-26-614, a publicly disclosed but unpatched out-of-bounds write vulnerability in pdfforge PDF Architect, a widely deployed PDF editor and converter for Windows. The flaw allows unauthenticated remote attackers to execute arbitrary code in the context of the user who opens a malicious file — and ZDI has rated it CVSS 7.8 (High).

The exploitation requirement is classic and cheap: user interaction. A target only needs to open a malicious PDF or visit a malicious page that delivers the crafted file. That means phishing email attachments, watering-hole downloads, and shared-file lures are all viable delivery vectors. With no vendor patch available at time of writing, this is a zero-day in every practical sense — your only controls today are detection, mitigation, and attack-surface reduction.

This matters because PDF editors sit on the endpoints of finance teams, legal departments, HR, and executives — exactly the personas adversaries target with document lures. A 7.8-rated memory corruption bug in a document parser, disclosed publicly with no fix, is an open invitation to exploit developers.

Technical Analysis

Affected Product

  • Vendor: pdfforge
  • Product: PDF Architect (Windows desktop application)
  • Advisory: ZDI-26-614 (http://www.zerodayinitiative.com/advisories/ZDI-26-614/)
  • CVSS: 7.8 (High) — vector consistent with local attack vector / user interaction required (AV:L/AC:L/PR:N/UI:R)
  • Status: Unpatched at disclosure. Per ZDI's standard process, this advisory followed their coordinated disclosure timeline after the vendor failed to ship a fix. No CVE identifier has been published in the advisory summary, and none should be assumed until MITRE/NVD assigns one.

Vulnerability Mechanics

The flaw exists in PDF file parsing within PDF Architect. When the application parses a malformed or maliciously crafted PDF object stream, it performs an out-of-bounds write — data is written past the boundary of an allocated memory buffer. OOB writes in document parsers are among the most reliable primitives for exploitation because the attacker controls both the input content and, frequently, the heap layout via embedded objects (JavaScript, embedded files, malformed xref tables, or crafted stream lengths).

From a defender's perspective, the attack chain looks like this:

  1. Delivery: Attacker sends a crafted .pdf via phishing email, malicious site download, or file-share lure.
  2. Trigger: Victim opens the file in PDF Architect (or it is opened via browser download / preview handler invocation).
  3. Memory corruption: The parser's OOB write corrupts adjacent memory, typically enabling control-flow hijack (overwriting function pointers, vtables, or return addresses).
  4. Code execution: Attacker-controlled code executes in the context of the logged-on user — no authentication required, no elevated privileges needed for initial access.
  5. Post-exploitation: Expect the child-process pattern typical of document exploits: the PDF process spawning cmd.exe, powershell.exe, mshta.exe, rundll32.exe, or dropping and executing a second-stage payload from %TEMP% or %APPDATA%.

Exploitation Status

  • Patch: None available — treat as an active zero-day exposure.
  • Public disclosure: Yes, via ZDI advisory, meaning technical details are circulating and exploit development is economically rational for threat actors.
  • Confirmed in-the-wild exploitation: Not confirmed in the advisory as of publication, but absence of evidence is not evidence of absence — public ZDI advisories for unpatched document-parser bugs have historically been weaponized within weeks.
  • CISA KEV: Not listed at time of writing; monitor https://www.cisa.gov/known-exploited-vulnerabilities-catalog for additions.

Detection & Response

Because there is no patch, your compensating controls are behavioral detection on the PDF Architect process and its children, plus file- and network-level hunting for the delivery stage. The detections below are built around the realistic post-exploitation behavior of a document-parser exploit — not speculative IoCs.

Sigma Rules

YAML
---
title: PDF Architect Spawning Script or Shell Child Process
id: 3f8c1a92-7b4d-4e61-9a05-2c7d8e1f6b03
status: experimental
description: Detects pdfforge PDF Architect spawning command shells, script engines, or LOLBins — a strong indicator of successful exploitation of a document-parsing memory corruption flaw such as ZDI-26-614. Legitimate PDF editors do not launch cmd, PowerShell, mshta, wscript, or rundll32 as child processes.
references:
  - http://www.zerodayinitiative.com/advisories/ZDI-26-614/
  - https://attack.mitre.org/techniques/T1203/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.execution
  - attack.t1203
  - attack.t1059
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|contains:
      - '\PDF Architect'
      - '\pdfarchitect'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\mshta.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\rundll32.exe'
      - '\regsvr32.exe'
      - '\certutil.exe'
      - '\bitsadmin.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Extremely rare; PDF Architect has no legitimate function that launches shells or script engines
level: high
---
title: PDF Architect Writing Executable Content to User-Writable Directories
id: 91d4e5b7-2c3a-4f08-b6d1-5e9a7c2d4f18
status: experimental
description: Detects the PDF Architect process writing PE files or script payloads to temp, AppData, or Downloads directories — consistent with a second-stage drop following exploitation of an out-of-bounds write in the PDF parser (ZDI-26-614).
references:
  - http://www.zerodayinitiative.com/advisories/ZDI-26-614/
  - https://attack.mitre.org/techniques/T1203/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.execution
  - attack.t1203
  - attack.t1105
logsource:
  category: file_event
  product: windows
detection:
  selection_process:
    Image|contains:
      - '\PDF Architect'
      - '\pdfarchitect'
  selection_path:
    TargetFilename|contains:
      - '\AppData\Local\Temp\'
      - '\AppData\Roaming\'
      - '\Downloads\'
      - '\ProgramData\'
  selection_ext:
    TargetFilename|endswith:
      - '.exe'
      - '.dll'
      - '.scr'
      - '.bat'
      - '.cmd'
      - '.ps1'
      - '.vbs'
      - '.js'
      - '.jse'
      - '.hta'
  condition: selection_process and selection_path and selection_ext
falsepositives:
  - PDF Architect self-updater writing components to ProgramData — correlate with vendor update signatures and scheduled update windows
level: high
---
title: PDF Architect Outbound Network Connection
id: b2e7f3a1-6d9c-4a85-8e24-7f1b3c5d9a62
status: experimental
description: Detects the PDF Architect process initiating outbound network connections. While update checks are legitimate, unexpected connections — especially to rare external hosts or immediately following document open — may indicate payload retrieval after exploitation of ZDI-26-614.
references:
  - http://www.zerodayinitiative.com/advisories/ZDI-26-614/
  - https://attack.mitre.org/techniques/T1071/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.command_and_control
  - attack.t1071
  - attack.t1105
logsource:
  category: network_connection
  product: windows
detection:
  selection:
    Image|contains:
      - '\PDF Architect'
      - '\pdfarchitect'
    Initiated: 'true'
  filter_update:
    DestinationHostname|contains:
      - 'pdfforge.org'
      - 'pdfarchitect.org'
  condition: selection and not filter_update
falsepositives:
  - Cloud conversion or licensing features contacting third-party services — baseline approved destinations before enforcing
level: medium

KQL — Microsoft Sentinel / Defender for Endpoint

Hunt for the full behavior chain: PDF Architect launching suspicious children, dropping executables, or beaconing to non-vendor infrastructure. Run this over the last 14 days and tune the vendor-domain allowlist to your environment.

KQL — Microsoft Sentinel / Defender
// Hunt: PDF Architect exploitation indicators (ZDI-26-614)
// Chain: suspicious child processes, payload drops, and non-vendor network egress
let PdfProc = dynamic(["pdf architect", "pdfarchitect"]);
let Lolbins = dynamic(["cmd.exe","powershell.exe","pwsh.exe","mshta.exe","wscript.exe","cscript.exe","rundll32.exe","regsvr32.exe","certutil.exe","bitsadmin.exe"]);
let VendorDomains = dynamic(["pdfforge.org","pdfarchitect.org"]);
let SuspiciousChildren =
    DeviceProcessEvents
    | where TimeGenerated > ago(14d)
    | where InitiatingProcessFileName has_any (PdfProc)
    | where FileName in~ (Lolbins)
    | project TimeGenerated, DeviceName, AccountName, InitiatingProcessFileName,
              InitiatingProcessCommandLine, FileName, ProcessCommandLine, SHA256;
let SuspiciousDrops =
    DeviceFileEvents
    | where TimeGenerated > ago(14d)
    | where InitiatingProcessFileName has_any (PdfProc)
    | where FolderPath has_any ("\\Temp\\", "\\AppData\\Roaming\\", "\\Downloads\\", "\\ProgramData\\")
    | where FileName has_any (".exe",".dll",".scr",".ps1",".bat",".vbs",".js",".hta")
    | project TimeGenerated, DeviceName, InitiatingProcessFileName, FolderPath, FileName, SHA256;
let SuspiciousNet =
    DeviceNetworkEvents
    | where TimeGenerated > ago(14d)
    | where InitiatingProcessFileName has_any (PdfProc)
    | where not(RemoteUrl has_any (VendorDomains))
    | summarize Connections=count(), RemoteIPs=make_set(RemoteIP), RemoteURLs=make_set(RemoteUrl)
        by DeviceName, InitiatingProcessFileName, bin(TimeGenerated, 1h);
SuspiciousChildren
| union SuspiciousDrops
| order by TimeGenerated desc;
// Run SuspiciousNet separately to review egress baselines per device

Velociraptor VQL

Use this hunt artifact across your fleet to identify PDF Architect installations (attack surface inventory) and flag any live instances spawning shells or script engines — the highest-fidelity exploitation signal.

VQL — Velociraptor
-- ZDI-26-614: PDF Architect exposure and exploitation hunt
-- 1) Identify installed PDF Architect binaries (attack surface)
-- 2) Flag running PDF Architect processes with suspicious children
SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE Exe =~ '(?i)pdf.?architect'

-- Child-process check: run on endpoints where PDF Architect is present
SELECT Pid, Ppid, Name, Exe, CommandLine, CreateTime
FROM pslist()
WHERE Name =~ '(?i)(cmd|powershell|pwsh|mshta|wscript|cscript|rundll32|regsvr32|certutil|bitsadmin)\.exe$'
  AND Ppid IN (
      SELECT Pid FROM pslist() WHERE Exe =~ '(?i)pdf.?architect'
  )

-- Persistence check: PDF Architect or dropped payloads in Run keys
SELECT Name, Data, Key
FROM glob(globs='HKEY_USERS/*/Software/Microsoft/Windows/CurrentVersion/Run/*', accessor='registry')
WHERE Data =~ '(?i)(pdf.?architect|appdata.*\.(exe|dll|ps1|bat))'

Remediation / Hardening Script

Until pdfforge ships a fix, run this PowerShell across endpoints (via your RMM, Intune, or GPO startup script) to inventory installations, report exposure, and optionally remove or block the application. The block path uses an AppLocker-style Software Restriction hash/publisher approach via Block-PdfArchitect as a temporary compensating control.

PowerShell
# ZDI-26-614: PDF Architect exposure inventory and temporary mitigation
# Run elevated. Default mode = audit only. Use -Remove or -Block for enforcement.
param(
    [switch]$Remove,
    [switch]$Block,
    [string]$ReportPath = "$env:ProgramData\Security\ZDI-26-614-Report.csv"
)

$results = @()

# --- Inventory: find installed PDF Architect via registry uninstall hives ---
$hives = @(
    'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*',
    'HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*',
    'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*'
)
$installed = Get-ItemProperty $hives -ErrorAction SilentlyContinue |
    Where-Object { $_.DisplayName -match 'PDF Architect' }

foreach ($app in $installed) {
    $results += [PSCustomObject]@{
        Hostname        = $env:COMPUTERNAME
        Product         = $app.DisplayName
        Version         = $app.DisplayVersion
        Publisher       = $app.Publisher
        InstallLocation = $app.InstallLocation
        UninstallString = $app.UninstallString
        Detected        = (Get-Date -Format 'yyyy-MM-dd HH:mm:ss')
    }
}

if ($results.Count -gt 0) {
    New-Item -Path (Split-Path $ReportPath) -ItemType Directory -Force | Out-Null
    $results | Export-Csv -Path $ReportPath -NoTypeInformation -Append
    Write-Warning "PDF Architect detected. Report: $ReportPath"

    # --- Optional: uninstall as attack-surface reduction until patch ships ---
    if ($Remove) {
        foreach ($app in $installed) {
            if ($app.UninstallString) {
                Write-Host "Uninstalling: $($app.DisplayName)"
                $uninst = $app.UninstallString -replace '^MsiExec\.exe\s*/I', 'msiexec.exe /X'
                Start-Process cmd.exe -ArgumentList "/c $uninst /qn /norestart" -Wait
            }
        }
    }

    # --- Optional: block execution via Image File Execution Options debugger trick ---
    # (Emergency stopgap only; prefer AppLocker/WDAC publisher rules in managed fleets)
    if ($Block) {
        $exeNames = @('PDF Architect.exe','PDFArchitect.exe','pdfarchitect.exe')
        foreach ($exe in $exeNames) {
            $ifeo = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\$exe"
            New-Item -Path $ifeo -Force | Out-Null
            New-ItemProperty -Path $ifeo -Name 'Debugger' -Value 'systray.exe' -PropertyType String -Force | Out-Null
            Write-Host "Execution blocked via IFEO: $exe"
        }
    }
} else {
    Write-Host "No PDF Architect installations found on $env:COMPUTERNAME."
}

# --- Verification: confirm no PDF Architect process is currently running ---
Get-Process | Where-Object { $_.Path -match 'PDF.?Architect' } |
    Select-Object Name, Id, Path, StartTime

Remediation

There is no patch available for ZDI-26-614 as of publication. Until pdfforge releases a fixed build, apply the following in priority order:

  1. Inventory and reduce the attack surface (today). Use the script above or your software inventory (Intune, SCCM, Tanium) to enumerate every PDF Architect installation. If the business does not require it, uninstall it. Every unpatched document parser on an endpoint is an initial-access opportunity.
  2. Substitute an alternative PDF viewer/editor for users who need PDF capability during the exposure window, and communicate the change to reduce user workarounds.
  3. Block execution temporarily via AppLocker/WDAC publisher or path rules (preferred) or the IFEO stopgap in the script for unmanaged systems. Do not rely on IFEO long-term — it is trivially bypassed and unsuitable for regulated environments.
  4. Harden the delivery vector. Since exploitation requires a malicious file, tighten email and web controls: enable attachment sandboxing/detonation for PDFs, strip or quarantine PDFs from untrusted external senders where feasible, and enforce SmartScreen/Defender network protection.
  5. Enforce exploit mitigations. Confirm Microsoft Defender Exploit Guard attack surface reduction (ASR) rules are enabled — particularly "Block Office applications from creating child processes" equivalents applied via Exploit Protection mitigations (DEP, ASLR, CFG, SEHOP) for the PDF Architect binary. These raise the cost of weaponizing an OOB write substantially.
  6. Deploy the detections above and alert at high severity on any PDF Architect child-process or payload-drop event. These signals are low-noise by design — treat every hit as a potential incident and trigger your IR runbook.
  7. Monitor for the vendor fix. Watch the pdfforge release notes (https://www.pdfforge.org), the ZDI advisory page (http://www.zerodayinitiative.com/advisories/ZDI-26-614/) for a CVE assignment and patch reference, and the CISA KEV catalog. Validate the patched version number against your inventory before declaring closure, and remove temporary execution blocks only after the update is confirmed deployed fleet-wide.
  8. Educate high-risk users (finance, legal, HR, executives) that PDF attachments are an active exploitation vector right now — the phish that lands this week may be carrying this bug.

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.