Blog da Zscaler

Receba as últimas atualizações do blog da Zscaler na sua caixa de entrada

Products & Solutions

Closing the Process-to-Packet Chasm: Why We Built Zscaler Endpoint Context (And Why Your EDR Loves It)

VIVEK GANTI, JOBY MENON
November 19, 2026 - 11 Min. de leitura
>Closing the Process-to-Packet Chasm: Why We Built Zscaler Endpoint Context (And Why Your EDR Loves It)

If you have ever spent a Tuesday afternoon in a Security Operations Center (SOC), you have watched the most expensive game of "telephone" in enterprise IT.

It starts with a network alert. An outbound encrypted connection to an unfamiliar IP address or a newly registered domain. The SOC analyst looks at the alert and asks a deceptively simple question: What on the user’s machine actually opened this connection?

Was it a legitimate Chrome browser tab? A developer’s CLI utility? A rogue GenAI desktop agent? Or was it powershell.exe spawned by a malicious ClickFix lure, quietly beaconing out to a Cobalt Strike command-and-control (C2) server?

Historically, the network couldn't tell you. A network proxy sees packets, TLS handshakes, and IP headers. The network doesn’t see Process IDs (PIDs), parent execution paths, or unsigned binaries. Meanwhile, the Endpoint Detection and Response (EDR) agent sitting on the laptop sees every process and thread in exquisite detail, but it is effectively blind to the contents of inline encrypted payloads once they leave the network interface.

To answer that one basic question, the analyst has to open four different consoles: endpoint, network, identity, and cloud. And then manually stitch together timestamps and ephemeral source ports by hand. While the human is pivoting between tabs, the adversary is moving laterally. Today, the fastest observed breakout time is 51 seconds. You cannot fight a 51-second breakout with a 45-minute manual log-stitching exercise.

That architectural divide between the host and the wire is why we built Zscaler Endpoint Context.

As we recently highlighted in this post, defenders are being asked to make harder decisions with less time and less certainty. Today, we are going to look under the hood at the architectural problem Endpoint Context solves, walk through concrete examples of where it stops threats in their tracks, explain why it is fundamentally distinct from — and complementary to — your existing EDR, and show how attaching process-level intelligence directly to 750 billion daily cloud transactions changes the math for every enterprise security team.


 

The Anatomy of the Blind Spot: When the Host and the Wire Don’t Talk

To understand why modern attacks succeed, you have to look at the seams between security domains. Attackers don't think in product categories; they exploit the gaps between them:

  1. Living-off-the-Land (LOTL) and Fileless Execution: Adversaries increasingly abuse built-in OS tools (PowerShell, RDP, WMI) and modern social engineering lures like ClickFix or DLL sideloading. Because there is no traditional malicious file dropped on disk to scan, host-only thresholds often aren't crossed until the process is already communicating outbound.
  2. 87%+ of Threats Hide in Encrypted Channels: Standalone endpoint tools observe local host activity, but they cannot perform inline SSL/TLS decryption at cloud scale to inspect hidden C2 traffic or data exfiltration in flight. Conversely, developer tools, certificate-pinned applications, and non-binary software (like browser extensions and plugins) frequently create visibility blind spots on the wire.
  3. Out-of-Band Entry Vectors: Not every threat arrives through the front door of the corporate proxy. Malware introduced offline via USB drives, Bluetooth, or AirDrop bypasses inline network gateways entirely — turning the laptop into a "patient zero" device the moment it reconnects.

For years, the industry tried to solve this after the fact in the SIEM. The philosophy was: dump all your network logs and all your endpoint logs into a data lake, write correlation rules, and hope the join query finishes before the data is exfiltrated.

But security teams have always known that this is an observability strategy, not an inline prevention strategy. 

Enter Zscaler Endpoint Context: Attaching the Process to the Transaction

At Zscaler, we already sit inline for over 750 billion daily transactions across the Zero Trust Exchange, with Zscaler Client Connector (ZCC) deployed across 60M+ endpoints.

Instead of forcing SOC analysts to correlate host processes with network flows hours later, we asked: What if ZCC harvested rich process and application telemetry on the device and attached it directly to the network transaction in real time?

Here is what happens under the hood across the six core pillars of Zscaler Endpoint Context — and what that looks like in the real world:

1. Granular Application & Process Visibility

Because ZCC is already on the endpoint routing traffic through Z-Tunnel 2.0, Endpoint Context continuously inventories running applications and processes without requiring a heavy, separate agent deployment. With Endpoint Context, Zscaler customers will be able to capture:

  • Deep Process Lineage: Process ID (PID), process owner, execution duration, exit codes, parent/child process relationships, parent execution paths, and exact command-line arguments.
  • Binary & Non-Binary Inventory: Application install paths, version enumeration, cryptographic hashes (MD5/SHA), code-signing status, and non-binary software such as browser extensions and plugins.
  • Vulnerability & Risk Mapping: Immediate identification of endpoint applications or processes carrying known CVEs or threat/risk indicators.
