# TLS cipher suites in 2026: what to enable and what WebSec0 flags

> Which TLS cipher suites to enable in 2026: ECDHE with AES-GCM or ChaCha20 on TLS 1.2, TLS 1.3 as is. What WebSec0 flags, and tested configs for four servers.

Author: Joshua Martinelle, Security engineer at Tenable (https://www.websec0.com/guides/authors/joshua-martinelle/)
Canonical: https://www.websec0.com/guides/tls-ciphers/
Updated: 2026-11-20
Tested on: nginx 1.28 to 1.31, Apache httpd 2.4.58 to 2.4.69, Caddy 2.9 to 2.11 and Traefik 2.11 to 3.7

## In short

- On TLS 1.2, enable only the six ECDHE suites with AES-GCM or ChaCha20-Poly1305. Leave the TLS 1.3 suites at their defaults.
- Nginx and Apache defaults with an RSA certificate offer static RSA and CBC suites: WebSec0 lists 6 of them as weak. Caddy's defaults are already clean, and Traefik's add two CBC suites.
- WebSec0 caps the TLS grade at F for an RC4 suite, and at C for a 3DES suite or when no suite has forward secrecy.
- WebSec0 only tests the suites Go's crypto/tls implements, one handshake per suite. DHE, CCM, ARIA and Camellia suites never appear in the report.
- 128-bit suites score 80 and 256-bit suites 100 in the cipher score. AES-128 is not weak: keep it, even though TLS 1.3 negotiates it and holds that score at 90.

## Which TLS cipher suites should you enable?

On TLS 1.2, enable only the six suites that combine **ECDHE key exchange with
AES-GCM or ChaCha20-Poly1305**. They all have forward secrecy and
authenticated encryption. Leave TLS 1.3 at its defaults: its three suites are
all safe.

| OpenSSL name (Nginx, Apache) | IANA name (Caddy, Traefik) |
| --- | --- |
| `ECDHE-ECDSA-AES128-GCM-SHA256` | `TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256` |
| `ECDHE-RSA-AES128-GCM-SHA256` | `TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256` |
| `ECDHE-ECDSA-AES256-GCM-SHA384` | `TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384` |
| `ECDHE-RSA-AES256-GCM-SHA384` | `TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384` |
| `ECDHE-ECDSA-CHACHA20-POLY1305` | `TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256` |
| `ECDHE-RSA-CHACHA20-POLY1305` | `TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256` |

This is the TLS 1.2 list of Mozilla's intermediate configuration, and it
includes the four suites that [RFC 9325](https://www.rfc-editor.org/rfc/rfc9325.html#section-4.2)
recommends. A server only uses the ECDSA suites with an ECDSA certificate and
the RSA suites with an RSA certificate, so listing both is safe.

## What does a cipher suite name mean?

A TLS 1.2 suite name lists four choices. In
`TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256`, ECDHE is the key exchange, RSA the
type of certificate signature, AES-128 in GCM mode the cipher, and SHA-256 the
hash used to derive keys.

Two parts decide whether a suite is still acceptable:

- **Key exchange.** With ECDHE, each connection uses a fresh key. Someone who
  records your traffic and steals the private key later still cannot decrypt
  it: that is forward secrecy. With static RSA key exchange (`TLS_RSA_WITH_*`),
  the stolen key decrypts every recorded session. RFC 9325 says servers
  should not negotiate those suites.
- **Cipher mode.** GCM and ChaCha20-Poly1305 are AEAD modes: they encrypt and
  authenticate in one step. CBC suites (`_CBC_`) depend on a separate MAC and
  are the source of the Lucky13 family of timing attacks. RFC 9325 says not to
  use them unless the encrypt-then-MAC extension is negotiated.

TLS 1.3 names are shorter, such as `TLS_AES_128_GCM_SHA256`, because the key
exchange is always ephemeral and every cipher is AEAD.

## How WebSec0 grades cipher suites

WebSec0 uses Go's crypto/tls. For each TLS version from 1.0 to 1.2 the server
offers, it opens one handshake per suite that Go implements, and records the
suites the server accepts. For TLS 1.3, Go cannot choose suites, so WebSec0
records the one suite the server negotiates.

Go implements 25 suites. WebSec0 labels each one:

| Label | Suites |
| --- | --- |
| Good | ECDHE with AES-GCM or ChaCha20-Poly1305, and the TLS 1.3 suites |
| Warning | ECDHE with AES-CBC and SHA-1 (`_CBC_SHA`) |
| Weak | Every suite Go lists as insecure: static RSA (`TLS_RSA_WITH_*`), CBC with SHA-256, 3DES and RC4 |

Suites that Go does not implement never appear in the report: DHE, AES-CCM,
ARIA, Camellia and the ECDHE CBC suites with SHA-384. With an RSA certificate,
the default Nginx list on OpenSSL 3.5 accepted 25 TLS 1.2 suites in our test;
WebSec0 tested and listed 11 of them.

Three rules can cap the TLS grade, whatever the score:

| Offered | TLS grade cap |
| --- | --- |
| An RC4 suite | F |
| A 3DES suite | C |
| No suite with forward secrecy | C |

The code also caps anonymous and export suites at F, but Go implements none of
them, so WebSec0 cannot detect them. TLS 1.3 suites always count as forward
secret, so a server that offers TLS 1.3 never gets the last cap. Protocol
versions and the certificate chain have caps of their own: the chain one is
covered in [how to fix an incomplete certificate chain](/guides/certificate-chain/). The report also shows "RSA key-exchange ciphers
offered" and "Legacy CBC modes on TLS 1.2" as warnings, a red "weak ciphers
offered" line, and vulnerability rows for Sweet32 (3DES), RC4 and Lucky13 (CBC
on TLS 1.0 or 1.1).

Two parts of the TLS score depend on the suites. The key-exchange score is 90
when at least one suite has forward secrecy. The cipher score averages the
best and the worst suite: 128-bit suites score 80, 256-bit suites and
ChaCha20 score 100.

## What each server offers by default

We probed each server's defaults the way WebSec0 does, with an RSA
certificate and no cipher setting:

| Server | TLS 1.2 suites seen | Weak | CBC |
| --- | --- | --- | --- |
| Nginx 1.28 to 1.31 | 11 | 6 | 6 |
| Apache 2.4.58 to 2.4.69 | 11 | 6 | 6 |
| Caddy 2.9 to 2.11 | 3 | 0 | 0 |
| Traefik 2.11 to 3.7 | 5 | 0 | 2 |

With an ECDSA certificate, the static RSA suites disappear: Nginx and Apache
then offer 6 suites, one of them weak (`TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256`).
None of the defaults triggers a grade cap; the warnings are what you fix.

## Configure it on your server

### Nginx

Set the list once in the `http` block, next to `ssl_protocols`, and delete any
other `ssl_ciphers` line:

```nginx
# /etc/nginx/nginx.conf, inside the http { } block
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305;
ssl_prefer_server_ciphers off;
```

`ssl_ciphers` only covers TLS 1.2 and older; TLS 1.3 keeps the OpenSSL
defaults. To find every line that sets ciphers, run
`sudo nginx -T 2>/dev/null | grep -n ssl_ciphers`. Disabling old protocol
versions is covered in [how to disable TLS 1.0 and 1.1 on Nginx](/guides/tls-versions/nginx/).

### Apache

Put the directives in the server configuration, outside any
`<VirtualHost>`. On Debian and Ubuntu, replace the `SSLCipherSuite HIGH:!aNULL`
and `SSLProtocol` lines in `/etc/apache2/mods-available/ssl.conf`:

```apache
SSLProtocol -all +TLSv1.2 +TLSv1.3
SSLCipherSuite ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305
SSLHonorCipherOrder off
```

An `SSLCipherSuite` line inside a `<VirtualHost>` replaces the global one for
that site, so search for all of them with
`grep -rn SSLCipherSuite /etc/apache2 /etc/httpd 2>/dev/null`. Without a
protocol argument, `SSLCipherSuite` does not change the TLS 1.3 suites.

### Caddy

Caddy's defaults are already the recommended list: three suites on TLS 1.2
with an RSA certificate, all ECDHE with GCM or ChaCha20, in every version we
tested. Leave them. If a site block has a `ciphers` line under `tls`, remove
it unless you need it for a specific client. The
[Caddy documentation](https://caddyserver.com/docs/caddyfile/directives/tls)
advises against changing them.

### Traefik

Traefik uses Go's default list, which includes two ECDHE CBC suites. Set the
list in the `default` TLS options of the dynamic configuration, which every
router without its own `tls.options` uses:

```yaml
tls:
  options:
    default:
      minVersion: VersionTLS12
      cipherSuites:
        - TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
        - TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
        - TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
        - TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
        - TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
        - TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
```

A router that points to another TLS option, such as `tls.options: modern@file`,
uses that option's list instead. Repeat the `cipherSuites` there.

## Should you drop AES-128 for a higher score?

No. With the recommended list, WebSec0's cipher score is 90: the 256-bit
suites score 100 and the 128-bit ones 80. TLS 1.3 also negotiates
`TLS_AES_128_GCM_SHA256` with WebSec0's client on every server we tested,
so the score stays at 90 even with 256-bit suites only on TLS 1.2.

With an ECDSA certificate, TLS 1.2 and 1.3 and the recommended list, our test
servers scored 94, an A. With an RSA certificate, they scored 88, also an A.
An A+ starts at 95. Reaching it would mean removing every 128-bit suite, TLS
1.3's included, which is not possible on Caddy and Traefik. It would also drop
`TLS_AES_128_GCM_SHA256`, the one suite that [RFC 8446](https://www.rfc-editor.org/rfc/rfc8446.html#section-9.1)
requires every TLS 1.3 implementation to support. A clean report with every
suite labelled good matters more than those points.

## Check the result

Reload the server, then list the TLS 1.2 suites it accepts. This loop tries
every suite your OpenSSL knows, one handshake each, and prints the accepted
ones. Run it on a machine with OpenSSL 3 and replace `example.com` with your
host:

```sh
for c in $(openssl ciphers 'ALL:@SECLEVEL=0' | tr ':' ' '); do
  openssl s_client -connect example.com:443 -servername example.com -tls1_2 -cipher "$c:@SECLEVEL=0" </dev/null >/dev/null 2>&1 && echo "$c"
done
```

With the recommended list and an RSA certificate, it prints three suites:

```text
ECDHE-RSA-AES256-GCM-SHA384
ECDHE-RSA-CHACHA20-POLY1305
ECDHE-RSA-AES128-GCM-SHA256
```

In the WebSec0 report, the "Cipher suites" tab should then show only suites
labelled AEAD and PFS, and the highlights "All offered ciphers provide forward
secrecy" with no CBC or weak cipher warning.

## Frequently asked questions

### Which cipher suites should I use in 2026?

For TLS 1.2: ECDHE-ECDSA and ECDHE-RSA with AES-128-GCM, AES-256-GCM or ChaCha20-Poly1305, six suites in all. For TLS 1.3, keep the defaults: all of its suites use ephemeral key exchange and AEAD.

### Do I need to configure TLS 1.3 cipher suites?

No. The three TLS 1.3 suites, `TLS_AES_128_GCM_SHA256`, `TLS_AES_256_GCM_SHA384` and `TLS_CHACHA20_POLY1305_SHA256`, are all safe. Caddy and Traefik cannot change them, because Go's crypto/tls does not allow it.

### Why does WebSec0 say my server offers weak ciphers?

It labels every suite that Go lists as insecure as weak: static RSA key exchange (`TLS_RSA_WITH_*`), CBC with SHA-256, 3DES and RC4. With an RSA certificate, the default Nginx and Apache lists offer five static RSA suites and `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256`.

### Is AES-128 weak?

No. RFC 9325 expects 128-bit ciphers to remain secure for at least several years, and TLS 1.3 makes `TLS_AES_128_GCM_SHA256` mandatory to implement. WebSec0's cipher score rates 128-bit suites at 80 and 256-bit suites at 100, which costs a few points but no grade cap.

### Should I enable DHE cipher suites?

No. RFC 9325 says TLS 1.2 implementations should not negotiate `TLS_DHE_*` suites, because of the known fragility of finite-field Diffie-Hellman. WebSec0 cannot see them either: Go does not implement DHE.

### Does cipher order still matter?

Little, once every suite you offer is strong. Mozilla's configuration lets the client choose (`ssl_prefer_server_ciphers off` on Nginx, `SSLHonorCipherOrder off` on Apache). Go-based servers such as Caddy and Traefik have no such setting: Go chooses from the client's hardware and its own preferences.

## Sources

- [RFC 9325: Recommendations for Secure Use of TLS and DTLS](https://www.rfc-editor.org/rfc/rfc9325.html), IETF
- [RFC 8446: The Transport Layer Security (TLS) Protocol Version 1.3, section 9.1](https://www.rfc-editor.org/rfc/rfc8446.html#section-9.1), IETF
- [Mozilla SSL Configuration Generator](https://ssl-config.mozilla.org/), Mozilla
- [Package crypto/tls: CipherSuites and InsecureCipherSuites](https://pkg.go.dev/crypto/tls), The Go Authors
- [Module ngx_http_ssl_module: ssl_ciphers](https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_ciphers), nginx.org
- [Apache Module mod_ssl: SSLCipherSuite](https://httpd.apache.org/docs/2.4/mod/mod_ssl.html#sslciphersuite), The Apache Software Foundation
- [Caddyfile directive: tls](https://caddyserver.com/docs/caddyfile/directives/tls), Caddy
- [Traefik TLS options](https://doc.traefik.io/traefik/reference/routing-configuration/http/tls/tls-options/), Traefik Labs
