fix: support hash attestation domains in certificate audit

Certificate audit now handles .hatt.tinfoil.sh domains by decoding the
attestation hash, fetching the full attestation from the server, and
verifying the hash matches.

Author: sachaservan

certificate_audit.go

@@ -4,9 +4,11 @@ import (
 	"crypto/ecdsa"
 	"crypto/tls"
 	"crypto/x509"
+	"encoding/base32"
 	"encoding/pem"
 	"fmt"
 	"os"
+	"sort"
 	"strings"
 
 	log "github.com/sirupsen/logrus"
@@ -27,37 +29,86 @@ func init() {
 	rootCmd.AddCommand(certificateAuditCmd)
 }
 
-func attestationFromCertificate(cert *x509.Certificate) (*attestation.Document, string, error) {
+func decodeHashDomains(domains []string) (string, error) {
+	sort.Slice(domains, func(i, j int) bool {
+		return domains[i][:2] < domains[j][:2]
+	})
+
+	var encodedData string
+	for _, domain := range domains {
+		domain = strings.Split(domain, ".")[0]
+		encodedData += domain[2:]
+	}
+
+	encoder := base32.StdEncoding.WithPadding(base32.NoPadding)
+	hashBytes, err := encoder.DecodeString(strings.ToUpper(encodedData))
+	if err != nil {
+		return "", fmt.Errorf("failed to decode base32: %v", err)
+	}
+	return string(hashBytes), nil
+}
+
+func attestationFromCertificate(cert *x509.Certificate, enclaveHost string) (*attestation.Document, string, error) {
 	pubKey, ok := cert.PublicKey.(*ecdsa.PublicKey)
 	if !ok {
 		return nil, "", fmt.Errorf("public key is not an ECDSA key")
 	}
 	keyFP := tlsutil.KeyFP(pubKey)
 
 	var attDomains []string
+	var hashAttDomains []string
 	for _, name := range cert.DNSNames {
 		if strings.HasSuffix(name, ".att.tinfoil.sh") {
 			attDomains = append(attDomains, name)
 			log.Debugf("Attestation domain: %s", name)
+		} else if strings.HasSuffix(name, ".hatt.tinfoil.sh") {
+			hashAttDomains = append(hashAttDomains, name)
+			log.Debugf("Hash attestation domain: %s", name)
 		}
 	}
 
-	if len(attDomains) == 0 {
-		return nil, "", fmt.Errorf("no attestation domains found in certificate")
+	if len(attDomains) > 0 {
+		att, err := dcode.Decode(attDomains)
+		if err != nil {
+			return nil, "", fmt.Errorf("failed to decode attestation: %v", err)
+		}
+		return att, keyFP, nil
 	}
 
-	att, err := dcode.Decode(attDomains)
-	if err != nil {
-		return nil, "", fmt.Errorf("failed to decode attestation: %v", err)
+	if len(hashAttDomains) > 0 {
+		if enclaveHost == "" {
+			return nil, "", fmt.Errorf("certificate contains only hash attestation domains; use -s flag to specify server for attestation fetch")
+		}
+
+		certAttHash, err := decodeHashDomains(hashAttDomains)
+		if err != nil {
+			return nil, "", fmt.Errorf("failed to decode hash attestation: %v", err)
+		}
+		log.Debugf("Certificate attestation hash: %s", certAttHash)
+
+		att, err := attestation.Fetch(enclaveHost)
+		if err != nil {
+			return nil, "", fmt.Errorf("failed to fetch attestation from server: %v", err)
+		}
+		serverAttHash := att.Hash()
+		log.Debugf("Server attestation hash: %s", serverAttHash)
+
+		if certAttHash != serverAttHash {
+			return nil, "", fmt.Errorf("attestation hash mismatch: cert=%s server=%s", certAttHash, serverAttHash)
+		}
+		log.Infof("Attestation hash verified: %s", certAttHash)
+		return att, keyFP, nil
 	}
-	return att, keyFP, nil
+
+	return nil, "", fmt.Errorf("no attestation domains found in certificate")
 }
 
 var certificateAuditCmd = &cobra.Command{
 	Use:   "certificate audit",
 	Short: "Audit enclave certificate",
 	Run: func(cmd *cobra.Command, args []string) {
 		var cert *x509.Certificate
+		var enclaveHost string
 		if certFile != "" {
 			certBytes, err := os.ReadFile(certFile)
 			if err != nil {
@@ -75,11 +126,13 @@ var certificateAuditCmd = &cobra.Command{
 			if server == "" {
 				log.Fatal("Server address is required")
 			}
-			if !strings.Contains(server, ":") {
-				server += ":443"
+			enclaveHost = strings.TrimSuffix(server, ":443")
+			serverAddr := server
+			if !strings.Contains(serverAddr, ":") {
+				serverAddr += ":443"
 			}
 
-			conn, err := tls.Dial("tcp", server, nil)
+			conn, err := tls.Dial("tcp", serverAddr, nil)
 			if err != nil {
 				log.Fatalf("Failed to connect to server: %v", err)
 			}
@@ -91,7 +144,7 @@ var certificateAuditCmd = &cobra.Command{
 			cert = certs[0]
 		}
 
-		att, certKeyFP, err := attestationFromCertificate(cert)
+		att, certKeyFP, err := attestationFromCertificate(cert, enclaveHost)
 		if err != nil {
 			log.Fatalf("Failed to get attestation from certificate: %v", err)
 		}