TLS & PKI

What TLS actually does

TLS solves two problems at once: confidentiality (encryption) and authenticity (you’re really talking to example.com). The handshake is a small dance that combines asymmetric and symmetric crypto:

sequenceDiagram
participant C as Client
participant S as Server
C->>S: ClientHello (ciphers, SNI=example.com)
S->>C: ServerHello + certificate (chain)
Note over C: verify cert chains to a trusted CA<br/>+ matches the hostname
C->>S: key exchange (ECDHE)
Note over C,S: both derive the same symmetric session key
C->>S: encrypted with AES-GCM
S->>C: encrypted with AES-GCM

Asymmetric crypto authenticates the server and agrees on a shared secret; that secret becomes a fast symmetric session key for the actual data. That’s why every TLS connection has a handshake phase then a (much faster) data phase — exactly the symmetric/asymmetric split from the previous page.

The chain of trust

Your OS ships a set of trusted root CA certificates. A website’s certificate is signed by an intermediate CA, which is signed by a root. Verification walks that chain up to a root you already trust — if any link is missing, expired, revoked, or untrusted, it fails.

See it: generate and verify a certificate

Go’s crypto/x509 builds and verifies certificates. This runs here — it generates a self-signed cert, parses it back, and verifies it against a pool containing itself. Output is fixed fields + booleans, so it’s deterministic:

package main

import (
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/x509"
"crypto/x509/pkix"
"fmt"
"math/big"
"time"
)

func main() {
// A key pair for the certificate.
key, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)

tmpl := &x509.Certificate{
	SerialNumber: big.NewInt(1),
	Subject:      pkix.Name{CommonName: "example.com"},
	DNSNames:     []string{"example.com"},
	NotBefore:    time.Now().Add(-time.Hour),
	NotAfter:     time.Now().Add(24 * time.Hour),
	IsCA:         true, // self-signed root for the demo
	KeyUsage:     x509.KeyUsageCertSign | x509.KeyUsageDigitalSignature,
	BasicConstraintsValid: true,
}

// Self-sign: parent == template, signed with our own key.
der, _ := x509.CreateCertificate(rand.Reader, tmpl, tmpl, &key.PublicKey, key)
cert, _ := x509.ParseCertificate(der)

fmt.Println("subject:  ", cert.Subject.CommonName)
fmt.Println("is CA:    ", cert.IsCA)

// Verify the cert chains to a trusted root (itself, here).
roots := x509.NewCertPool()
roots.AddCert(cert)
_, err := cert.Verify(x509.VerifyOptions{Roots: roots, DNSName: "example.com"})
fmt.Println("verifies: ", err == nil)

// A hostname that isn't on the cert must fail.
_, err = cert.Verify(x509.VerifyOptions{Roots: roots, DNSName: "evil.com"})
fmt.Println("rejects wrong host:", err != nil)
}

Verify does the real work browsers do: chain-building to a trusted root, expiry checks, and hostname matching (evil.com is rejected because it’s not in the cert’s DNSNames). In production you’d let a real CA — or Let’s Encrypt via golang.org/x/crypto/acme/autocert — issue the cert, and the client’s system root pool would do the verifying.

Serving and consuming TLS

Running an HTTPS server is one line once you have a cert; mutual TLS adds client-cert verification for service-to-service auth (fenced — needs real certs and sockets):

// Server requiring client certificates (mTLS).
srv := &http.Server{
	Addr: ":8443",
	TLSConfig: &tls.Config{
		ClientAuth: tls.RequireAndVerifyClientCert,
		ClientCAs:  clientCAPool, // verify clients against these CAs
		MinVersion: tls.VersionTLS12,
	},
}
srv.ListenAndServeTLS("server.crt", "server.key")

mTLS is the backbone of zero-trust service meshes: every caller must present a valid certificate, so identity is cryptographic, not just a bearer token.

See also

• Symmetric encryption — the session crypto TLS sets up.
• DNS enumeration — why certificate transparency makes every TLS hostname public.
• TLS & HTTPS (web track) — serving HTTPS with net/http in depth.
• Web security — TLS as one layer of a hardened server.

Next: the mistakes that break otherwise-good crypto — attacking weak crypto.

Related topics