You are currently viewing Intercepting Desktop App Traffic with Burp Suite: System Proxy Setup, HTTPS Capture, and Beating Certificate Pinning

Intercepting Desktop App Traffic with Burp Suite: System Proxy Setup, HTTPS Capture, and Beating Certificate Pinning

📋 Key Takeaways
  • Yes. Most desktop applications honor the Windows system proxy or the standard HTTP_PROXY/HTTPS_PROXY environment variables—set Burp Suite as the proxy, install Burp's CA certificate into the OS trust store, and the client's HTTPS traffic appears in your HTTP history like any web app.
  • Before intercepting anything, build a controlled environment.
  • The fastest path. Most .NET, Java, Electron, and Python applications built on standard HTTP libraries read the OS proxy configuration.
  • Some applications ignore the system proxy but respect the de facto standard environment variables honored by cURL, Python requests, Go's net/http, Node.js libraries, and most Java HTTP clients.
11 min read · 2,183 words
Educational & Ethical Use Only — This article is provided for educational and ethical cybersecurity research purposes only. The techniques described should only be used on systems you own or have explicit permission to test. Always follow responsible disclosure and the laws applicable to you. Mitigations are included so engineers can harden real systems.
🗺️ ArchitectureIntercepting Desktop App Traffic with Burp Suite
🖥️Thick ClientElectron/.NET/Java app
HTTP(S) via proxy
⚙️System Proxy127.0.0.1:8080
redirect traffic
🕷️Burp SuiteTLS interception proxy
re-encrypt upstream
🔑Trust StoreBurp CA certificate
trust forged cert
🌐Target APITest backend endpoint
pinned? blocked
🔒Cert PinningBlocks interception

Client → system proxy → Burp → API; trust store enables HTTPS decryption, pinning blocks it

Security

🧭 Part of: Client Application Security

🔎 Last updated · Editorial policy · Report an error

TL;DR: Can Burp Suite intercept desktop (thick client) app traffic?

Yes. Most desktop applications honor the Windows system proxy or the standard HTTP_PROXY/HTTPS_PROXY environment variables—set Burp Suite as the proxy, install Burp’s CA certificate into the OS trust store, and the client’s HTTPS traffic appears in your HTTP history like any web app. The only reliable obstacle is certificate pinning, which we’ll diagnose and address below.

Web application testing has a well-established playbook: point the browser at Burp Suite, capture the request, fuzz the parameter. Thick clients throw half of that out the window. A desktop app—an Electron bundle, a .NET WPF client, a Java fat jar, a native C++ binary—doesn’t have an address bar, doesn’t always respect your proxy, and may validate TLS in ways your browser never would. Yet the same classes of vulnerability apply: broken authorization on hidden REST endpoints, hardcoded API keys, plaintext tokens in telemetry, insecure update mechanisms. OWASP’s API Security Top 10 (2023) is as relevant to a thick client’s backend as it is to a SaaS web frontend.

This guide walks through the complete workflow: routing desktop traffic through Burp Suite, capturing HTTPS, identifying hidden API calls, and understanding what happens when certificate pinning says no.

Lab Setup: Prerequisites and Environment

Before intercepting anything, build a controlled environment. Never point these techniques at applications you don’t own or lack written authorization to test—intercepting third-party traffic can violate the CFAA, the Computer Misuse Act, or equivalent statutes in your jurisdiction.

  • Burp Suite Community or Professional (PortSwigger). Professional adds Intruder throughput and active scanning, but Community is sufficient for proxy interception.
  • A Windows 10/11 VM (or Linux—this guide uses Windows paths). Snapshot it before you start so trust-store changes and environment variables are disposable.
  • A sample thick client. Good candidates: OWASP’s crAPI companion tools, an Electron test app you build yourself, or a deliberately vulnerable desktop CTF binary.
  • A safe target backend: DVWA, OWASP Juice Shop, crAPI, or a self-hosted test API on your lab network.
  • Confirm Burp’s listener: Proxy → Proxy settings → verify it’s bound to 127.0.0.1:8080 with “All interfaces” disabled unless you intentionally want LAN exposure.

