SSL/TLS Inspection Design: Certificates, Exceptions and Risks

What should be planned before turning on TLS inspection? The difference between certificate and deep inspection, internal CA distribution, technical and legal exceptions, and the product-dependent effect of TLS 1.3, ECH and QUIC.
Technical summary
Technology
TLS 1.2, TLS 1.3, QUIC, ECH, PKI, NGFW, Web Proxy
Topic
Designing the inspection of encrypted traffic on a firewall or proxy
Level
Intermediate–advanced
Prerequisites
  • Basic knowledge of the enterprise PKI (AD CS or equivalent)
  • Endpoint management with GPO or MDM
  • Familiarity with the NGFW policy structure
In this article8 sections

In traffic that isn’t decrypted, the NGFW’s IPS, antivirus, DLP and URL filtering engines see only the outer shell of the connection; a malicious file arrives inside HTTPS and passes without hitting any signature. SSL/TLS inspection restores this visibility. When it’s set up wrong, though, it breaks applications, creates privacy problems and turns the firewall into a bottleneck. The guide below is written for security and network teams who will make decisions on the scope of inspection, internal CA distribution, exception policy and phased rollout.

Why, and to what extent, to inspect encrypted traffic

Malware downloads, phishing pages and command-and-control (C2) connections mostly come over HTTPS. Without decryption, IPS signatures can’t look at the HTTP body, the antivirus engine can’t look at the downloaded file and DLP can’t look at uploaded content. On the other hand, from an enterprise cybersecurity perspective, decrypting every connection is neither mandatory nor wise. The question to ask is: which control should run on which traffic group?

Match controls on risk and return:

  • User-to-internet web traffic: file downloads, uncategorized or newly registered domains and file sharing services give the highest return.
  • Egress from servers to the internet: the destinations a server goes to should already be limited. Here, a destination-based allowlist is often more effective than inspection.
  • Services published from inside (inbound): incoming traffic can be inspected by loading the server’s own certificate and private key onto the firewall. This is a different model from outbound inspection, and key management needs to be planned separately. With TLS 1.3 and cipher suites that provide forward secrecy (PFS), knowing the key isn’t enough for passive decryption; the firewall must take an active role in the middle of the connection. Verify this support in the device documentation.

The difference between certificate inspection and deep inspection

Although vendors use different names, there are two basic modes. In certificate inspection, the firewall doesn’t decrypt the connection; it decides by reading the SNI field in the ClientHello and, in TLS 1.2, the server certificate sent in the clear. In deep (full) inspection, the firewall gets between the client and the server: it connects to the server itself, validates the server certificate and presents the client with a certificate re-signed by the organization’s internal CA.

Feature Certificate inspection Deep inspection
Is traffic decrypted? No Yes
Information visible SNI, the certificate (in TLS 1.2) URL path, headers, body, files
CA requirement on the endpoint None The internal CA must be trusted
Risk of breaking applications Low High with pinning and mTLS
Resource consumption Low High
Suitable use Category/domain filtering IPS, antivirus, DLP, sandbox

Deep inspection has an often-overlooked responsibility: the firewall is now the validator of the server certificate. If the firewall turns an expired, self-signed or name-mismatched certificate into a valid certificate with its own CA, the user never sees the browser warning. This is the common misconfiguration. Set the “untrusted server certificate” behavior in the profile to block or to present the user with an untrusted certificate; don’t silently allow it. Likewise, don’t let the firewall fall back to weak versions such as SSLv3, TLS 1.0 and 1.1 on the server side.

Distributing the internal CA certificate to endpoints

The CA used for re-signing shouldn’t be the root CA of the enterprise PKI. The right structure is: create a subordinate CA under the root CA only for TLS inspection, keep its private key on the firewall (in an HSM or protected store if supported), and make sure the root CA is trusted on endpoints. If the firewall is compromised, only this subordinate CA is revoked. The root stays in place.