image
  • Real-World Example (Catching the Fake Browser): Imagine a piece of malware renames itself chrome.exe in a user's Downloads folder and spoofs a Chrome browser header over port 443. A standard web proxy only sees "Chrome" and lets it through. Endpoint Context immediately sees that chrome.exe is unsigned, running from the wrong install path, and has an unknown SHA hash — exposing the imposter before a single packet reaches the destination.
image

2. Surgical, Adaptive Inline Policy Enforcement

Once the Zero Trust Exchange knows which exact process initiated a network session and what its risk posture is, static network rules become dynamic, process-aware guardrails. Security teams can:

  • Enforce Process-Level SSL/TLS, DNS, and Firewall Policies: Use application or process identity, threat score, code-signing status, and CVE properties as live criteria inside ZIA SSL/TLS Inspection, DNS, and Advanced Firewall policies.
  • Control Applications Without Chasing Network Coordinates: Historically, blocking or governing an endpoint application on the network meant playing an endless game of whack-a-mole. You had to research, know, and maintain complex lists of every destination domain, IP address, protocol, and port that application might use, and then write multiple rules to cover them all. Because ZCC identifies traffic directly from the originating endpoint application, with Endpoint Context, customers will be able to block or control all traffic generated by an app with a single policy — without ever needing to know its underlying domains, IPs, ports, or protocols.
  • Govern Cert-Pinned Apps, Dev Tools, and Agentic AI: Leverage curated or custom application tag lists to manage developer utilities, certificate-pinned applications, and emerging agentic AI tools eliminating Shadow IT and Shadow AI blind spots.
  • Execute Policy-Based Quarantine: Define granular application control policies to block outbound access for vulnerable or unsanctioned software, or trigger policy-based quarantine rules for apps, processes, files, and full endpoint isolation when necessary.
  • Real-World Example (Fixing the Developer & AI Bypass Headache): Every security team struggles with certificate-pinned developer tools (git, npm, python) or local AI agents that break under SSL inspection. Previously, you had to bypass inspection by destination domain — opening a blind spot any malware on the laptop could use. With Endpoint Context, you can write a surgical rule: Only bypass SSL inspection if the traffic comes from a cryptographically signed, vendor-verified developer tool with zero critical CVEs — and block outbound access for any unsanctioned desktop AI agent or risky browser extension.
image

3. Inline Threat Protection Against Modern Exploits

By feeding application and process metadata directly into Zscaler’s inline inspection engines and AI/ML models, ZIA can stop attacks that evade single-domain tools:

  • C2 & Supply Chain Disruption: Enhanced inline detection and remediation for command-and-control frameworks (Cobalt Strike, Mythic, PoshC2), Living-off-the-Land (LOTL) activity, and software supply chain compromises.
  • Exploit Technique Prevention: Real-time identification and blocking of modern initial-access and persistence tradecraft, including ClickFix execution chains and DLL sideloading.
  • Real-World Example (Stopping a ClickFix Attack in Flight): A user is tricked by a fake browser update prompt (ClickFix) into running a hidden PowerShell command that beacons out to a brand-new domain with a clean reputation. Because PowerShell is a legitimate Windows tool and the domain is brand new, both the endpoint and the URL filter might hesitate. Endpoint Context combines the two: ZIA sees that an anomalous parent-child chain (explorer.exe -> powershell.exe -EncodedCommand) is initiating an outbound connection to an unknown host, flags the C2 pattern inline, and drops the connection immediately.

4. Out-of-Band Vector Coverage with Endpoint Sandbox

What happens when a user plugs in an infected USB drive, or receives a file over Bluetooth or AirDrop while offline? A traditional cloud proxy never sees that file cross the wire.

  • Real-World Example (Quarantining the Conference USB): An employee picks up a USB drive or receives an AirDrop file while traveling and clicks the executable. With Endpoint Context’s Endpoint Sandbox integration, Zscaler intercepts the unknown .exe prior to execution and submits it to the Zscaler Cloud Sandbox for detonation and analysis — stopping patient-zero zero-day malware before it ever runs on the host.

5. Unifying SecOps and Slashing MTTD/MTTR

As we explored in our recent posts on Bridging the Gap Between NetOps and SecOps and Taming Agentic Threats, the ultimate goal of architecture is to make human defenders faster. Endpoint Context streams unified process-plus-network metadata directly into Zscaler Insight Logs and Nanolog Streaming Service (NSS), while correlating threat intelligence with Red Canary and leading NDR platforms (such as Vectra, ExtraHop, and Corelight).

  • Real-World Example (Ending the SOC "Pivot Tax"): When an analyst gets an alert in their SIEM or MDR workflow, they don't have to spend 20 minutes cross-referencing firewall logs with EDR process trees to see if a suspicious process actually exfiltrated data. The exact process name, hash, command line, and inline block verdict are stamped onto a single Zscaler transaction log — cutting investigation time from 20+ minutes to under 3 minutes.

 

The Elephant in the Room: How Endpoint Context Is Separate from EDR