Method 1: Routing Traffic Through the Windows System Proxy

The fastest path. Most .NET, Java, Electron, and Python applications built on standard HTTP libraries read the OS proxy configuration.

  1. Open Settings → Network & Internet → Proxy (or the legacy Internet Options applet → Connections → LAN settings).
  2. Enable Use a proxy server, set the address to 127.0.0.1 and the port to 8080.
  3. Launch your thick client and use it normally—log in, trigger API calls, check for updates.
  4. Watch Burp’s HTTP history under the Proxy tab. Requests should start appearing immediately.

If history populates but you see CONNECT tunnel entries without decrypted content, the app is reaching Burp but TLS interception is failing—that’s the CA certificate step below. If nothing appears at all, move to Method 2.

Method 2: Forcing Traffic with HTTP_PROXY and HTTPS_PROXY Environment Variables

Some applications ignore the system proxy but respect the de facto standard environment variables honored by cURL, Python requests, Go’s net/http, Node.js libraries, and most Java HTTP clients.

Command Prompt (session-scoped):

set HTTP_PROXY=http://127.0.0.1:8080
set HTTPS_PROXY=http://127.0.0.1:8080
set NO_PROXY=localhost,127.0.0.1

Persistent via setx:

setx HTTP_PROXY "http://127.0.0.1:8080"
setx HTTPS_PROXY "http://127.0.0.1:8080"
setx NO_PROXY "localhost,127.0.0.1"

PowerShell (session-scoped):

$env:HTTP_PROXY  = "http://127.0.0.1:8080"
$env:HTTPS_PROXY = "http://127.0.0.1:8080"
$env:NO_PROXY    = "localhost,127.0.0.1"

Launch the application from the same shell so it inherits the environment. Note that setx writes persistently but doesn’t affect the current session—open a new terminal afterward. Always set NO_PROXY; without it, localhost debugging traffic loops through Burp and generates noise or failures.

Installing Burp’s CA Certificate Into the Windows Trust Store

Interception means Burp terminates the client’s TLS and re-establishes it upstream. For the client to accept Burp’s forged certificate, Burp’s CA must be trusted by the OS.

  1. With the proxy configured, browse to http://burp and download the certificate (CA Certificate button—this delivers a DER-encoded .cer file). Alternatively: Proxy settings → Import/export CA certificate.
  2. Double-click the file → Install Certificate → Current User → Place all certificates in the following store → browse to Trusted Root Certification Authorities.
  3. Verify via certmgr.msc → Trusted Root Certification Authorities → Certificates → look for PortSwigger CA. For machine-wide trust, use certlm.msc instead.
  4. Restart the thick client. Many runtimes (.NET, Java JVMs using the Windows trust store) cache CA state at startup.

Java applications are a common exception: JVMs historically use cacerts, not the Windows store. Either import with keytool -importcert -cacerts, or launch the JVM with -Djavax.net.ssl.trustStoreType=WINDOWS-ROOT. Burp’s TLS pass-through options (Proxy settings → TLS pass through) let you selectively exclude hosts whose pinning you can’t yet address, keeping the rest of the session testable.

Capturing Hidden API Calls: What to Look For

With traffic flowing, the real work begins. Thick clients routinely expose attack surface the UI never shows.

  • Undocumented REST endpoints: Admin functions, debug routes, and versioned APIs (/api/v2/) the UI doesn’t surface. Add interesting hosts to Target scope, then review the site map tree.
  • Tokens and secrets: Authorization headers, refresh tokens, API keys in query strings. These frequently reveal JWTs with weak validation—worth replaying with modified claims.
  • Telemetry and analytics: often sent unauthenticated, sometimes leaking user identifiers, machine fingerprints, or internal hostnames.
  • Update checks: If the client polls an update endpoint, examine whether the response is integrity-checked. An unsigned or unverified update channel is a remote code execution primitive.
  • Filter the noise: Use Display filter in HTTP history (e.g., filter by scope or MIME type JSON) to cut telemetry clutter and focus on functional API calls.

