Blog

Case studies, strategies, and ideas shaping modern technology.

TLS Explained: What It Is, Why It Matters and How to Manage TLS Versions

TLS Explained: What It Is, Why It Matters and How to Manage TLS Versions

Whether you're checking your bank account, sending a confidential email or making an API request, TLS is probably working in the background.

You might not think about it, but Transport Layer Security (TLS) plays a vital role in protecting information as it travels across the internet.

However, having TLS enabled doesn't necessarily mean it's configured securely. Which versions are supported? Are outdated protocols still lurking in your infrastructure? And are the right security standards being enforced?

In this Part 1, we'll explore how TLS works, why version and configuration choices matter, and how to manage TLS security across your infrastructure.

Stay tuned for Part 2, where we'll put these principles into practice with a case study: Strengthening TLS Security: Moving Beyond Cloud Provider Defaults.

Let's take a look.


 

1. What Is TLS?

TLS is a cryptographic protocol that provides secure communication between systems.

For example, when you visit a website using HTTPS, TLS helps create a secure connection between your browser and the web server.

It provides three key protections:

  • Confidentiality: Encrypts data so unauthorised people cannot read it while it is travelling across the network.
  • Authentication: Helps verify that you are communicating with the intended service.
  • Integrity: Helps ensure that data has not been changed while it is in transit.

TLS can protect all sorts of communications, from websites and APIs to email and other application services.

 

TLS vs SSL: What is the difference?

You will often hear people talk about "SSL certificates" or "SSL configuration".

Technically, modern systems use TLS, not SSL.

SSL, or Secure Sockets Layer, was the predecessor to TLS. SSL 2.0 and SSL 3.0 have long been deprecated because of serious security weaknesses.

TLS was introduced as the successor to SSL and has continued to evolve as security requirements have changed.

So when someone says "SSL certificate", they are usually referring to a certificate being used as part of a modern TLS connection.

The terminology has stuck around, even though SSL itself should not be used.

stack

2. Why Does TLS Matter?

Without TLS, information sent across a network could potentially be exposed to someone able to intercept the connection.

Imagine logging into your bank and sending your username and password across the internet without encryption.

You would not want that.

TLS helps protect that information through three core principles.

Principle

What it means

Confidentiality

Keeps transmitted data private through encryption.

Authentication

Helps verify the identity of the service you are connecting to.

Integrity

Helps detect whether data has been changed in transit.

TLS also plays an important role in security and compliance.

Organisations handling sensitive or regulated information may have requirements around encryption in transit, approved cryptographic standards and minimum protocol versions.

So TLS is not just about the padlock you see in your browser.

For many organisations, it is part of the wider security baseline.

 

3. How Does a TLS Connection Actually Work?

So what happens when you connect to an HTTPS website?

Before the application starts sending sensitive information, the client and server need to agree on how they are going to communicate securely.

This is known as the TLS handshake.

At a simplified level, it works like this:

Client → Server: "Here are the TLS versions and security options I support."

Server → Client: "Let's use this version and these security settings. Here is my certificate."

Client: "I'll check that certificate is trusted."

Client ↔ Server: They establish shared session keys.

Client ↔ Server: Encrypted communication begins.

The handshake uses asymmetric cryptography to establish trust and agree on keys, while symmetric encryption is then used to protect the actual data because it is much more efficient for ongoing communication.

The important thing to take away is that TLS is doing considerably more than simply "encrypting the website".

It is establishing a trusted and protected communication channel.

fingerprint

4. TLS Versions: Which One Should You Use?

This is where TLS configuration becomes particularly important.

Not all TLS versions provide the same level of security.

 

TLS 1.0 and TLS 1.1

These older versions have been deprecated and should no longer be used.

They rely on outdated cryptographic mechanisms and have been affected by various security weaknesses over time.

If they are still enabled on an externally exposed service, it is worth reviewing why.

 

TLS 1.2

TLS 1.2 remains widely supported and is commonly used as the minimum acceptable version.

For many organisations, particularly those with regulatory requirements, TLS 1.2 is the baseline.

However, simply enabling TLS 1.2 does not mean every possible configuration is secure. Cipher suites and other cryptographic settings still need to be considered.

 

TLS 1.3

TLS 1.3 is the newer version and provides a number of improvements over TLS 1.2.

It simplifies the cryptographic options available, removes a number of older algorithms and improves handshake performance.

It also provides forward secrecy as a standard part of the protocol.

Where supported by your applications and clients, TLS 1.3 is the preferred modern standard.

The general direction is therefore straightforward:

Disable outdated versions and use TLS 1.2 or TLS 1.3.

 

5. Why Should You Care About TLS Versions?

It can be tempting to think:

"If the connection is encrypted, does the version really matter?"

Yes.

Supporting an outdated protocol can create unnecessary security risk.

It can also create a compliance problem if your organisation is required to enforce a specific minimum security standard.

For example, an organisation may have a policy stating that external services must use TLS 1.2 or higher.

That policy is only useful if the infrastructure actually enforces it.

This is why TLS configuration needs to be tested and monitored rather than simply documented.

Database

6. How Do You Manage TLS Across Your Infrastructure?

Managing TLS for one application is relatively straightforward.

Managing it across dozens of services is a different story.