Whenever we talk about process lineages, hashes, and parent/child relationships, the first question from any pragmatic CISO or SOC Director is: "Wait, is Zscaler trying to replace my CrowdStrike, SentinelOne, or Microsoft Defender?"

The short answer is no. 

EDR/EPP platforms and Zscaler Endpoint Context operate on fundamentally different planes of the enterprise architecture, and they are engineered to work together in a defense-in-depth model:

Capability Dimension

Standalone EDR / XDR (CrowdStrike, SentinelOne, Defender)

Zscaler Endpoint Context + EDR (Better Together)

Primary Enforcement Plane

Host & Kernel Plane: Deep OS-level behavioral monitoring, memory scanning, and local process termination once a host detection threshold is crossed.

Inline Network & Cloud Plane: Real-time per-session access control across web, SaaS, and private apps before traffic transits the wire.

SSL/TLS Decryption at Scale

Host-Anchored: Blind to inline encrypted network payload contents in flight; cannot natively inspect TLS traffic at cloud scale.

Full Inline TLS Inspection: Decrypts and inspects 750B+ daily signals in the cloud, tying the cleartext payload directly to the initiating endpoint process.

Cross-Domain Correlation

Siloed Telemetry: Exports host-centric logs that require complex, expensive SIEM/SOAR join rules to match against proxy and firewall flows.

Natively Unified: Stamps identity, endpoint process, CVE posture, and cloud destination onto a single transaction record streamed via NSS.

Policy & Access Control

Binary Host Containment: Primarily acts via process kill or full host network quarantine after malicious behavior is confirmed.

Surgical Inline Guardrails: Dynamically restricts an unpatched app from reaching sensitive cloud data or bypasses/enforces TLS inspection per process without bricking the user's laptop.

When an attacker uses a living-off-the-land binary or a stolen session token that doesn't trigger a high-confidence kernel alert on the host, they still have to communicate over the network to achieve their objective. And when they hit the Zero Trust Exchange, Zscaler sees the exact process, sees inside the TLS tunnel, and blocks the session inline — while streaming high-fidelity evidence to your SOC, Red Canary, or EDR workflows to accelerate root-cause remediation.


 

Why Every Customer Should Turn This On

Security teams today don’t have a data shortage problem; they have a context shortage problem.

Every Zscaler customer who already routes traffic through Zscaler Client Connector and the Zero Trust Exchange is sitting on a goldmine of inline control. By enabling Zscaler Endpoint Context, you immediately transform both your network security and your SOC operations:

  1. Zero-Friction Deployment: There is no new kernel sensor to deploy, test, or certify across your fleet. If you are running Zscaler Client Connector (v4.8+ with Z-Tunnel 2.0), the telemetry harvesting is built right into the footprint you already trust on 60M+ devices.
  2. Eliminate the "Pivot Tax" in the SOC: Every alert in ZIA Insight Logs and every stream sent via NSS to your SIEM arrives pre-correlated with the exact application name, PID, hash, command-line argument, and CVE risk score. You turn a 30-minute multi-tool investigation into a 30-second verification.
  3. Make Your Firewall and TLS Policies Process-Aware: Historically, controlling an application’s network traffic meant knowing every domain, IP address, protocol, and port it used, and writing a labyrinth of firewall and proxy rules to cover them all. Because ZCC identifies traffic directly from the endpoint application itself, you can block or control all traffic from an app in one step without needing to know its underlying network coordinates. You can write surgical Zero Trust policies like: "Allow signed developer tools to communicate on custom ports, block all outbound traffic from unsanctioned desktop apps or unsigned processes regardless of destination IP or port, and automatically isolate any process exhibiting ClickFix or DLL sideloading indicators."

 

In cybersecurity, the winner is almost always the side with the most context at the moment a decision has to be made. By uniting the process on the endpoint with the packet in the cloud, we are making sure that advantage belongs permanently to the defender.


Want to see Zscaler Endpoint Context in action? Reach out to your Zscaler account team to schedule a live deep dive and see your own Endpoint Application Inventory, and CVE risk scoring, in the Zero Trust Exchange. 

form submtited
Obrigado por ler

Esta postagem foi útil??

Aviso legal: este post no blog foi criado pela Zscaler apenas para fins informativos e é fornecido "no estado em que se encontra", sem quaisquer garantias de exatidão, integridade ou confiabilidade. A Zscaler não se responsabiliza por quaisquer erros, omissões ou por quaisquer ações tomadas com base nas informações fornecidas. Quaisquer sites ou recursos de terceiros vinculados neste post são fornecidos apenas para sua conveniência, e a Zscaler não se responsabiliza por seu conteúdo ou práticas. Todo o conteúdo está sujeito a alterações sem aviso prévio. Ao acessar este blog, você concorda com estes termos e reconhece que é de sua exclusiva responsabilidade verificar e utilizar as informações conforme apropriado para suas necessidades.

Receba as últimas atualizações do blog da Zscaler na sua caixa de entrada

Ao enviar o formulário, você concorda com nossa política de privacidade.