main.go

package main

import (
	"crypto/sha256"
	"crypto/tls"
	"crypto/x509"
	"encoding/base64"
	"encoding/xml"
	"flag"
	"fmt"
	"io"
	"log"
	"net"
	"os"
	"sort"
	"strings"
	"time"
)

const doc = `Verify that each pinned domain's live TLS chain is covered by the Android Network Security Configuration declared in network_security_config.xml.`

func main() {
	var (
		networkSecurityConfigPath string
		timeout                   time.Duration
	)
	flag.StringVar(&networkSecurityConfigPath, "network-security-config", "", "path to network_security_config.xml")
	flag.DurationVar(&timeout, "timeout", 10*time.Second, "TLS dial timeout")
	flag.Usage = func() {
		fmt.Fprintf(flag.CommandLine.Output(), doc+"\n\n")
		flag.PrintDefaults()
	}
	flag.Parse()

	pins, err := parseXML(networkSecurityConfigPath)
	if err != nil {
		log.Fatalf("parse %s: %v", networkSecurityConfigPath, err)
	}

	fmt.Printf("=== Android pins (%s) ===\n", networkSecurityConfigPath)
	for _, host := range sortedHosts(pins) {
		fmt.Printf("%-20s %3d\n", host, len(pins[host]))
	}

	failed := false
	for _, domain := range sortedHosts(pins) {
		if verifyDomain(domain, pins[domain], timeout) != nil {
			failed = true
		}
	}

	fmt.Println()
	if failed {
		fmt.Println("error : one or more domains are not covered by Android cert pinning")
		os.Exit(1)
	}
	fmt.Println("ok : all domains are covered by Android cert pinning")
}

// verifyDomain fetches the live chain of domain and reports whether any chain
// certificate's SPKI matches one of the configured pins.
func verifyDomain(domain string, pins []string, timeout time.Duration) error {
	fmt.Printf("\n=== verify %s ===\n", domain)
	certs, err := fetchChain(domain, timeout)
	if err != nil {
		fmt.Printf("error: %v\n", err)
		return err
	}

	hashes := make([]string, len(certs))
	fmt.Printf("chain: %d certs\n", len(certs))
	for i, c := range certs {
		h, err := spkiHash(c)
		if err != nil {
			fmt.Printf("error: cert %d: %v\n", i+1, err)
			return err
		}
		hashes[i] = h
		fmt.Printf("[%d] %-12s %-45s  SPKI %s\n", i+1, certKindFor(i, len(certs)), certName(c), h)
	}

	fmt.Println()

	idx, matched := findMatchIn(hashes, pins)
	status := "ok"
	notes := fmt.Sprintf("%d pins; chain cert [%d] matches %s", len(pins), idx+1, matched)
	if matched == "" {
		status = "error"
		notes = fmt.Sprintf("%d pins; no chain cert SPKI in pin-set", len(pins))
	}
	fmt.Printf("%-20s %-5s %s\n", domain, status, notes)

	if matched == "" {
		return fmt.Errorf("%s not covered by pins", domain)
	}
	return nil
}

// parseXML extracts, per <domain>, the SHA-256 pins from every <pin-set> in
// the Network Security Configuration.
func parseXML(path string) (map[string][]string, error) {
	pins := map[string][]string{}
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer f.Close()

	dec := xml.NewDecoder(f)
	domain := ""
	inPinSet := false
	for {
		tok, err := dec.Token()
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}
		switch t := tok.(type) {
		case xml.StartElement:
			switch t.Name.Local {
			case "domain":
				domain = strings.TrimSpace(readText(dec, "domain"))
			case "pin-set":
				inPinSet = true
			case "pin":
				if inPinSet && domain != "" && attr(t.Attr, "digest") == "SHA-256" {
					if v := strings.TrimSpace(readText(dec, "pin")); v != "" {
						pins[domain] = append(pins[domain], v)
					}
				}
			}
		case xml.EndElement:
			if t.Name.Local == "domain-config" {
				domain = ""
				inPinSet = false
			}
		}
	}
	return pins, nil
}

// attr returns the value of the named XML attribute, or "".
func attr(attrs []xml.Attr, name string) string {
	for _, a := range attrs {
		if a.Name.Local == name {
			return a.Value
		}
	}
	return ""
}

// fetchChain dials the domain over TLS and returns the chain the server
// presents (leaf first), the same set openssl s_client -showcerts shows.
func fetchChain(domain string, timeout time.Duration) ([]*x509.Certificate, error) {
	dialer := &net.Dialer{Timeout: timeout}
	conn, err := tls.DialWithDialer(dialer, "tcp", net.JoinHostPort(domain, "443"), &tls.Config{ServerName: domain})
	if err != nil {
		return nil, fmt.Errorf("tls dial %s: %w", domain, err)
	}
	defer conn.Close()
	state := conn.ConnectionState()
	if len(state.PeerCertificates) == 0 {
		return nil, fmt.Errorf("tls dial %s: no peer certificates", domain)
	}
	return state.PeerCertificates, nil
}

// spkiHash returns the base64 SHA-256 hash of the certificate's Subject Public
// Key Info (the value used by OkHttp/Cronet pinning and Android NSC pins).
func spkiHash(c *x509.Certificate) (string, error) {
	der, err := x509.MarshalPKIXPublicKey(c.PublicKey)
	if err != nil {
		return "", err
	}
	sum := sha256.Sum256(der)
	return base64.StdEncoding.EncodeToString(sum[:]), nil
}

// findMatchIn returns the index (within hashes) and matching pin for the first
// hash that appears in pins, or -1/"".
func findMatchIn(hashes, pins []string) (int, string) {
	for i, h := range hashes {
		for _, p := range pins {
			if strings.TrimSpace(p) == h {
				return i, p
			}
		}
	}
	return -1, ""
}

// readText consumes tokens until the end of the given element and returns the
// accumulated character data.
func readText(dec *xml.Decoder, elem string) string {
	var b strings.Builder
	for {
		tok, err := dec.Token()
		if err != nil {
			return b.String()
		}
		if end, ok := tok.(xml.EndElement); ok && end.Name.Local == elem {
			return b.String()
		}
		if cd, ok := tok.(xml.CharData); ok {
			b.Write(cd)
		}
	}
}

func sortedHosts(pins map[string][]string) []string {
	hosts := make([]string, 0, len(pins))
	for h := range pins {
		hosts = append(hosts, h)
	}
	sort.Strings(hosts)
	return hosts
}

// certKind identifies the position of a certificate within a chain.
type certKind string

const (
	certKindLeaf         certKind = "leaf"
	certKindIntermediate certKind = "intermediate"
	certKindRoot         certKind = "root"
)

// certKindFor returns the chain position of certificate i of total.
func certKindFor(i, total int) certKind {
	switch {
	case i == 0:
		return certKindLeaf
	case i == total-1 && total > 2:
		return certKindRoot
	default:
		return certKindIntermediate
	}
}

func certName(c *x509.Certificate) string {
	if c.Subject.CommonName != "" {
		return "CN=" + c.Subject.CommonName
	}
	if len(c.Subject.Organization) > 0 {
		return c.Subject.Organization[0]
	}
	return c.Subject.String()
}