Whether a certificate is valid is only one part of a server's TLS configuration. Two servers can both present perfectly valid certificates while negotiating very different connections underneath — one accepting only modern protocols with strong ciphers, the other still willing to fall back to a decade-old protocol version if a client asks for it. TLS Configuration checks that negotiation directly: which protocol versions a server accepts, what cipher suite it picks by default, and how the handshake itself behaves.
You can test any server's live negotiation using PacketFlo's TLS Configuration tool.
Protocol Versions
TLS has gone through several versions, and a server can usually be configured to accept more than one:
- TLS 1.3 — the current version. Faster 1-RTT handshake, and it removed the weak cipher options earlier versions allowed. A server that supports it and prefers it is in good shape.
- TLS 1.2 — still widely used and still considered secure when configured with modern ciphers. Most of the web runs on a mix of 1.3 and 1.2.
- TLS 1.1 and TLS 1.0 — formally deprecated since 2021 (RFC 8996). Browsers stopped supporting them years ago. A server that still accepts one of these isn't necessarily under active attack, but it's carrying configuration that serves no real client anymore and only widens what an attacker downgrading a connection could target.
A server rejecting TLS 1.1 or TLS 1.0 is the expected, healthy outcome — not a failure. The tool reports each protocol as supported, not supported, or, where the check itself couldn't be completed cleanly, unable to test — that third state exists specifically so an inconclusive result is never reported as a false pass or a false fail.
Cipher Suites and Negotiated Algorithms
Once a connection is open, the client and server agree on exactly one protocol version and one cipher suite for that session. The cipher suite is the standardized recipe of cryptographic algorithms governing key exchange, authentication, bulk encryption, and integrity checking.
PacketFlo connects the way a normal browser would (no forced version) and reports what the server actually chose, which is a more useful signal than the full list of what it's merely capable of.
Anatomy of a Cipher Suite: TLS 1.3 vs. TLS 1.2
Cipher suite naming changed fundamentally between TLS 1.2 and TLS 1.3. In TLS 1.2, a cipher suite name was a monolithic string specifying four distinct components:TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
- Key Exchange:
ECDHE(Elliptic Curve Diffie-Hellman Ephemeral for Forward Secrecy) - Authentication / Signature:
RSA(orECDSA) - Bulk Encryption:
AES_256_GCM - Message Authentication Code (MAC):
SHA384
In TLS 1.3 (RFC 8446), key exchange algorithms were separated entirely from the cipher suite definitions. Because TLS 1.3 strictly requires forward secrecy, it mandates ephemeral Diffie-Hellman out of the box. Consequently, a TLS 1.3 cipher suite only defines the AEAD encryption algorithm and the hash algorithm.
Deep Dive: TLS_AES_256_GCM_SHA384
TLS_AES_256_GCM_SHA384 is widely recognized as the premier standard for high-security web traffic, government compliance (including NSA Suite B and CNSA), and financial platforms. Here is what each building block provides:
1. AES-256 (256-bit Symmetric Key)
The Advanced Encryption Standard with a 256-bit key provides a keyspace of 2256 possible combinations. To put this in perspective, even if all supercomputers on Earth combined to test billions of keys per second, breaking an AES-256 session would take trillions of times longer than the age of the universe. It also provides an extra defensive buffer against quantum attacks using Grover's search algorithm (which halves the effective key length to 128 bits, still computationally intractable).
2. GCM (Galois/Counter Mode — Authenticated Encryption)
GCM is an AEAD (Authenticated Encryption with Associated Data) construction. Prior to AEAD, protocols used “MAC-then-Encrypt” (CBC mode with HMAC), which was vulnerable to subtle padding oracle and timing attacks such as BEAST, POODLE, and Lucky Thirteen. GCM computes authentication tags simultaneously with encryption using hardware-accelerated carry-less multiplication (CLMUL), making it both impervious to padding attacks and exceptionally fast.
3. SHA-384 (Secure Hash Algorithm)
SHA-384 produces a 384-bit message digest. In TLS 1.3, this hash function is used by the Pseudorandom Function (PRF) and HKDF (HMAC-based Extract-and-Expand Key Derivation Function) to derive session keys, verify handshake transcript integrity, and ensure that no intermediate party tampered with parameter exchanges.
The Five TLS 1.3 Cipher Suites
Unlike TLS 1.2, which accumulated hundreds of confusing and insecure cipher combinations (such as RC4, 3DES, and CBC-mode ciphers), TLS 1.3 eliminated all known insecure options, leaving only five streamlined AEAD suites:
| Cipher Suite | Security Level | Primary Use Case |
|---|---|---|
| TLS_AES_256_GCM_SHA384 | Ultra-High | Maximum security, banking, government, enterprise systems |
| TLS_AES_128_GCM_SHA256 | High (Standard) | Default for modern web; maximum CPU efficiency on AES-NI |
| TLS_CHACHA20_POLY1305_SHA256 | High | Mobile devices and CPUs without dedicated AES hardware |
| TLS_AES_128_CCM_SHA256 | High | Constrained IoT devices with hardware CCM engines |
| TLS_AES_128_CCM_8_SHA256 | High | Low-bandwidth embedded environments (short 8-byte auth tag) |
Deprecated & Insecure Ciphers to Disable
If your server supports legacy TLS 1.2 or older protocols, make sure you explicitly eliminate these dangerous algorithms:
- RC4: Completely broken stream cipher; prohibited by RFC 7465.
- 3DES (Triple-DES / DES-EDE3-CBC): Vulnerable to 64-bit block collision attacks (Sweet32).
- CBC Mode with SHA-1 (e.g. AES_128_CBC_SHA): Vulnerable to timing oracle attacks and SHA-1 collision vulnerabilities.
- Static RSA Key Exchange: Does not offer Perfect Forward Secrecy (PFS). If the server's private key is leaked in the future, past recorded traffic can be decrypted. Always require
ECDHE.
ALPN, HTTP/2, and SNI
- ALPN (Application-Layer Protocol Negotiation) is negotiated during the TLS handshake itself and determines whether the connection proceeds as HTTP/2 (
h2) or falls back to HTTP/1.1 — before a single HTTP request is sent. - SNI (Server Name Indication) lets a client tell the server which hostname it's requesting during the handshake, before the certificate is even selected. This is what allows one IP address to serve TLS certificates for many different domains. A server that requires SNI will fail the handshake entirely if it's omitted.
Connection Timing
Where it can be measured reliably, the tool reports TCP connection time separately from TLS handshake time — the handshake happens after the TCP connection is already open, and slow negotiation (an overloaded server, an unusually expensive cipher, a distant OCSP check) shows up specifically in that second number rather than the first. This is a measurement of that one connection at that one moment from PacketFlo's server, not a general latency benchmark.
Configuring Modern Ciphers on Web Servers
Nginx Configuration
To configure your Nginx server for modern security with TLS 1.3 and strong TLS 1.2 ciphers, add the following to your ssl.conf:
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers off;
# TLS 1.3 ciphers (OpenSSL 1.1.1+)
ssl_conf_command Ciphersuites TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256;
# TLS 1.2 ciphers
ssl_ciphers ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;Apache Configuration
SSLProtocol all -SSLv3 -TLSv1 -TLSv1.1
SSLCipherSuite ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256
SSLHonorCipherOrder offFrequently Asked Questions
What is a TLS cipher suite?
A cipher suite is a standardized set of cryptographic algorithms that clients and servers agree upon during the TLS handshake. It dictates how keys are exchanged, how bulk application data is encrypted, and how data integrity and authenticity are guaranteed.
Why does TLS_AES_256_GCM_SHA384 have no key exchange algorithm in its name?
In TLS 1.3, key exchange and digital signatures are separated from cipher suites. TLS 1.3 mandates ephemeral Diffie-Hellman (ECDHE or DHE) for all handshakes, so cipher suites only need to specify the symmetric encryption algorithm, block cipher mode (AEAD), and the cryptographic hash function.
Is TLS_AES_256_GCM_SHA384 better than TLS_AES_128_GCM_SHA256?
Both are exceptionally secure and unbreakable with modern computing. AES-256 uses a 256-bit key (offering greater theoretical margin against quantum computing via Grover's algorithm), while AES-128 is slightly faster on CPUs without dedicated AES-NI hardware acceleration. Most high-security environments prefer TLS_AES_256_GCM_SHA384.
What is AEAD (Authenticated Encryption with Associated Data)?
AEAD modes like Galois/Counter Mode (GCM) combine encryption and message authentication into a single simultaneous mathematical operation. Unlike legacy MAC-then-Encrypt constructions, AEAD is immune to padding oracle and timing attacks like Lucky Thirteen.
My server doesn't support TLS 1.0 or 1.1 — is that a problem?
No — that's the expected, secure configuration. Both were formally deprecated in 2021 (RFC 8996) and no current browser will use them anyway. Not supporting them is correct, not a gap.
What does 'unable to test' mean for a protocol?
It means the check couldn't reach a clean conclusion — for example, the testing server's own TLS stack may not be able to attempt that specific old protocol version at all, independent of whatever the target server would have done. That's reported honestly as inconclusive rather than guessed at as a pass or fail.
How is this different from the SSL Certificate Checker?
The SSL Certificate Checker answers whether the certificate itself is valid — issuer, expiry, hostname coverage. This tool answers a different question: what the server's actual TLS negotiation looks like, including protocol versions accepted, the cipher and ALPN it picks, SNI behavior, and handshake timing.
Why does SNI matter?
Most hosting today puts many HTTPS domains behind one IP address, and SNI is what lets the server know which certificate to present before the handshake completes. A server that requires SNI and doesn't get it will fail the connection outright — which is normal, not a misconfiguration.