Why an HTTPS proxy does not see an app's traffic

The proxy is set up and the certificate is installed, yet the app's requests are missing or die in the TLS handshake. Six scenarios, with a network-level diagram of each and what it looks like in the proxy.

1. The app does not use the proxy at all and connects directly

The simplest case, and a very common one. The app either ignores the system proxy settings entirely, or uses its own HTTP client that reads the proxy only from environment variables or its own configuration.

Typical examples:

  • Flutter (often ignores the system proxy);
  • custom OkHttp / URLSession setups with special configurations;
  • apps that check for a specific variable (such as HTTP_PROXY on Linux) and refuse to work that way.

There is little to be done here, except, for custom setups, shipping special builds that work through an external proxy.

Sequence diagram: the app sends TCP SYN and TLS ClientHello straight to the server, and the proxy takes no part in the connection

At this point the proxy shows only other traffic (the browser, other apps), and the app you need is not in the list.

Solpuga filtered to httpbin.org lists one GET from Safari, while the Flutter demo app beside it got HTTP 200 without passing through the proxy

Only the request from Safari came through

2. The app uses the proxy but does not trust its certificate

The traffic reaches the proxy, but the TLS handshake fails because the app (or the system) does not trust the proxy's root certificate.

For every host name the proxy generates a leaf certificate on the fly and signs it with its own root certificate authority. The app accepts the substitute certificate only if the proxy's root certificate is in the trust store the app actually consults.

A device may have a system store and a separate user store. On Android 7+ apps trust only the system store by default, and on iOS the configuration profile must be marked as fully trusted; otherwise the certificate is installed but ignored.

In this case, try adding the root certificate to the system store, or allowing the app to use the user store, if that is possible.

Sequence diagram: after CONNECT the proxy answers ClientHello with a certificate signed by its own root CA, the app replies with an unknown ca alert, and the handshake breaks off

Safari in the iOS simulator warns that the connection is not private, and Solpuga lists a CONNECT to httpbin.org:443 with the TLS error “tls handshake eof”

A connection attempt appears and immediately ends with a TLS error

3. The TLS handshake starts, but SSL pinning aborts it before the connection is established

SSL pinning is common in apps that handle sensitive data. During the connection, after the usual certificate chain check, the app also checks the server's public key (or the whole certificate) against a value hard-coded into it (SPKI pin / certificate pin). The forged leaf certificate carries the proxy's public key, not the real server's. Even if the system fully trusts the proxy's root certificate authority, the check fails and the connection is never established.

Sequence diagram: the certificate chain check passes, the SHA-256 SPKI pin check fails, and the app sends the proxy a pin mismatch alert

In the interface it looks almost the same as the previous case: a short-lived request with a TLS error. The only differences are the error itself and the fact that the system trusts the certificate while the app does not.

An Android pinning demo: the normal request gets HTTP 200, the pinned one fails with SSLPeerUnverifiedException, and Solpuga shows “Client closed the connection” for its CONNECT

Two requests to the same URL: one went through, the other failed with an error

4. The app uses its own TLS stack or a separate certificate store

Some apps use neither the system TLS nor the system certificate store. They either:

  • use their own BoringSSL / OpenSSL / mbedTLS,
  • or have a built-in trust store,
  • or implement pinning inside their own stack.

For example, Firefox on Linux may need the root certificate imported separately, through its own settings, into its own store. Then even a correctly installed system root certificate does nothing for it.

Sequence diagram: the app’s own TLS stack checks the server certificate against its own CA store and pins, and the system trust store is not used

Requests may then go through partly or not at all. Here, for example, the certificate is installed, Curl and Lynx requests run fine, and Firefox balks:

Solpuga on Linux: requests from curl and lynx return 200, while the CONNECT from Firefox to httpbin.org:443 fails with “received fatal alert: BadCertificate”

It is the HTTPS request that failed

5. Different parts of the app use different network libraries and channels

A very common case in large apps. The main features go through one HTTP client (which respects the proxy), while analytics, push notifications, WebSockets, image loading and the payment SDK go through another network stack.

As a result, some requests are visible and some are not.

Diagram: the app’s main HTTP client goes through the proxy, the analytics SDK and image loading connect directly, and WebSocket uses its own stack

6. The app uses a protocol or transport the particular proxy does not support

Even if the app works through a proxy and does not use pinning, it may use a protocol that the particular proxy supports poorly or not at all.

HTTP/2 needs full support for the binary framing and synchronisation for stateful HPACK. Many proxies pass only HTTP/1.1 and lose some of the requests.

HTTP/3 / QUIC runs over UDP. Classic debugging proxies are almost always TCP-only. If the network allows UDP/443, the client sets up QUIC directly, bypassing the proxy.

Sequence diagram: the proxy listens only on TCP, the app completes a QUIC handshake with the server over UDP/443, and the proxy sees no traffic

In a TCP proxy that traffic is simply absent, or it turns into HTTP/1 if the origin supports several connection types (the alt-svc header):

Solpuga shows a Chrome request to quic.nginx.org over HTTP/1.1, and the raw response carries the header alt-svc: h3=":443"

The response is available over HTTP/3, but here we see HTTP/1.1

Conclusion

These are the most common ways apps bypass a proxy. The list is surely not complete; there are more exotic cases. That is why it matters to understand how the networking in the app under test is built, and why it is built that way. Missing traffic in the proxy is far from always a bug: sometimes it is the architecture, or a limit of the tool.

View in Solpuga

Related