x509包

var ErrUnsupportedAlgorithm = errors.New("x509: cannot verify signature: algorithm unimplemented")

var IncorrectPasswordError = errors.New("x509: decryption password incorrect")

func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv interface{}) (cert []byte, err error)

func CreateCertificateRequest(rand io.Reader, template *CertificateRequest, priv interface{}) (csr []byte, err error)

func DecryptPEMBlock(b *pem.Block, password []byte) ([]byte, error)

func EncryptPEMBlock(rand io.Reader, blockType string, data, password []byte, alg PEMCipher) (*pem.Block, error)

func IsEncryptedPEMBlock(b *pem.Block) bool

func MarshalECPrivateKey(key *ecdsa.PrivateKey) ([]byte, error)

func MarshalPKCS1PrivateKey(key *rsa.PrivateKey) []byte

func MarshalPKIXPublicKey(pub interface{}) ([]byte, error)

func ParseCRL(crlBytes []byte) (*pkix.CertificateList, error)

func ParseCertificates(asn1Data []byte) ([]*Certificate, error)

func ParseDERCRL(derBytes []byte) (*pkix.CertificateList, error)

func ParseECPrivateKey(der []byte) (*ecdsa.PrivateKey, error)

func ParsePKCS1PrivateKey(der []byte) (*rsa.PrivateKey, error)

func ParsePKCS8PrivateKey(der []byte) (key interface{}, err error)

func ParsePKIXPublicKey(derBytes []byte) (pub interface{}, err error)

package main

import (
	"crypto/dsa"
	"crypto/ecdsa"
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"fmt"
)

func main() {
	const pubPEM = `
-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAlRuRnThUjU8/prwYxbty
WPT9pURI3lbsKMiB6Fn/VHOKE13p4D8xgOCADpdRagdT6n4etr9atzDKUSvpMtR3
CP5noNc97WiNCggBjVWhs7szEe8ugyqF23XwpHQ6uV1LKH50m92MbOWfCtjU9p/x
qhNpQQ1AZhqNy5Gevap5k8XzRmjSldNAFZMY7Yv3Gi+nyCwGwpVtBUwhuLzgNFK/
yDtw2WcWmUU7NuC8Q6MWvPebxVtCfVp/iQU6q60yyt6aGOBkhAX0LpKAEhKidixY
nP9PNVBvxgu3XZ4P36gZV6+ummKdBVnc3NqwBLu5+CcdRdusmHPHd5pHf4/38Z3/
6qU2a/fPvWzceVTEgZ47QjFMTCTmCwNt29cvi7zZeQzjtwQgn4ipN9NibRH/Ax/q
TbIzHfrJ1xa2RteWSdFjwtxi9C20HUkjXSeI4YlzQMH0fPX6KCE7aVePTOnB69I/
a9/q96DiXZajwlpq3wFctrs1oXqBp5DVrCIj8hU2wNgB7LtQ1mCtsYz//heai0K9
PhE4X6hiE0YmeAZjR0uHl8M/5aW9xCoJ72+12kKpWAa0SFRWLy6FejNYCYpkupVJ
yecLk/4L1W0l6jQQZnWErXZYe0PNFcmwGXy1Rep83kfBRNKRy5tvocalLlwXLdUk
AIU+2GKjyT3iMuzZxxFxPFMCAwEAAQ==
-----END PUBLIC KEY-----`

	block, _ := pem.Decode([]byte(pubPEM))
	if block == nil {
		panic("failed to parse PEM block containing the public key")
	}

	pub, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		panic("failed to parse DER encoded public key: " + err.Error())
	}

	switch pub := pub.(type) {
	case *rsa.PublicKey:
		fmt.Println("pub is of type RSA:", pub)
	case *dsa.PublicKey:
		fmt.Println("pub is of type DSA:", pub)
	case *ecdsa.PublicKey:
		fmt.Println("pub is of type ECDSA:", pub)
	default:
		panic("unknown type of public key")
	}
}

type CertPool struct {
        // 包含已过滤或未导出的字段
}

func NewCertPool() *CertPool

func SystemCertPool() (*CertPool, error)

func (s *CertPool) AddCert(cert *Certificate)

