if details.algo == algo {
			return details.name
		}
	}
	return strconv.Itoa(int(algo))
}

type PublicKeyAlgorithm int

const (
	UnknownPublicKeyAlgorithm PublicKeyAlgorithm = iota
	RSA
	DSA // Only supported for parsing.
	ECDSA
	Ed25519
)

var publicKeyAlgoName = [...]string{
	RSA:     "RSA",
	DSA:     "DSA",
	ECDSA:   "ECDSA",

	var spk asn1.BitString
	if !spki.ReadASN1BitString(&spk) {
		return nil, errors.New("x509: malformed subjectPublicKey")
	}
	if cert.PublicKeyAlgorithm != UnknownPublicKeyAlgorithm {
		cert.PublicKey, err = parsePublicKey(&publicKeyInfo{
			Algorithm: pkAI,
			PublicKey: spk,
		})
		if err != nil {
			return nil, err
		}
	}

	if cert.Version > 1 {

			name: "invalid issuer, unsupported public key type",
			issuer: &Certificate{
				Version:               3,
				BasicConstraintsValid: true,
				IsCA:                  true,
				PublicKeyAlgorithm:    UnknownPublicKeyAlgorithm,
				PublicKey:             goodKey.Public(),
			},
			err: "x509: cannot verify signature: algorithm unimplemented",
		},
		{
			name: "wrong key",
			issuer: &Certificate{

		{"TooManyIntermediates", Const, 0},
		{"UnconstrainedName", Const, 10},
		{"UnhandledCriticalExtension", Type, 0},
		{"UnknownAuthorityError", Type, 0},
		{"UnknownAuthorityError.Cert", Field, 8},
		{"UnknownPublicKeyAlgorithm", Const, 0},
		{"UnknownSignatureAlgorithm", Const, 0},
		{"VerifyOptions", Type, 0},
		{"VerifyOptions.CurrentTime", Field, 0},
		{"VerifyOptions.DNSName", Field, 0},

pkg crypto/x509, const SHA384WithRSA SignatureAlgorithm
pkg crypto/x509, const SHA512WithRSA SignatureAlgorithm
pkg crypto/x509, const TooManyIntermediates InvalidReason
pkg crypto/x509, const UnknownPublicKeyAlgorithm PublicKeyAlgorithm
pkg crypto/x509, const UnknownSignatureAlgorithm SignatureAlgorithm
pkg crypto/x509, func CreateCertificate(io.Reader, *Certificate, *Certificate, interface{}, interface{}) ([]uint8, error)

pkg crypto/x509, const SHA256WithRSA = 4
pkg crypto/x509, const SHA384WithRSA = 5
pkg crypto/x509, const SHA512WithRSA = 6
pkg crypto/x509, const TooManyIntermediates = 3
pkg crypto/x509, const UnknownPublicKeyAlgorithm = 0
pkg crypto/x509, const UnknownSignatureAlgorithm = 0
pkg crypto/x509, func DecryptPEMBlock(*pem.Block, []uint8) ([]uint8, error)