SNI selects a TLS certificate for the requested hostname

package main

import (
	"crypto/ed25519"
	"crypto/rand"
	"crypto/tls"
	"crypto/x509"
	"errors"
	"fmt"
	"io"
	"log"
	"math/big"
	"net/http"
	"net/http/httptest"
	"runtime"
	"strings"
	"sync/atomic"
	"time"
)

func must(err error) {
	if err != nil {
		panic(err)
	}
}

func check(ok bool, message string) {
	if !ok {
		panic(message)
	}
}

func leaf(name string, serial int64, ca *x509.Certificate, signer ed25519.PrivateKey) tls.Certificate {
	public, private, err := ed25519.GenerateKey(rand.Reader)
	must(err)
	now := time.Now()
	template := &x509.Certificate{
		SerialNumber: big.NewInt(serial), DNSNames: []string{name},
		NotBefore: now.Add(-time.Minute), NotAfter: now.Add(time.Hour),
		KeyUsage:    x509.KeyUsageDigitalSignature,
		ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
	}
	der, err := x509.CreateCertificate(rand.Reader, template, ca, public, signer)
	must(err)
	certificate, err := x509.ParseCertificate(der)
	must(err)
	return tls.Certificate{Certificate: [][]byte{der}, PrivateKey: private, Leaf: certificate}
}

func main() {
	public, private, err := ed25519.GenerateKey(rand.Reader)
	must(err)
	now := time.Now()
	template := &x509.Certificate{
		SerialNumber: big.NewInt(1), IsCA: true, BasicConstraintsValid: true,
		NotBefore: now.Add(-time.Minute), NotAfter: now.Add(time.Hour),
		KeyUsage: x509.KeyUsageCertSign,
	}
	der, err := x509.CreateCertificate(rand.Reader, template, template, public, private)
	must(err)
	ca, err := x509.ParseCertificate(der)
	must(err)
	roots := x509.NewCertPool()
	roots.AddCert(ca)
	alpha := leaf("alpha.example.test", 2, ca, private)
	beta := leaf("beta.example.test", 3, ca, private)
	certificates := map[string]*tls.Certificate{
		"alpha.example.test": &alpha, "beta.example.test": &beta,
	}

	var handled, rejected atomic.Int64
	server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		handled.Add(1)
		fmt.Fprintf(w, "%s|%s", r.TLS.ServerName, r.Host)
	}))
	server.Config.ErrorLog = log.New(io.Discard, "", 0)
	server.TLS = &tls.Config{
		MinVersion: tls.VersionTLS13, MaxVersion: tls.VersionTLS13,
		Certificates: []tls.Certificate{alpha}, SessionTicketsDisabled: true,
		GetCertificate: func(hello *tls.ClientHelloInfo) (*tls.Certificate, error) {
			certificate, ok := certificates[strings.ToLower(hello.ServerName)]
			if !ok {
				rejected.Add(1)
				return nil, fmt.Errorf("unknown fixture SNI")
			}
			return certificate, nil
		},
	}
	server.StartTLS()
	defer server.Close()

	request := func(name, host string) (string, error) {
		config := &tls.Config{RootCAs: roots, ServerName: name, MinVersion: tls.VersionTLS13}
		transport := &http.Transport{TLSClientConfig: config, DisableKeepAlives: true}
		defer transport.CloseIdleConnections()
		client := &http.Client{Transport: transport, Timeout: 2 * time.Second}
		request, err := http.NewRequest(http.MethodGet, server.URL, nil)
		must(err)
		request.Host = host
		response, err := client.Do(request)
		if err != nil {
			return "", err
		}
		defer response.Body.Close()
		body, err := io.ReadAll(response.Body)
		if err != nil {
			return "", err
		}
		check(response.StatusCode == 200, "unexpected HTTP status")
		check(response.TLS.Version == tls.VersionTLS13 && len(response.TLS.VerifiedChains) > 0, "verified TLS 1.3 required")
		check(string(body) == name+"|"+host, "handler must observe separate SNI and Host")
		certificate := response.TLS.PeerCertificates[0]
		must(certificate.VerifyHostname(name))
		return certificate.DNSNames[0], nil
	}

	for _, name := range []string{"alpha.example.test", "beta.example.test"} {
		selected, err := request(name, name)
		must(err)
		check(selected == name, "SNI must select its matching certificate")
		fmt.Println("SNI", name, "selected", selected)
	}
	selected, err := request("ALPHA.EXAMPLE.TEST", "alpha.example.test")
	must(err)
	check(selected == "alpha.example.test", "DNS name selection must be case-insensitive")
	selected, err = request("alpha.example.test", "beta.example.test")
	must(err)
	check(selected == "alpha.example.test", "HTTP Host must not change the TLS certificate")
	_, err = request("missing.example.test", "missing.example.test")
	check(err != nil && rejected.Load() == 1, "unknown SNI must be rejected by fixture policy")
	_, err = request("", "alpha.example.test")
	var nameError x509.HostnameError
	check(errors.As(err, &nameError), "without DNS SNI, default certificate must fail IP identity")
	check(handled.Load() == 4, "only four verified requests may reach the handler")
	fmt.Println("uppercase name selects alpha; Host override keeps alpha; unknown SNI and IP-name mismatch rejected")
	fmt.Println(runtime.Version())
}