func (s *CertPool) AppendCertsFromPEM(pemCerts []byte) (ok bool)

func (s *CertPool) Subjects() [][]byte

type Certificate struct {
        Raw                     []byte // 完整的ASN.1 DER内容（证书，签名算法和签名）。
        RawTBSCertificate       []byte // 原始ASN.1 DER内容的证书部分。
        RawSubjectPublicKeyInfo []byte // DER编码的SubjectPublicKeyInfo。 
        RawSubject              []byte // DER编码主题
        RawIssuer               []byte // DER编码发行者

        Signature          []byte
        SignatureAlgorithm SignatureAlgorithm

        PublicKeyAlgorithm PublicKeyAlgorithm
        PublicKey          interface{}

        Version             int
        SerialNumber        *big.Int
        Issuer              pkix.Name
        Subject             pkix.Name
        NotBefore, NotAfter time.Time // 有效期限。
        KeyUsage            KeyUsage

        // 扩展包含原始X.509扩展。 解析证书时，
        // 这可用于提取非关键扩展
        // 由此包解析。 编组证书时，扩展名（Extensions）
        // 字段被忽略，请参阅ExtraExtensions。
        Extensions []pkix.Extension

        // ExtraExtensions包含要复制的原始扩展名
        // 编组证书。 值会覆盖任何扩展名
        // 否则将根据其他字段生成。 ExtraExtensions
        // 解析证书时未填充字段，请参阅扩展（Extensions）。
        ExtraExtensions []pkix.Extension

        // UnhandledCriticalExtensions包含一个扩展ID列表
        // 解析时没有（完全）处理。 如果这样，验证将失败
        // 除非将验证委托给操作系统，否则slice不为空
        // 了解所有关键扩展的库。
        //
        // 用户可以使用扩展程序访问这些扩展程序，并可以删除
        // 如果他们相信他们已经存在，那么这片中的元素
        // 被处理了。
        UnhandledCriticalExtensions []asn1.ObjectIdentifier

        ExtKeyUsage        []ExtKeyUsage           // 扩展密钥用法的顺序。
        UnknownExtKeyUsage []asn1.ObjectIdentifier // 遇到此软件包未知的扩展密钥用法。

        // BasicConstraintsValid表示IsCA，MaxPathLen，
        // 和MaxPathLenZero有效。
        BasicConstraintsValid bool
        IsCA                  bool

        // MaxPathLen和MaxPathLenZero表示存在和
        // BasicConstraints的“pathLenConstraint”的值。
        //
        // 解析证书时，正零非MaxPathLen
        // 表示该字段已指定，-1表示未设置该字段，
        // 和MaxPathLenZero是真的意味着该领域
        // 明确设置为零。 MaxPathLen == 0，MaxPathLenZero == false
        // 应该被视为等于-1（未设置）。
        //
        // 生成证书时，取消设置pathLenConstraint
        // 可以使用MaxPathLen == -1或使用
        // MaxPathLen和MaxPathLenZero均为零值。
        MaxPathLen int
        // MaxPathLenZero表示BasicConstraintsValid == true
        // 和MaxPathLen == 0应解释为实际
        // 最大路径长度为零。 否则，那个组合就是
        // 解释为未设置MaxPathLen。
        MaxPathLenZero bool

        SubjectKeyId   []byte
        AuthorityKeyId []byte

        // RFC 5280, 4.2.2.1 （权限信息访问）
        OCSPServer            []string
        IssuingCertificateURL []string

        // 主题备用名称值
        DNSNames       []string
        EmailAddresses []string
        IPAddresses    []net.IP

        //名称限制
        PermittedDNSDomainsCritical bool // 如果为true，则名称约束标记为关键。
        PermittedDNSDomains         []string
        ExcludedDNSDomains          []string

        // CRL分发点
        CRLDistributionPoints []string

        PolicyIdentifiers []asn1.ObjectIdentifier
}

func ParseCertificate(asn1Data []byte) (*Certificate, error)

func (c *Certificate) CheckCRLSignature(crl *pkix.CertificateList) error

func (c *Certificate) CheckSignature(algo SignatureAlgorithm, signed, signature []byte) error

func (c *Certificate) CheckSignatureFrom(parent *Certificate) error