Most calls about TLS errors during the pilot come from a store the CA didn’t reach. The points most often forgotten in distribution:

  • Windows: the trusted root and intermediate CA stores under Computer Configuration > Policies > Windows Settings > Security Settings > Public Key Policies in GPO; a trusted certificate profile in Intune.
  • macOS and mobile devices: an MDM certificate payload. On iOS and Android, apps may not trust CAs installed by the user.
  • Firefox: uses its own certificate store; the ImportEnterpriseRoots setting in enterprise policy or the security.enterprise_roots.enabled preference makes it trust the operating system store.
  • Developer tools and runtimes: Java (the cacerts store), Python requests (REQUESTS_CA_BUNDLE), Node.js (NODE_EXTRA_CA_CERTS), Git (http.sslCAInfo) and container images may not use the operating system store.
  • Linux servers and clients: update-ca-certificates on Debian/Ubuntu, update-ca-trust on the RHEL family.
# Debian/Ubuntu: add the corporate root CA to the system store
sudo cp corp-root-ca.crt /usr/local/share/ca-certificates/
sudo update-ca-certificates

# RHEL/Rocky/Alma
sudo cp corp-root-ca.crt /etc/pki/ca-trust/source/anchors/
sudo update-ca-trust

# For a Java application (the keystore path varies by version)
keytool -importcert -alias corp-root-ca -file corp-root-ca.crt \
  -keystore "$JAVA_HOME/lib/security/cacerts" -storepass changeit

changeit in the Java example is the default store password; adapt it if it was changed in your organization. When the Java version is updated, cacerts may be replaced with the new one. The CA you added goes with it.

Exception categories: banking, health and applications that use pinning

The exception list has two justifications: technical and legal. Technical exceptions cover traffic where inspection doesn’t work:

  • Certificate pinning: the application accepts only a specific certificate or public key and rejects a re-signed certificate. Some mobile apps, security agents and update clients behave this way.
  • Mutual TLS (mTLS): in services where the client authenticates with its certificate, the firewall doesn’t have the client’s private key; it can’t continue the connection.
  • Operating system and security product updates: trusted and high-volume. The return on decrypting them is low and the cost high.

Privacy exceptions cover categories where employees access special-category personal data such as health (KVKK Art. 6) or sensitive financial information such as personal banking. Because decrypted traffic will contain personal data, the purpose, scope and log retention period of the inspection should be defined in the privacy notice and internal policies. Don’t expand the scope without the approval of legal and the KVKK officer.

The effect of TLS 1.3, ECH and QUIC on inspection

TLS 1.3 (RFC 8446) changes the design in three ways. First, the server certificate is sent encrypted in the handshake; certificate inspection in practice comes down to the SNI. Second, static RSA key exchange was removed; decrypting traffic by giving the server key to a passive device is no longer possible, and inspection can only be done by getting in the middle of the connection. Third, the firewall sets up two separate TLS sessions with the client and the server; if the device doesn’t support TLS 1.3 on one side, it may downgrade the connection to TLS 1.2 or skip inspection. This silently lowers the security level. Explicitly define the lowest allowed version in the profile and verify in the release notes that the device fully supports TLS 1.3 in deep inspection.

Encrypted Client Hello (ECH) encrypts the sensitive part of the ClientHello, including the SNI. Because the browser gets the ECH configuration from the DNS HTTPS record, controlling corporate DNS and DoH use directly determines how ECH behaves on your network; this topic is covered separately in the enterprise DNS filtering guide. On managed browsers, ECH can be disabled by enterprise policy (for example EncryptedClientHelloEnabled in Chrome).

QUIC (RFC 9000) runs over UDP 443 and embeds TLS 1.3 inside the protocol. Deep inspection of QUIC varies by product and version; many devices can’t decrypt QUIC. The common practice is to block outbound UDP 443 and make the browser fall back to TLS over TCP; on managed Chrome, the QuicAllowed policy can also be used. If your device recognizes QUIC and offers a blocking or inspection option, follow the vendor’s recommendation. If UDP 443 is left open, most of your inspection policy runs for nothing.