When Interception Fails: How Certificate Pinning Blocks Burp

Certificate pinning means the application hardcodes—or embeds a hash of—the expected server certificate or its Subject Public Key Info (SPKI). At connection time, the client compares what the server presents against the pin and aborts on mismatch. Burp’s forged certificate never matches, so the TLS handshake fails.

Symptoms that confirm pinning:

  • The app errors out (“connection failed,” generic network error) only while the proxy is configured.
  • Burp history shows the CONNECT request but no decrypted subsequent traffic—just repeated failed handshakes.
  • Burp’s event log or the client logs report SSLHandshakeException, peer not authenticated, or certificate_verify_failed.
  • Installing Burp’s CA changes nothing.

Pinning exists precisely to defeat the trust-store model you just set up. In the OWASP Mobile Application Security Verification Standard (MASVS), certificate pinning belongs with the network-communication requirements (MASVS-NETWORK) — hardening how the client talks to its backend — and the same logic applies to desktop clients protecting high-value APIs. Pinning is also why CISA and vendors repeatedly warn against trusting endpoints blindly: the control assumes the endpoint may be hostile.

Options for Handling Pinned Clients (Authorized Testing Only)

You have written authorization and the app is yours or in scope. Your options, roughly in order of effort:

  • Configuration first: Some applications offer debug modes or accept a custom CA path—check documentation before reversing anything.
  • Binary patching: Locate the validation routine in the binary (Ghidra, IDA Free, dnSpy for .NET assemblies) and NOP the comparison or force it to return true. Rebuild or patch in place.
  • Runtime instrumentation with Frida: The Frida dynamic instrumentation toolkit and objection provide hooks that bypass common pinning implementations (SSLContext, X509TrustManager, CertificateTransparency checks) without touching the binary. Universal bypass scripts exist for the most common libraries—expect to iterate against custom implementations.
  • Upstream interception: If you can’t defeat pinning on the client, terminate TLS upstream with a transparent proxy on the test network and present the real certificate chain—effective only when you control the PKI, which you do in a lab.

Boundaries: Bypassing pinning on software you don’t own, distributing patched binaries, or using these techniques to access third-party systems is illegal in most jurisdictions regardless of intent. These tools are for authorized assessments, secure development testing, and CTF environments—full stop.

Blue-Team Perspective: Why Debug Proxies Are a Defensive Risk

Everything above cuts both ways. If your thick client’s traffic is trivially interceptable, so is everyone else’s—including an attacker on the same network segment running mitmproxy, or a malware author sniffing tokens on a compromised workstation.

Hardening guidance for desktop clients:

  • Validate TLS rigorously and pin where the threat model justifies it. Pin the SPKI of your CA or leaf keys; rotate pins in pairs to avoid bricking clients during key rollover.
  • Never trust client-side enforcement alone. The API server must enforce authorization on every endpoint—assume the client is fully compromised. OWASP API Security Top 10 (API5:2023 Broken Function Level Authorization) exists because hidden endpoints get found.
  • Sign and verify update packages. Update channels discoverable via a debug proxy are the highest-value target; use signatures with revocation (e.g., The Update Framework pattern).
  • Minimize secrets in the client. Anything in HTTP headers or embedded strings is extractable; keep authorization decisions server-side.
  • Don’t leak internal topology through telemetry, verbose error messages, or hardcoded staging hostnames.

CISA’s Secure by Design guidance pushes vendors toward exactly this posture: assume adversarial inspection of everything shipped to the endpoint.