func (c *Certificate) CreateCRL(rand io.Reader, priv interface{}, revokedCerts []pkix.RevokedCertificate, now, expiry time.Time) (crlBytes []byte, err error)

func (c *Certificate) Equal(other *Certificate) bool

func (c *Certificate) Verify(opts VerifyOptions) (chains [][]*Certificate, err error)

package main

import (
	"crypto/x509"
	"encoding/pem"
)

func main() {
	// 使用自定义根证书列表进行验证。

	const rootPEM = `
-----BEGIN CERTIFICATE-----
MIIEBDCCAuygAwIBAgIDAjppMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT
MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i
YWwgQ0EwHhcNMTMwNDA1MTUxNTU1WhcNMTUwNDA0MTUxNTU1WjBJMQswCQYDVQQG
EwJVUzETMBEGA1UEChMKR29vZ2xlIEluYzElMCMGA1UEAxMcR29vZ2xlIEludGVy
bmV0IEF1dGhvcml0eSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
AJwqBHdc2FCROgajguDYUEi8iT/xGXAaiEZ+4I/F8YnOIe5a/mENtzJEiaB0C1NP
VaTOgmKV7utZX8bhBYASxF6UP7xbSDj0U/ck5vuR6RXEz/RTDfRK/J9U3n2+oGtv
h8DQUB8oMANA2ghzUWx//zo8pzcGjr1LEQTrfSTe5vn8MXH7lNVg8y5Kr0LSy+rE
ahqyzFPdFUuLH8gZYR/Nnag+YyuENWllhMgZxUYi+FOVvuOAShDGKuy6lyARxzmZ
EASg8GF6lSWMTlJ14rbtCMoU/M4iarNOz0YDl5cDfsCx3nuvRTPPuj5xt970JSXC
DTWJnZ37DhF5iR43xa+OcmkCAwEAAaOB+zCB+DAfBgNVHSMEGDAWgBTAephojYn7
qwVkDBF9qn1luMrMTjAdBgNVHQ4EFgQUSt0GFhu89mi1dvWBtrtiGrpagS8wEgYD
VR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwOgYDVR0fBDMwMTAvoC2g
K4YpaHR0cDovL2NybC5nZW90cnVzdC5jb20vY3Jscy9ndGdsb2JhbC5jcmwwPQYI
KwYBBQUHAQEEMTAvMC0GCCsGAQUFBzABhiFodHRwOi8vZ3RnbG9iYWwtb2NzcC5n
ZW90cnVzdC5jb20wFwYDVR0gBBAwDjAMBgorBgEEAdZ5AgUBMA0GCSqGSIb3DQEB
BQUAA4IBAQA21waAESetKhSbOHezI6B1WLuxfoNCunLaHtiONgaX4PCVOzf9G0JY
/iLIa704XtE7JW4S615ndkZAkNoUyHgN7ZVm2o6Gb4ChulYylYbc3GrKBIxbf/a/
zG+FA1jDaFETzf3I93k9mTXwVqO94FntT0QJo544evZG0R0SnU++0ED8Vf4GXjza
HFa9llF7b1cq26KqltyMdMKVvvBulRP/F/A8rLIQjcxz++iPAsbw+zOzlTvjwsto
WHPbqCRiOwY1nQ2pM714A5AuTHhdUDqB1O6gyHA43LL5Z/qHQF1hwFGPa4NrzQU6
yuGnBXj8ytqU0CwIPX4WecigUCAkVDNx
-----END CERTIFICATE-----`

	const certPEM = `
-----BEGIN CERTIFICATE-----
MIIDujCCAqKgAwIBAgIIE31FZVaPXTUwDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE
BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl
cm5ldCBBdXRob3JpdHkgRzIwHhcNMTQwMTI5MTMyNzQzWhcNMTQwNTI5MDAwMDAw
WjBpMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN
TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEYMBYGA1UEAwwPbWFp
bC5nb29nbGUuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEfRrObuSW5T7q
5CnSEqefEmtH4CCv6+5EckuriNr1CjfVvqzwfAhopXkLrq45EQm8vkmf7W96XJhC
7ZM0dYi1/qOCAU8wggFLMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAa
BgNVHREEEzARgg9tYWlsLmdvb2dsZS5jb20wCwYDVR0PBAQDAgeAMGgGCCsGAQUF
BwEBBFwwWjArBggrBgEFBQcwAoYfaHR0cDovL3BraS5nb29nbGUuY29tL0dJQUcy
LmNydDArBggrBgEFBQcwAYYfaHR0cDovL2NsaWVudHMxLmdvb2dsZS5jb20vb2Nz
cDAdBgNVHQ4EFgQUiJxtimAuTfwb+aUtBn5UYKreKvMwDAYDVR0TAQH/BAIwADAf
BgNVHSMEGDAWgBRK3QYWG7z2aLV29YG2u2IaulqBLzAXBgNVHSAEEDAOMAwGCisG
AQQB1nkCBQEwMAYDVR0fBCkwJzAloCOgIYYfaHR0cDovL3BraS5nb29nbGUuY29t
L0dJQUcyLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAH6RYHxHdcGpMpFE3oxDoFnP+
gtuBCHan2yE2GRbJ2Cw8Lw0MmuKqHlf9RSeYfd3BXeKkj1qO6TVKwCh+0HdZk283
TZZyzmEOyclm3UGFYe82P/iDFt+CeQ3NpmBg+GoaVCuWAARJN/KfglbLyyYygcQq
0SgeDh8dRKUiaW3HQSoYvTvdTuqzwK4CXsr3b5/dAOY8uMuG/IAR3FgwTbZ1dtoW
RvOTa8hYiU6A475WuZKyEHcwnGYe57u2I2KbMgcKjPniocj4QzgYsVAVKW3IwaOh
yE+vPxsiUkvQHdO2fojCkY8jg70jxM+gu59tPDNbw3Uh/2Ij310FgTHsnGQMyA==
-----END CERTIFICATE-----`

	// 首先，创建一组根证书。 对于这个例子我们只
	// 有一个。 也可以省略这个以便使用
	// 当前操作系统的默认根集。
	roots := x509.NewCertPool()
	ok := roots.AppendCertsFromPEM([]byte(rootPEM))
	if !ok {
		panic("failed to parse root certificate")
	}

	block, _ := pem.Decode([]byte(certPEM))
	if block == nil {
		panic("failed to parse certificate PEM")
	}
	cert, err := x509.ParseCertificate(block.Bytes)
	if err != nil {
		panic("failed to parse certificate: " + err.Error())
	}

	opts := x509.VerifyOptions{
		DNSName: "mail.google.com",
		Roots:   roots,
	}

	if _, err := cert.Verify(opts err != nil {
		panic("failed to verify certificate: " + err.Error())
	}
}

func (c *Certificate) VerifyHostname(h string) error

type CertificateInvalidError struct {
        Cert   *Certificate
        Reason InvalidReason
}

func (e CertificateInvalidError) Error() string

type CertificateRequest struct {
        Raw                      []byte // 完整的ASN.1 DER内容（CSR，签名算法和签名）。
        RawTBSCertificateRequest []byte // 证书请求信息是原始ASN.1 DER内容的一部分。
        RawSubjectPublicKeyInfo  []byte // DER编码的SubjectPublicKeyInfo。
        RawSubject               []byte // DER编码主题。
        Version            int
        Signature          []byte
        SignatureAlgorithm SignatureAlgorithm

        PublicKeyAlgorithm PublicKeyAlgorithm
        PublicKey          interface{}

        Subject pkix.Name

        // 属性是bugs的干燥外壳，不应使用。
        Attributes []pkix.AttributeTypeAndValueSET

        // 扩展包含原始X.509扩展。 解析CSR时，这个
        // 可用于提取未解析的扩展
        // 包。
        Extensions []pkix.Extension

        // ExtraExtensions包含要复制的原始扩展名
        // marshaled CSR。 值会覆盖否则将覆盖的任何扩展
        // 基于其他领域产出，但被任何领域覆盖
        // 在Attributes中指定的扩展名。
        //
        // 解析CSR时未填充ExtraExtensions字段，请参阅
        // Extensions。
        ExtraExtensions []pkix.Extension

        // 主题备用名称值。
        DNSNames       []string
        EmailAddresses []string
        IPAddresses    []net.IP
}

func ParseCertificateRequest(asn1Data []byte) (*CertificateRequest, error)

func (c *CertificateRequest) CheckSignature() error

type ConstraintViolationError struct{}

func (ConstraintViolationError) Error() string

type ExtKeyUsage int

const (
        ExtKeyUsageAny ExtKeyUsage = iota
        ExtKeyUsageServerAuth
        ExtKeyUsageClientAuth
        ExtKeyUsageCodeSigning
        ExtKeyUsageEmailProtection
        ExtKeyUsageIPSECEndSystem
        ExtKeyUsageIPSECTunnel
        ExtKeyUsageIPSECUser
        ExtKeyUsageTimeStamping
        ExtKeyUsageOCSPSigning
        ExtKeyUsageMicrosoftServerGatedCrypto
        ExtKeyUsageNetscapeServerGatedCrypto
)

type HostnameError struct {
        Certificate *Certificate
        Host        string
}

func (h HostnameError) Error() string

type InsecureAlgorithmError SignatureAlgorithm

func (e InsecureAlgorithmError) Error() string

type InvalidReason int

const (
        // 当另一个证书签署证书时，NotAuthorizedToSign会生成结果
        // 未标记为CA证书。
        NotAuthorizedToSign InvalidReason = iota
        // 证书过期时根据时间过期的结果
        // 在VerifyOptions中给出。
        Expired
        // 当中间或根时，结果为CANotAuthorizedForThisName
        // certificate具有名称约束，不包括名称
        // 被检查。
        CANotAuthorizedForThisName
        // 当路径长度约束为时，TooManyIntermediates结果
        // 被侵犯。
        TooManyIntermediates
        // 证书的密钥用法表示不兼容的使用结果
        // 它可能只用于不同的目的。
        IncompatibleUsage
        // 当父证书的主题名称时，NameMismatch结果
        // 与子项中的颁发者名称不匹配。
        NameMismatch
)

type KeyUsage int

const (
        KeyUsageDigitalSignature KeyUsage = 1 << iota
        KeyUsageContentCommitment
        KeyUsageKeyEncipherment
        KeyUsageDataEncipherment
        KeyUsageKeyAgreement
        KeyUsageCertSign
        KeyUsageCRLSign
        KeyUsageEncipherOnly
        KeyUsageDecipherOnly
)

type PEMCipher int

const (
        PEMCipherDES PEMCipher
        PEMCipher3DES
        PEMCipherAES128
        PEMCipherAES192
        PEMCipherAES256
)

type PublicKeyAlgorithm int

const (
        UnknownPublicKeyAlgorithm PublicKeyAlgorithm = iota
        RSA
        DSA
        ECDSA
)

type SignatureAlgorithm int

const (
        UnknownSignatureAlgorithm SignatureAlgorithm = iota
        MD2WithRSA
        MD5WithRSA
        SHA1WithRSA
        SHA256WithRSA
        SHA384WithRSA
        SHA512WithRSA
        DSAWithSHA1
        DSAWithSHA256
        ECDSAWithSHA1
        ECDSAWithSHA256
        ECDSAWithSHA384
        ECDSAWithSHA512
        SHA256WithRSAPSS
        SHA384WithRSAPSS
        SHA512WithRSAPSS
)

func (algo SignatureAlgorithm) String() string

type SystemRootsError struct {
        Err error
}

func (se SystemRootsError) Error() string

type UnhandledCriticalExtension struct{}

func (h UnhandledCriticalExtension) Error() string

type UnknownAuthorityError struct {
        Cert *Certificate
        // 包含已过滤或未导出的字段
}

func (e UnknownAuthorityError) Error() string

type VerifyOptions struct {
        DNSName       string
        Intermediates *CertPool
        Roots         *CertPool // 如果为nil（零），则使用系统根
        CurrentTime   time.Time // 如果为零，则使用当前时间
        // KeyUsage指定可接受的扩展密钥用法值。
        // 空列表表示ExtKeyUsageServerAuth。 密钥用法被认为是
        // 约束反映Windows CryptoAPI行为的链，
        // 但不是规范。 要接受任何密钥用法，请包括ExtKeyUsageAny。
        KeyUsages []ExtKeyUsage
}