x509_lists_gen.go

//go:build ignore
// +build ignore

package main

import (
	"bytes"
	"go/ast"
	"go/format"
	"go/parser"
	"go/token"
	"io/ioutil"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"text/template"
)

const (
	outputFile = "x509_lists.go"
)

var packageTemplate = template.Must(template.New("").Parse(`// Code generated by go generate; DO NOT EDIT.

package pcert

import (
	"crypto/x509"
)

var KeyUsages = map[string]x509.KeyUsage{
{{- range $key, $value := .KeyUsage }}
	{{ printf "%q" $key }}: x509.{{ $value }},
{{- end }}
}

var ExtKeyUsages = map[string]x509.ExtKeyUsage{
{{- range $key, $value := .ExtKeyUsage }}
	{{ printf "%q" $key }}: x509.{{ $value }},
{{- end }}
}

var SignatureAlgorithms = []x509.SignatureAlgorithm{
{{- range $key, $value := .SignAlgs }}
	x509.{{ $value }},
{{- end }}
}
`))

func main() {
	// detect GOROOT
	goroot := os.Getenv("GOROOT")
	if goroot == "" {
		cmd := exec.Command("go", "env", "GOROOT")
		out, err := cmd.CombinedOutput()
		if err != nil {
			log.Fatal(err)
		}
		goroot = strings.TrimSpace(string(out))
	}

	x509SrcFile := filepath.Join(goroot, "src/crypto/x509/x509.go")

	usage, err := getEnum("KeyUsage", x509SrcFile)
	if err != nil {
		log.Fatal(err)
	}
	extUsage, err := getEnum("ExtKeyUsage", x509SrcFile)
	if err != nil {
		log.Fatal(err)
	}
	signAlgs, err := getEnum("SignatureAlgorithm", x509SrcFile)
	if err != nil {
		log.Fatal(err)
	}

	usageStringMapping := generateStringMapping("KeyUsage", usage)
	extUsageStringMapping := generateStringMapping("ExtKeyUsage", extUsage)
	signAlgMapping := generateSignatureAlgorithmMapping(signAlgs)

	output := &bytes.Buffer{}
	err = packageTemplate.Execute(output, struct {
		KeyUsage    map[string]string
		ExtKeyUsage map[string]string
		SignAlgs    map[string]string
	}{
		KeyUsage:    usageStringMapping,
		ExtKeyUsage: extUsageStringMapping,
		SignAlgs:    signAlgMapping,
	})
	if err != nil {
		log.Fatal(err)
	}

	formattedOutput, err := format.Source(output.Bytes())
	if err != nil {
		log.Fatal(err)
	}

	err = ioutil.WriteFile(outputFile, formattedOutput, 0o644)
	if err != nil {
		log.Fatal(err)
	}
}

func generateSignatureAlgorithmMapping(names []string) map[string]string {
	out := map[string]string{}
	for _, name := range names {
		if strings.Contains(name, "Unknown") {
			continue
		}
		newName := strings.ReplaceAll(name, "With", "-")
		out[newName] = name
	}
	return out
}

func generateStringMapping(typeName string, names []string) map[string]string {
	out := map[string]string{}
	for _, name := range names {
		newName := name[len(typeName):]
		out[newName] = name
	}
	return out
}

func getEnum(typ, file string) ([]string, error) {
	fset := token.NewFileSet()
	node, err := parser.ParseFile(fset, file, nil, 0)
	if err != nil {
		return nil, err
	}

	var names []string
	ast.Inspect(node, func(n ast.Node) bool {
		decl, ok := n.(*ast.GenDecl)
		if !ok || decl.Tok != token.CONST {
			return true
		}

		if len(decl.Specs) == 0 {
			return true
		}

		vspec := decl.Specs[0].(*ast.ValueSpec)
		ident, ok := vspec.Type.(*ast.Ident)
		if !ok {
			return true
		}
		if ident.Name != typ {
			return true
		}

		for _, spec := range decl.Specs {
			vspec := spec.(*ast.ValueSpec) // Guaranteed to succeed as this is CONST.
			for _, n := range vspec.Names {
				names = append(names, n.Name)
			}
		}
		return true
	})

	return names, nil
}