Troubleshooting Common Burp Desktop Interception Problems

  • App ignores both system proxy and env vars. Some clients hardcode proxy settings or use raw sockets/non-HTTP protocols (gRPC over HTTP/2, custom TCP, WebSockets). Burp can proxy WebSockets; raw TCP requires a different tool or upstream transparent proxying.
  • Burp history stays empty but the app works. Either the client is non-proxy-aware (try an upstream transparent proxy), traffic is pinned TLS, or it’s a non-HTTP protocol. Check Burp’s Event log for handshake errors.
  • Certificate errors only on specific hosts. Partial pinning—the app pins only update or payment endpoints. Add those hosts to TLS pass-through and continue testing the rest.
  • Loopback storms. You forgot NO_PROXY; the app proxies its own localhost calls through Burp endlessly.
  • Java apps fail despite Windows trust. Import into cacerts with keytool or set -Djavax.net.ssl.trustStoreType=WINDOWS-ROOT.
  • HTTP/2 and gRPC quirks. Burp supports HTTP/2 (enable it in Proxy settings), but some gRPC clients need the plaintext h2c path handled explicitly.

Key Takeaways and Practice Targets

The workflow compresses to four steps: point the client at Burp (system proxy or environment variables), trust Burp’s CA in the OS store, mine HTTP history for hidden endpoints and secrets, and—when handshakes fail—diagnose pinning before reaching for Frida or binary patching. Interception failures aren’t dead ends; they’re diagnostic data about the client’s security posture.

Practice safely on authorized platforms:

Bigger attack surface, more thick clients, more hidden APIs, more telemetry, more update channels—the debug proxy remains one of the highest signal-per-minute tools in the assessment arsenal. Master it against your own applications before someone else masters it against theirs.

Frequently Asked Questions

Does every desktop app respect the Windows system proxy?

No. Many do, but some hardcode proxy configuration, use HTTP libraries that ignore OS settings, or communicate over raw sockets and non-HTTP protocols. Environment variables (HTTP_PROXY/HTTPS_PROXY) catch a second tier of clients; the remainder may require a transparent/upstream proxy or simply can’t be intercepted with Burp at all.

Where do I install Burp’s CA certificate on Windows?

Into the Trusted Root Certification Authorities store—either Current User (via certmgr.msc or the certificate import wizard) or Local Machine (via certlm.msc). Java applications are the exception: import into the JVM’s cacerts keystore with keytool or launch with -Djavax.net.ssl.trustStoreType=WINDOWS-ROOT.

Only on applications you own or have explicit written authorization to test. Bypassing pinning on third-party software, or using interception to access systems outside your authorized scope, violates computer fraud laws in most jurisdictions regardless of intent. Keep assessments inside a signed scope document and a lab you control.

Why does the app work but Burp history stays empty?

Three likely causes: the client is non-proxy-aware and never contacts Burp; the traffic is TLS-pinned, so handshakes fail after the CONNECT; or the app uses non-HTTP protocols Burp can’t decode. Check Burp’s Event log for TLS errors, and try TLS pass-through or a transparent proxy to isolate the cause.

How do defenders benefit from understanding this attack?

Assume every client-side control is inspectable. Certificate pinning and strict validation raise the bar against token theft and API tampering; server-side authorization on every endpoint—including the “hidden” ones—ensures discovery of undocumented APIs doesn’t translate into compromise; and signed, verified update channels close the most dangerous interception path.

HMMNM Security
Published by HMMNM Security

Hands-on cybersecurity tutorials, CVE breakdowns, and guided learning paths — written and lab-tested by the HMMNM Security team.

Keep going — the structured way
This post is one step. The learning paths chain the next ones for you, with progress tracking and no account needed.
Follow a learning path →

Check your understanding

1. Why is it useful to route a desktop app's traffic through Burp Suite even though it is not a web app?

2. You see CONNECT tunnel entries in Burp's HTTP history but no decrypted content. What does this indicate?

3. Why must NO_PROXY include localhost and 127.0.0.1 when setting proxy environment variables?

4. Why does intercepting HTTPS with Burp require installing Burp's CA certificate into the OS trust store?

Your answers stay in this browser only.

Prabhu Kalyan Samal

Application Security Consultant and founder of Hmmnm. Certified Red Team Operator, Burp Suite Certified Practitioner, eWPTX, CompTIA SecurityX and Azure Security Engineer. Writes hands-on labs and threat analysis on web, cloud and AI-agent security.