Cipher Suite Practices and Pitfalls
It seems like every time you turn around there is a new vulnerability to deal with, and some of them, such as Sweet32, have required altering cipher configurations for mitigation. Still other users may tweak their cipher suite settings to meet requirements for PCI compliance, regulatory issues, local compatibility needs, etc.
However, once you start modifying your cipher suite settings you must take great care, as it is very easy to shoot yourself in the foot. Many misconfigurations will silently fail – seeming to achieve the intended result while opening up new, even worse, vulnerabilities. Let's take a look at cipher configuration on the F5 BIG-IP products to try stay on the safe path.
What is a Cipher Suite?
Before we talk about how they're configured, let's define exactly what we mean by 'cipher suite', how it differs from just a 'cipher', and the components of the suite.
Wikipedia had a good summary, so rather than reinvent the wheel:
A cipher suite is a named combination of authentication, encryption, message authentication code (MAC) and key exchange algorithms used to negotiate the security settings for a network connection using the Transport Layer Security (TLS) / Secure Sockets Layer (SSL) network protocol.
When we talk about configuring ciphers on BIG-IP we're really talking about configuring cipher suites. More specifically the configured list of cipher suites is a menu of options available to be negotiated. Each cipher suite specifies the key exchange algorithm, authentication algorithm, cipher, cipher mode, and MAC that will be used.
I recommend reading K15194: Overview of the BIG-IP SSL/TLS cipher suite for more information. But as a quick overview, let's look at a couple of example cipher suites.
As an overview, the cipher suite is in the format:
Key Exchange-Authentication-Cipher-Cipher Mode-MAC
Note that not all of these components may be explicitly present in the cipher suite, but they are still implicitly part of the suite.
Let's consider this cipher suite:
ECDHE-RSA-AES256-GCM-SHA384
This breaks down as follows:
Key Exchange Algorithm: ECDHE (Elliptic Curve Diffie-Hellman Ephemeral)
Authentication Algorithm: RSA
Cipher: AES256 (aka AES with a 256-bit key)
Cipher Mode: GCM (Galois/Counter Mode)
MAC: SHA384 (aka SHA-2 (Secure Hash Algorithm 2) with 384-bit hash)
This is arguably the strongest cipher suite we have on BIG-IP at this time. Let's compare that to a simpler cipher suite:
AES128-SHA
Key Exchange Algorithm: RSA (Implied) – When it isn't specified, presume RSA.
Authentication Algorithm: RSA (Implied) – When it isn't specified, presume RSA.
Cipher: AES128 (aka AES with a 128-bit key)
Cipher Mode: CBC (Cipher Block Chaining) (Implied) – When it isn't specified, presume CBC.
MAC: SHA1 (Secure Hash Algorithm 1; SHA-1 always produces a 160-bit hash.)
This example illustrates that the cipher suite may not always explicitly specify every parameter, but they're still there. There are 'default' values that are fairly safe to presume when not otherwise specified. If an algorithm isn't specified, it is RSA. That's a safe bet. And if a cipher mode isn't specified it is CBC. Always CBC.
Note that all ciphers currently supported on BIG-IP are CBC mode except for AES-GCM and RC4. ALL. I stress this as it has been a recurring source of confusion in amongst customers. It isn't only cipher suites which explicitly state 'CBC' in their name.
Let's examine each of these components. This article is primarily about cipher suite configuration and ciphers, and not the SSL/TLS protocol, so I won't dive too deeply here, but I think it helps to have a basic understanding. Forgive me if I simplify a bit.
Key Exchange Algorithms
As a quick review of the difference between asymmetric key (aka public key) cryptography and symmetric key cryptography:
With the asymmetric key you have two keys – Kpublic and Kprivate. Since you can openly share the public key there is no need to pre-share keys with anyone. The downside is that these algorithms are computationally expensive. Key lengths for a common algorithm such as RSA are at least 1024-bit, and 2048-bit is really the minimally acceptable these days.
Symmetric key has only Kprivate. Both ends use the same key, which poses the problem of key distribution. The advantage is higher computational performance and common key sizes are 128-bit or 256-bit.
SSL/TLS, of course, uses both public and private key systems – the Key Exchange Algorithm is the public key system used to exchange the symmetric key. Examples you'll see in cipher suites include ECDHE, DHE, RSA, ECDH, and ADH.
Authentication Algorithms
This is sometimes grouped in with the Key Exchange Algorithm for configuration purposes; 'ECDHE_RSA' for example. But we'll consider it as a separate component.
This is the algorithm used in the SSL/TLS handshake for the server to sign (using the server's private key) elements sent to the client in the negotiation. The client can authenticate them using the server's public key.
Examples include: RSA, ECDSA, DSS (aka DSA), and Anonymous.
Anonymous means no authentication; this is generally bad. The most common way users run into this is by accidentally enabling an 'ADH' cipher suite. More on this later when we talk about pitfalls.
Note that when RSA is used for the key exchange, authentication is inherent to the scheme so there really isn't a separate authentication step. However, most tools will list it out for completeness.
Cipher
To borrow once again from Wikipedia:
In cryptography, a cipher (or cypher) is an algorithm for performing encryption or decryption—a series of well-defined steps that can be followed as a procedure. An alternative, less common term is encipherment. To encipher or encode is to convert information into cipher or code. In common parlance, 'cipher' is synonymous with 'code', as they are both a set of steps that encrypt a message; however, the concepts are distinct in cryptography, especially classical cryptography.
This is what most of us mean when we refer to 'configuring ciphers'. We're primarily interested in controlling the cipher used to protect our information through encryption. There are many, many examples of ciphers which you may be familiar with: DES (Data Encryption Standard), 3DES (Triple DES), AES (Advanced Encryption Standard), RC4 (Rivest Cipher 4), Camellia, RC6, RC2, Blowfish, Twofish, IDEA, SEED, GOST, Rijndael, Serpent, MARS, etc.
For a little cipher humor, I recommend RFC2410: The NULL Encryption Algorithm and Its Use With IPsec.
Roughly speaking, ciphers come in two types – block ciphers and stream ciphers.
Block Ciphers
Block ciphers operate on fixed-length chunks of data, or blocks. For example, DES operates on 64-bit blocks while AES operates on 128-bit blocks. Most of the ciphers you'll encounter are block ciphers.
Examples: DES, 3DES, AES, Blowfish, Twofish, etc.
Stream Ciphers
Stream ciphers mathematically operate on each bit in the data flow individually. The most commonly encountered stream cipher is RC4, and that's deprecated. So we're generally focused on block ciphers, not that it really changes anything for the purposes of this article.
All of the secrecy in encryption comes from the key that is used, not the cipher itself. Obtain the key and you can unlock the ciphertext. The cipher itself – the algorithm, source code, etc. – not only can be, but should be, openly available. History is full of examples of private cryptosystems failing due to weaknesses missed by their creators, while the most trusted ciphers were created via open processes (AES for example).
Keys are of varying lengths and, generally speaking, the longer the key the more secure the encryption. DES only had 56-bits of key data, and thus is considered insecure. We label 3DES as 168-bit, but it is really only equivalent to 112-bit strength. (More on this later.) Newer ciphers, such as AES, often offer options – 128-bits, 192-bits, or 256-bits of key.
Remember, a 256-bit key is far more than twice as strong as a 128-bit key. It is 2128 vs. 2256 - 3.4028237e+38 vs. 1.1579209e+77
Cipher Mode
Cipher mode is the mode of operation used by they cipher when encrypting plaintext into ciphertext, or decrypting ciphertext into plaintext. The most common mode is CBC – Cipher Block Chaining. In cipher block chaining the ciphertext from block n feeds into the process for block n+1 – the blocks are chained together.
To steal borrow an image from Wikipedia:
As I mentioned previously, all ciphers on BIG-IP are CBC mode except for RC4 (the lone stream cipher, disabled by default starting in 11.6.0) and AES-GCM. AES-GCM was first introduced in 11.5.0, and it is only available for TLSv1.2 connections.
GCM stands for Galois/Counter Mode, a more advanced mode of operation than CBC. In GCM the blocks are not chained together. GCM runs in an Authenticated Encryption with Associated Data (AEAD) mode which eliminates the separate per-message hashing step, therefore it can achieve much higher performance on a given HW platform than CBC. It is also immune to classes of attack that have harried CBC, such as numerous padding attacks (BEAST, Lucky 13, etc.)
Via Wikipedia:
The main drawback to AES-GCM is that it was only added in TLSv1.2, so any older clients which don't support TLSv1.2 cannot use it.
There are other cipher suites officially supported in TLS which have other modes, but F5 does not currently support those ciphers so we won't get too deep into that. Other ciphers include AES-CCM (CTR mode with a CBC MAC; CTR is Counter Mode), CAMELLIA-GCM (CAMELLIA as introduced in 12.0.0 is CBC), and GOST CNT (aka CTR). We may see these in the future.
MAC aka Hash Function
What did we ever do before Wikipedia?
A hash function is any function that can be used to map data of arbitrary size to data of fixed size. The values returned by a hash function are called hash values, hash codes, digests, or simply hashes. One use is a data structure called a hash table, widely used in computer software for rapid data lookup. Hash functions accelerate table or database lookup by detecting duplicated records in a large file. An example is finding similar stretches in DNA sequences. They are also useful in cryptography. A cryptographic hash function allows one to easily verify that some input data maps to a given hash value, but if the input data is unknown, it is deliberately difficult to reconstruct it (or equivalent alternatives) by knowing the stored hash value. This is used for assuring integrity of transmitted data, and is the building block for HMACs, which provide message authentication.
In short, the MAC provides message integrity. Hash functions include MD5, SHA-1 (aka SHA), SHA-2 (aka SHA128, SHA256, & SHA384), and AEAD (Authenticated Encryption with Associated Data). MD5 has long since been rendered completely insecure and is deprecated. SHA-1 is now being 'shamed', if not blocked, by browsers as it is falling victim to advances in cryptographic attacks. While some may need to continue to support SHA-1 cipher suites for legacy clients, it is encouraged to migrate to SHA-2 as soon as possible – especially for digital certificates.
Configuring Cipher Suites on BIG-IP
Now that we've covered what cipher suites are, let's look at where we use them.
There are two distinct and separate areas where cipher suites are used – the host, or management plane, and TMM, or the data plane. On the host side SSL/TLS is handled by OpenSSL and the configuration follows the standard OpenSSL configuration options.
Control Plane
The primary use of SSL/TLS on the control plane is for httpd. To see the currently configured cipher suite, use 'tmsh list sys http ssl-ciphersuite'. The defaults may vary depending on the version of TMOS. For example, these were the defaults in 12.0.0:
tmsh list sys http ssl-ciphersuite
sys httpd {
ssl-ciphersuite DEFAULT:!aNULL:!eNULL:!LOW:!RC4:!MD5:!EXP
}
As of 12.1.2 these have been updated to a more explicit list:
tmsh list sys http ssl-ciphersuite
sys httpd {
ssl-ciphersuite ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA384:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA:AES256-SHA:AES128-SHA256:AES256-SHA256:ECDHE-RSA-DES-CBC3-SHA:ECDHE-ECDSA-DES-CBC3-SHA:DES-CBC3-SHA
}
You can change this configuration via 'tmsh modify sys http ssl-ciphersuite <value>'.
One important thing to note is that the default is not just 'DEFAULT' as it is on the data plane. This is one thing that users have been caught by, thinking that setting the keyword to 'DEFAULT' will reset the configuration.
As OpenSSL provides SSL/TLS support for the control plane, if you want to see which ciphers will actually be supported you can use 'openssl ciphers -v <cipherstring>'.
For example:
openssl ciphers -v 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA384:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA:AES256-SHA:AES128-SHA256:AES256-SHA256:ECDHE-RSA-DES-CBC3-SHA:ECDHE-ECDSA-DES-CBC3-SHA:DES-CBC3-SHA'
Now let's see what happens if you use 'DEFAULT':
openssl ciphers -v 'DEFAULT'
As you can see that enables far, far more ciphers, including a number of unsafe ciphers – export, MD5, DES, etc. This is a good example of why you always want to confirm your cipher settings and check exactly what is being enabled before placing new settings into production. Many security disasters could be avoided if everyone doublechecked their settings first.
Let’s take a closer look at how OpenSSL represents one of the cipher suites:
ECDHE-RSA-AES256-GCM-SHA384 TLSv1.2 Kx=ECDH Au=RSA Enc=AESGCM(256) Mac=AEAD
The columns are:
Cipher Suite: ECDHE-RSA-AES256-GCM-SHA384
Protocol: TLSv1.2
Key Exchange Algorithm (Kx): ECDH
Authentication Algorithm (Au): RSA
Cipher/Encryption Algorithm (Enc): AESGCM(256)
MAC (Mac): AEAD
Since the control plane uses OpenSSL you can use the standard OpenSSL documentation, so I won't spend a lot of time on that.
Data Plane
In tmm the cipher suites are configured in the Ciphers field of the Client SSL or Server SSL profiles. See K14783: Overview of the Client SSL profile (11.x - 12.x) & K14806: Overview of the Server SSL profile (11.x - 12.x), respectively for more details. It is important to keep in mind that these are two different worlds with their own requirements and quirks.
As most of the configuration activity, and security concerns, occur on the public facing side of the system, we'll focus on the Client SSL Profile. Most of the things we'll cover here will also apply to the Server SSL profile.
In the GUI it appears as an editable field:
Presuming the profile was created with the name 'Test':
tmsh list ltm profile client-ssl Test
Modifying the cipher configuration from the command line is simple.
tmsh list ltm profile client-ssl Test ciphers
tmsh modify ltm profile client-ssl Test ciphers 'DEFAULT:!3DES'
tmsh list ltm profile client-ssl Test ciphers
Just remember the 'tmsh save sys config' when you're happy with the configuration.
Note here the default is just 'DEFAULT'. What that expands to will vary depending on the version of TMOS. K13156: SSL ciphers used in the default SSL profiles (11.x - 12.x) defines the default values for each version of TMOS. Or you can check it locally from the command line:
tmm --clientciphers 'DEFAULT'
On 12.1.2 that would be:
tmm --clientciphers 'DEFAULT'
Some differences when compared to OpenSSL are readily apparent. For starters, TMM kindly includes a column label header, and actually aligns the columns. The first column is simply a 0-ordinal numeric index, the rest are as follows:
ID: The official SSL/TLS ID assigned to that cipher suite.
SUITE: The cipher suite.
BITS: The size of the key in bits.
PROT: The protocol supported.
METHOD: NATIVE (in TMM) vs. COMPAT (using OpenSSL code).
CIPHER: The cipher.
MAC: The hash function.
KEYX: The Key Exchange and Authentication Algorithms
Note that the MAC is a little misleading for AES-GCM cipher suites. There is no separate MAC as they're AEAD. But the hashing algorithm is used in the Pseudo-Random Function (PRF) and a few other handshake related places.
Selecting the Cipher Suites
Now we know how to look at the current configuration, modify it, and list the actual ciphers that will be enabled by the listed suites. But what do we put into the configuration?
Most users won't have to touch this. The default values are carefully selected by F5 to meet the needs of the majority of our customers. That's the good news. The bad news is that some customers will need to get in there and change the configuration – be it for regulatory compliance, internal policies, legacy client support, etc.
Once you begin modifying them, the configuration is truly custom for each customer. Every customer who modifies the configuration, and uses a custom cipher configuration, needs to determine what the proper list is for their needs.
Let's say we have determined that we need to support only AES & AES-GCM, 128-bit or 256-bit, and only ECDHE key exchange. Any MAC or Authentication is fine. OK, let's proceed from there.
On 12.1.2 there are six cipher suites that fit those criteria. We could list them all explicitly:
tmm --clientciphers 'ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-CBC-SHA:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES128-CBC-SHA'
That will work, but it gets unwieldy fast. Not only that, but in versions up to 11.5.0 the ciphers configuration string was truncated at 256bytes. Starting in 11.5.0 that was increased to 768bytes, but that can still truncate long configurations. We'll revisit this when we get to the pitfalls section.
Fortunately, there is an alternative – keywords! This will result in the same list of cipher suites:
tmm --clientciphers 'ECDHE+AES-GCM:ECDHE+AES'
That specifies the ECDHE key exchange with AES-GCM ciphers, and ECDHE with AES ciphers. Let's take a closer look to help understand what is happening here.
Keywords
Keywords are extremely important when working with cipher suite configuration, so we'll spend a little time on those. Most of these apply to both the control plane (OpenSSL) and the data plane (TMM), unless otherwise noted, but we're focused on the data plane as that's F5 specific.
Keywords organize into different categories.
F5 specific:
NATIVE: cipher suites implemented natively in TMM
COMPAT: cipher suites using OpenSSL code; removed as of 12.0.0
@SPEED: Re-orders the list to put 'faster' (based on TMOS implementation performance) ciphers first.
Sorting:
@SPEED: Re-orders the list to put 'faster' (based on TMOS implementation performance) ciphers first. (F5 Specific)
@STRENGTH: Re-orders the list to put 'stronger' (larger keys) ciphers first.
Protocol:
TLSv1_2: cipher suites available under TLSv1.2
TLSv1_1: cipher suites available under TLSv1.1
TLSv1: cipher suites available under TLSv1.0
SSLv3: cipher suites available under SSLv3
Note the 'Protocol' keywords in the cipher configuration control the ciphers associated with that protocol, and not the protocol itself! More on this in pitfalls.
Key Exchange Algorithms (sometimes with Authentication specified):
ECDHE or ECDHA_RSA: Elliptic Curve Diffie-Hellman Ephemeral (with RSA)
ECDHE_ECDSA: ECDHE with Elliptic Curve Digital Signature Algorithm
DHE or EDH: Diffie-Hellman Ephemeral (aka Ephemeral Diffie-Hellman) (with RSA)
DHE_DSS: DHE with Digital Signature Standard (aka DSA – Digital Signature Algorithm)
ECDH_RSA: Elliptic Curve Diffie-Hellman with RSA
ECDH_ECDSA: ECDH with ECDSA
RSA: RSA, obviously
ADH: Anonymous Diffie-Hellman.
Note the Authentication Algorithms don't work as standalone keywords in TMM. You can't use 'ECDSA' or 'DSS' for example. And you might think ECDHE or DHE includes all such cipher suites – note that they don't if you read carefully.
General cipher groupings:
DEFAULT: The default cipher suite for that version; see K13156
ALL: All NATIVE cipher suites; does not include COMPAT in current versions
HIGH: 'High' security cipher suites; 128-bit
MEDIUM: 'Medium' security cipher suites; effectively 128-bit suites
LOW: 'Low' security cipher suites; <128-bit excluding export grade ciphers
EXP or EXPORT: Export grade ciphers; 40-bit or 56-bit
EXPORT56: 56-bit export ciphers
EXPORT40: 40-bit export ciphers
Note that DEFAULT does change periodically as F5 updates the configuration to follow the latest best practices. K13156: SSL ciphers used in the default SSL profiles (11.x - 12.x) documents these changes.
Cipher families:
AES-GCM: AES in GCM mode; 128-bit or 256-bit
AES: AES in CBC mode; 128-bit or 256-bit
CAMELLIA: Camellia in CBC mode; 128-bit or 256-bit
3DES: Triple DES in CBC mode; 168-bit (well, 112-bit really)
DES: Single DES in CBC mode, includes EXPORT! 40-bit & 56-bit.
RC4: RC4 stream cipher
NULL: NULL cipher; just what it sounds like, it does nothing – no encryption
MAC aka Hash Function:
SHA384: SHA-2 384-bit hash
SHA256: SHA-2 256-bit hash
SHA1 or SHA: SHA-1 160-bit hash
MD5: MD5 128-bit hash
Other:
On older TMOS versions when using the COMPAT keyword it also enables two additional keywords:
SSLv2: Ciphers supported on the SSLv2 protocol
RC2: RC2 ciphers.
So, let's go back to our example:
tmm --clientciphers 'ECDHE+AES-GCM:ECDHE+AES'
Note that you can combine keywords using '+' (plus sign). And multiple entries in the ciphers configuration line are separated with ':' (colon). You may also need to wrap the string in single quotes on the command line – I find it is a good habit to just always do so.
We can also exclude suites or keywords. There are two ways to do that:
'!' (exclamation point) is a hard exclusion. Anything excluded this way cannot be implicitly or explicitly re-enabled. It is disabled, period.
'-' (minus sign or dash) is a soft exclusion. Anything excluded this way can be explicitly re-enabled later in the configuration string.
Let's look at the different in hard and soft exclusions.
We'll start with our base example:
tmm --clientciphers 'ECDHE+AES-GCM:DHE+AES-GCM'
Now let's look at a hard exclusion:
tmm --clientciphers 'ECDHE+AES-GCM:!DHE:DHE+AES-GCM'
And lastly a soft exclusion:
tmm --clientciphers 'ECDHE+AES-GCM:-DHE:DHE+AES-GCM'
Note that in the second example, the hard exclusion, we used '!DHE'' and even though we then explicitly added 'DHE+AES-GCM'' those ciphers were not enabled. This is because, once excluded with a hard exclusion, ciphers cannot be re-enabled.
In the third example, the soft exclusion, we used '-DHE'' and then 'DHE+AES-GCM'. This time it did enable those ciphers, which is possible with a soft exclusion.
You might be wondering what soft disabling is useful for; why would you ever want to remove ciphers only to add them again? Reordering the ciphers is a common use case. As an example, DEFAULT orders ciphers differently in different versions, but mainly based on strength – bit size. Let's say we know 3DES is really 112-bit equivalent strength and not 168-bit as it is usually labeled. For some reason, maybe legacy clients, we can't disable them, but we want them to be last on the list.
One way to do this is to first configure the DEFAULT list, then remove all of the 3DES ciphers. But then add the 3DES ciphers back explicitly – at the end of the list. Let's try it – compare the following:
tmm --clientciphers 'DEFAULT'
tmm --clientciphers 'DEFAULT:-3DES:!SSLv3:3DES+ECDHE:3DES+DHE:3DES+RSA'
I added something else in there which I'll come back to later.
Pitfalls
As should be clear by now cipher configuration is a powerful tool, but as the song says, every tool is a weapon if you hold it right. And weapons are dangerous. With a little careless handling it is easy to lose a toe – or a leg. Whenever you are working with cipher suite configuration the old rule of 'measure twice, cut once' applies – and then double-check the work to be certain.
There are several common pitfalls which await you.
Misuse
Perhaps the most common pitfall is simply misuse – using cipher suite configuration for that which it is not intended. And the single most common example of this comes from using cipher configuration to manipulate protocols.
Given the keywords, as described above, it seems common for users to presume that if they want to disable a protocol, such as TLSv1.0, then the way to do that is to use a cipher suite keyword, such as !TLSv1. And, indeed, this may seem to work – but it isn't doing what is desired. The protocol is not disabled, only the ciphers that are supported for that protocol are.
The protocol is configured on the VIP independently of the ciphers. !TLSv1 would disable all ciphers supported under the TLSv1.0 protocol, but not the protocol itself. Note that the protocol negotiation and the cipher negotiation in the SSL/TLS handshake are independent. What happens if the VIP only supports TLSv1.0/v1.1/v1.2 and the client only supports SSLv3 & TLSv1.0? Well, they'd agree on TLSv1.0 as the common protocol.
The cipher list the client sends in the Client Hello is independent of the protocol that is eventually negotiated. Say the client sends AES128-SHA and the server has that in its list, so it is selected. OK, we've agreed on a protocol and a cipher suite – only the server won't do any ciphers on TLSv1.0 because of '!TLSv1' in the ciphers configuration, and the connection will fail.
That may seem like splitting hairs, but it makes a difference. If a scanner is looking for protocols that are enabled, and not the full handshake, it may still flag a system which has been configured this way. The protocol is negotiated during the SSL/TLS handshake before the cipher is selected.
This also means the system is doing more work, as the handshake continues further before failing, and the log messages may be misleading. Instead of logging a protocol incompatibility the logs will reflect the failure to find a viable cipher, which can be a red herring when it comes time to debug the configuration.
The right way to do this is to actually disable the protocol, which doesn't involve the cipher suite configuration at all. For the control plane this is done through the ssl-protocol directive:
tmsh list sys http ssl-protocol
sys httpd {
ssl-protocol "all -SSLv2 -SSLv3"
}
For example, if we wanted to disable TLSv1.0:
tmsh modify sys http ssl-protocol 'all -SSLv2 -SSLv3 -TLSv1'
tmsh list sys http ssl-protocol
sys httpd {
ssl-protocol "all -SSLv2 -SSLv3 -TLSv1"
}
For the data plane this can be done via the Options List in the SSL Profile GUI, via the No SSL, No TLSv1.1, etc. directives:
Or via the command line:
tmsh list ltm profile client-ssl Test options
ltm profile client-ssl Test {
options { dont-insert-empty-fragments }
}
tmsh modify ltm profile client-ssl Test options {dont-insert-empty-fragments no-tlsv1}
tmsh list /ltm profile client-ssl Test options
ltm profile client-ssl Test {
options { dont-insert-empty-fragments no-tlsv1 }
}
The values are slightly different on the command line, use this command to see them all:
tmsh modify ltm profile client-ssl <profile-name> options ?
Use the right tool for the job and you'll be more likely to succeed.
Truncation
As I previously mentioned, in versions up to 11.5.0 the ciphers configuration string was truncated at 256 bytes. Starting in 11.5.0 that was increased to 768 bytes (see K11481: The SSL profile cipher lists have a 256 character limitation for more information), but that can still silently truncate long configurations.
This is not a theoretical issue, we've seen users run into this in the real world. For example, little over a year ago I worked with a customer who was then using 11.4.1 HF8. They were trying to very precisely control which ciphers were enabled, and their order. In order to do this they'd decided to enumerate every individual cipher in their configuration – resulting in this cipher suite configuration string:
TLSv1_2+ECDHE-RSA-AES256-CBC-SHA:TLSv1_1+ECDHE-RSA-AES256-CBC-SHA:TLSv1_2+ECDHE-RSA-AES128-CBC-SHA:TLSv1_1+ECDHE-RSA-AES128-CBC-SHA:TLSv1_2+DHE-RSA-AES256-SHA:TLSv1_1+DHE-RSA-AES256-SHA:TLSv1_2+DHE-RSA-AES128-SHA:TLSv1_1+DHE-RSA-AES128-SHA:TLSv1_2+AES256-SHA256:TLSv1_1+AES256-SHA:TLSv1_2+AES128-SHA256:TLSv1_1+AES128-SHA:TLSv1+ECDHE-RSA-AES256-CBC-SHA:TLSv1+ECDHE-RSA-AES128-CBC-SHA:TLSv1+DHE-RSA-AES256-SHA:TLSv1+DHE-RSA-AES128-SHA:TLSv1+AES256-SHA:TLSv1+AES128-SHA:TLSv1+DES-CBC3-SHA
That string would save in the configuration and it was there if you looked at the bigip.conf file, but it was silently truncated when the configuration was loaded. Since this was 11.4.1, only the first 256 bytes were loaded successfully, which made the running configuration:
TLSv1_2+ECDHE-RSA-AES256-CBC-SHA:TLSv1_1+ECDHE-RSA-AES256-CBC-SHA:TLSv1_2+ECDHE-RSA-AES128-CBC-SHA:TLSv1_1+ECDHE-RSA-AES128-CBC-SHA:TLSv1_2+DHE-RSA-AES256-SHA:TLSv1_1+DHE-RSA-AES256-SHA:TLSv1_2+DHE-RSA-AES128-SHA:TLSv1_1+DHE-RSA-AES128-SHA:TLSv1_2+AES256-S
Note the last suite is truncated itself, which means it was invalid and therefore ignored. If their configuration had worked they would've had nineteen protocol+suite combinations – instead they had eight. Needless to say, this caused some problems.
This customer was missing ciphers that they expected to have working. That is bad enough – but it could be worse.
Let's imagine a customer who wants to specify several specific ciphers first, then generally enable a number of other TLSv1.2 & TLSv1.1 ciphers. And, of course, they are careful to disable dangerous ciphers!
TLSv1_2+ECDHE-RSA-AES256-CBC-SHA:TLSv1_1+ECDHE-RSA-AES256-CBC-SHA:TLSv1_2+ECDHE-RSA-AES128-CBC-SHA:TLSv1_1+ECDHE-RSA-AES128-CBC-SHA:TLSv1_2+DHE-RSA-AES256-SHA:TLSv1_1+DHE-RSA-AES256-SHA:TLSv1_2+DHE-RSA-AES128-SHA:TLSv1_1+DHE-RSA-AES128-SHA:TLSv1_2:TLSv1_1:!RC4:!MD5:!ADH:!DES:!EXPORT
OK, that looks fairly solid, right? What do you suppose the problem with this is?
This is the problem; in 11.4.1 and earlier it would truncate to this:
TLSv1_2+ECDHE-RSA-AES256-CBC-SHA:TLSv1_1+ECDHE-RSA-AES256-CBC-SHA:TLSv1_2+ECDHE-RSA-AES128-CBC-SHA:TLSv1_1+ECDHE-RSA-AES128-CBC-SHA:TLSv1_2+DHE-RSA-AES256-SHA:TLSv1_1+DHE-RSA-AES256-SHA:TLSv1_2+DHE-RSA-AES128-SHA:TLSv1_1+DHE-RSA-AES128-SHA:TLSv1_2:TLSv1_1:
All of the exclusions were truncated off! Now we have the opposite problem – there are a number of ciphers enabled which the customer expects to be disabled! And they're BAD ciphers – ADH, DES, MD5, RC4. So this customer would be at high risk without realizing it.
Be aware of this; it is very sneaky. The configuration will look fine; the truncation happens in the code when it loads the configuration. This is also one reason why I always recommend listing your exclusions first in the configuration string. Then you can never accidentally enable something.
Unintended Consequences
Let's say a new CVE is announced which exposes a very serious vulnerability in SSLv3 & TLSv1.0. There is no way to mitigate it, and the only solution is to limit connections to only TLSv1.1 & TLSv1.2.
You want a cipher configuration to accomplish this. It seems straight-forward – just configure it to use only ciphers on TLSv1.1 & TLSv1.2:
tmsh modify ltm profile client-ssl <profile> ciphers 'TLSv1_2:TLSv1_1'
Congratulations, you've solved the problem. You are no longer vulnerable to this CVE.
You know there is a but coming, right?
What's wrong? Well, you just enabled all TLSv1.2 & TLSv1.1 ciphers. That includes such gems as RC4-MD5, RC4-SHA, DES, and a few ADH (Anonymous Diffie-Hellman) suites which have no authentication. As recently as 11.3.0 you'd even be enabling some 40-bit EXPORT ciphers. (We pulled them out of NATIVE in 11.4.0.)
So you just leapt out of the frying pan and into the fire.
Always, always, always check the configuration before using it. Running that through tmm --clientciphers 'TLSv1_2:TLSv1_1' would've raised red flags.
Instead, this configuration would work without causing those problems:
tmsh modify ltm profile client-ssl <profile> ciphers 'DEFAULT:!TLSv1:!SSLv3'
Another option, and probably the better one, is to disable the SSLv3 and TLSv1.0 protocols on the VIP. As I discussed above. Of course, you can do both – belt and suspenders.
And just to show you how easy it is to make such a mistake, F5 did this! In K13400: SSL 3.0/TLS 1.0 BEAST vulnerability CVE-2011-3389 and TLS protocol vulnerability CVE-2012-1870 we originally had the following in the mitigation section:
Note: Alternatively, to configure an SSL profile to use only TLS 1.1-compatible, TLS 1.2-compatible, AES-GCM, or RC4-SHA ciphers using the tmsh utility, use the following syntax:
tmsh create /ltm profile client-ssl <name> ciphers TLSv1_1:TLSv1_2:AES-GCM:RC4-SHA
Yes, I had this fixed long ago.
Remember back in the section on keywords I had this comparison example:
tmm --clientciphers 'DEFAULT'
tmm --clientciphers 'DEFAULT:-3DES:!SSLv3:3DES+ECDHE:3DES+DHE:3DES+RSA'
Who caught the '!SSLv3' in the second line? Why do you think I added that? Did I need to?
Hint: What do you think the side effect of blanket enabling all of those 3DES ciphers would be if I didn't explicitly disable SSLv3?
Cipher Ordering
In SSL/TLS there are two main models to the cipher suite negotiation – Server Cipher Preference or Client Cipher Preference. What does this mean? In SSL/TLS the client sends the list of cipher suites it is willing and able to support in the Client Hello. The server also has its list of cipher suites that it is willing and able to support.
In Client Cipher Preference the server will select the first cipher on the client's list that is also in the server's list. Effectively this gives the client influence over which cipher is selected based on the order of the list it sends.
In Server Cipher Preference the server will select the first server on its own list that is also on the client's list. So the server gives the order of its list precedence.
BIG-IP always operates in Server Cipher Preference, so be very careful in how you order your cipher suites. Preferred suites should go at the top of the list. How you order your cipher suites will directly affect which ciphers are used. It doesn't matter if a stronger cipher is available if a weak cipher is matched first.
HTTP/2
How is HTTP/2 a pitfall? The HTTP/2 RFC7540 includes a blacklist of ciphers that are valid in TLS, but should not be used in HTTP/2. This can cause a problem on a server where the TLS negotiation is decoupled from the ALPN exchange for the higher level protocol. The server might select a cipher which is on the blacklist, and then when the connection attempts to step up to HTTP/2 via ALPN the client may terminate the connection with extreme prejudice. It is well known enough to be called out in the RFC – Section 9.2.2.
F5 added support for HTTP/2 in 12.0.0 – and we fell into this trap. Our DEFAULT ciphers list was ordered such that it was almost certain a blacklisted cipher would be selected.; This was fixed in 12.0.0 HF3 and 12.1.0, but serves as an example.
On 12.0.0 FINAL through 12.0.0 HF2 a simple fix was to configure the ciphers to be 'ECDHE+AES-GCM:DEFAULT'. ECDHE+AES-GCM is guaranteed to be supported by any client compliant with RFC7540 (HTTP/2). Putting it first ensures it is selected before any blacklisted cipher.
3DES
Back in the section on ciphers I mentioned that we label 3DES as being 168-bit, but that it only provides the equivalent of 112-bit strength. So, what did I mean by that?
DES operates on 64-bit data blocks, using 56-bits of key. So it has a strength of 256. 3DES, aka Triple DES, was a stop-gap designed to stretch the life of DES once 56-bits was too weak to be safe, until AES became available. 3DES use the exact same DES cipher, it just uses it three times – hence the name. So you might think 3x56-bits = 168-bits. 2168 strong. Right? No, not really.
The standard implementation of 3DES is known as EDE – for Encrypt, Decrypt, Encrypt. (For reasons we don't need to get into here.) You take the 64-bit data block, run it through DES once to encrypt it with K1, then run it through again to decrypt it using K2, then encrypt it once again using K3.
Three keys, that's still 168-bits, right?
Well, you'd think so. But the devil is in the (implementation) details. Firs