You might have:

  • Load balancers.
  • Web applications.
  • APIs.
  • Kubernetes ingress points.
  • Cloud services.
  • CDNs.
  • Internal services.
  • Development, staging and production environments.

The more services you have, the harder it becomes to manually check every configuration.

This is where consistency becomes important.

You want to know that the same security requirements are being applied wherever they are needed.

 

7. Start by Auditing Your Existing Configuration

Before changing anything, find out what you currently support.

For externally exposed services, you can use tools such as SSL Labs to assess your public TLS configuration.

You can also test individual endpoints using OpenSSL.

For example:

# Check whether TLS 1.0 is accepted

openssl s_client -connect yourdomain.com:443 -tls1

# Check whether TLS 1.3 is supported

openssl s_client -connect yourdomain.com:443 -tls1_3

The first test should fail if TLS 1.0 has been correctly disabled.

The second should succeed if TLS 1.3 is supported.

The important thing is to understand your starting point before making changes.

 

8. Enforce a Minimum TLS Version

Once you know what you have, the next step is to define what you actually want.

For most modern environments, that means:

  • Disable TLS 1.0.
  • Disable TLS 1.1.
  • Enforce TLS 1.2 as the minimum where required.
  • Support TLS 1.3 where appropriate.
  • Use appropriate cryptographic policies.
  • Apply FIPS-compliant configurations where required.

The exact implementation depends on your technology.

For example, NGINX and Apache can be configured to explicitly allow TLS 1.2 and TLS 1.3 while rejecting older versions.

Cloud platforms and CDNs also provide security policies that allow organisations to define the minimum supported TLS version.

The key is to make the requirement explicit rather than relying on whatever happens to be enabled by default.

 

9. What About Cloud Provider Defaults?

This is particularly relevant if your infrastructure runs in the cloud.

Cloud providers generally provide default SSL/TLS policies designed to offer broad compatibility.

That makes sense. They need their services to work for a wide range of customers and clients.

But your organisation may have more specific requirements.

A regulated environment, for example, may need:

  • TLS 1.2 as a minimum.
  • FIPS-compliant cryptographic policies.
  • Consistent settings across load balancers.
  • Evidence that the configuration has been implemented.
  • A controlled process for changing security settings.

In those situations, explicitly defining your TLS policies gives you greater control than simply relying on provider defaults.

tech lock

10. Why Infrastructure as Code Helps

There is another question worth asking:

How do you make sure these settings stay that way?

Manually configuring a load balancer might solve the immediate problem.

But what happens six months later?

What if someone changes the configuration?

What if you create another load balancer?

What if you need to apply the same security standard across ten more services?

This is where infrastructure as code, such as Terraform, becomes useful.

Instead of manually configuring TLS policies, you can define them in code.

That means your security requirements can be:

  • Stored in version control.
  • Reviewed before deployment.
  • Tested in staging.
  • Applied consistently.
  • Reused across services.
  • Audited later.

It also means that the security configuration becomes part of the platform itself.

 

11. Test Before You Change Production

Security improvements should not come at the expense of availability.

Increasing the minimum TLS version could prevent older clients or systems from connecting.

That is why changes should be tested before they reach production.

A sensible process is:

Define → Test → Validate → Deploy → Monitor

First, define the required TLS policy.

Then apply it in a staging environment.

Test the application and expected client connections.

Check that deprecated TLS versions are rejected.

Confirm that the correct security policy is being applied.

Once everything has been validated, promote the change to production.

This gives you a controlled way to strengthen security without making changes blindly.

checklist

12. TLS Management Checklist

If you are reviewing TLS across your environment, here are some useful questions to ask:

  • Are TLS 1.0 and TLS 1.1 disabled?
  • Is TLS 1.2 enforced as the minimum where required?
  • Can TLS 1.3 be enabled?
  • Are appropriate cipher suites being used?
  • Do any services still rely on outdated configurations?
  • Are cloud-provider defaults sufficient for your requirements?
  • Do FIPS requirements apply to your environment?
  • Are TLS policies applied consistently across externally exposed services?
  • Are certificates being renewed before they expire?
  • Are TLS changes managed through infrastructure as code?
  • Are security changes tested before production?
  • Can you provide evidence that the required configuration is actually being enforced?

 

Final Thoughts

TLS is one of those technologies that should largely be invisible to the end user. But for the people responsible for the platform, it deserves more attention.

Having HTTPS enabled is a good start. It is not the end of the conversation. You also need to consider which TLS versions you allow, which cryptographic policies you use and how consistently those settings are managed.

For regulated organisations, this becomes even more important. Security requirements need to be more than statements in a policy document. They need to be reflected in the infrastructure itself.

Managing TLS through infrastructure as code can help make those requirements consistent, repeatable, reviewable and auditable.

But understanding the principles is only part of the picture. In Part 2, we'll explore how this works in practice through our case study, [Strengthening TLS Security: Moving Beyond Cloud Provider Defaults].

Stay tuned for Part 2, where we'll look at the practical steps involved in strengthening TLS security beyond the standard cloud provider configurations.


At Mesoform, we help organisations build secure and compliant cloud platforms where security requirements are built into the infrastructure and deployment process.

Want to strengthen your cloud security? Contact us.