Performance and capacity planning

Deep inspection means two separate TLS handshakes, certificate generation and symmetric encryption/decryption for every connection. That’s why vendor datasheets give “firewall throughput” and “SSL inspection throughput” separately, and the second is noticeably lower. In the capacity calculation, look at:

  • What’s decisive isn’t total bandwidth but the traffic to be decrypted and the number of new TLS sessions per second.
  • IPS, antivirus and sandbox profiles enabled together with inspection increase the load. Check which profile combination the datasheet value was measured with.
  • Exceptions such as updates, video streaming and large cloud backups reduce the load significantly. The exception policy is also a performance tool.
  • During the pilot, monitor peak-hour values for CPU, memory, the session table and SSL processing queues.

We collected the criteria for the device selection stage in the enterprise firewall selection guide. The real point here is testing the selected device with your own traffic mix. A datasheet is a lab measurement.

Phased rollout and verification

  1. Inventory and goal: put in writing which user groups and which controls inspection will be done for, the exception categories and the log retention rule.
  2. PKI preparation: create the inspection subordinate CA, distribute the root CA to endpoints and report the distribution rate. Don’t apply deep inspection to a device without the CA.
  3. Start with certificate inspection: enable SNI-based category filtering for all users. This stage requires no changes on the endpoint.
  4. IT pilot group: apply deep inspection to the IT team first; build the technical exception list from TLS error logs and user feedback.
  5. Department-by-department expansion: record new exceptions in each wave, and start IPS and antivirus profiles in monitoring mode on decrypted traffic (details in the IPS policy tuning guide).
  6. Regular review: review exceptions and untrusted certificate blocks every quarter.

The first place to look in verification is the CA that issued the certificate the client sees. For an inspected site the issuer field should show the inspection CA, and for a site on the exception list, the real public CA:

openssl s_client -connect www.example.com:443 -servername www.example.com </dev/null 2>/dev/null \
  | openssl x509 -noout -issuer -subject -dates

Check with PowerShell that the root CA is really installed on Windows endpoints:

Get-ChildItem Cert:\LocalMachine\Root | Where-Object { $_.Subject -like "*Corp Root CA*" } |
  Select-Object Subject, Thumbprint, NotAfter

Finally, connect to a test site that is deliberately expired or has a name mismatch; check that the firewall blocks this connection or presents the browser with an untrusted certificate. This test catches the most dangerous misconfiguration of deep inspection. It takes five minutes. To shape the policy and profile structure for your organization, we handle these decisions together in firewall installation and rule management and network security and segmentation work.

Frequently asked questions

Is the certificate the firewall generates itself enough for SSL inspection?

It’s enough for a pilot. In production, use a subordinate CA from the enterprise PKI dedicated to this purpose. The certificate’s lifetime, revocation and renewal stay in the organization’s hands, and the root CA key is never moved to the firewall.

Is certificate inspection still useful with TLS 1.3?

Partly. In TLS 1.3, the server certificate is sent encrypted; certificate inspection in practice comes down to the SNI field. Domain and category-based blocking works, but visibility decreases on connections using ECH, since the SNI can also be hidden.

Does blocking QUIC traffic affect users?

Usually it goes unnoticed. When UDP 443 is closed, the browser connects to the same site with TLS over TCP. Still, test corporate applications that use QUIC or UDP, such as video conferencing, with a pilot group; define destination-based exceptions if needed.

Which traffic should never be decrypted?

Defining exceptions for categories where special-category data under KVKK is processed, such as health; sensitive financial services such as personal banking; applications that use certificate pinning; services that use mutual authentication with a client certificate; and operating system update channels is a common and defensible approach. A technical exception list doesn’t replace a legal compliance assessment; approve the list together with legal and the KVKK officer.

Support

Contact us for support or a discovery session on this topic.

Contact form
[email protected]

Eretek Cybersecurity

Firewall, VPN, endpoint security and threat prevention. We reduce the attack surface and measure and report the risks.

Knowledge Center

Other articles