...
Run Format

Package x509

import "crypto/x509"
Overview
Index
Examples
Subdirectories

Overview ▾

Package x509 parses X.509-encoded keys and certificates.

On UNIX systems the environment variables SSL_CERT_FILE and SSL_CERT_DIR can be used to override the system default locations for the SSL certificate file and SSL certificate files directory, respectively.

Index ▾

Variables
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 MarshalPKCS1PublicKey(key *rsa.PublicKey) []byte
func MarshalPKCS8PrivateKey(key interface{}) ([]byte, error)
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 ParsePKCS1PublicKey(der []byte) (*rsa.PublicKey, error)
func ParsePKCS8PrivateKey(der []byte) (key interface{}, err error)
func ParsePKIXPublicKey(derBytes []byte) (pub interface{}, err error)
type CertPool
    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
    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)
    func (c *Certificate) VerifyHostname(h string) error
type CertificateInvalidError
    func (e CertificateInvalidError) Error() string
type CertificateRequest
    func ParseCertificateRequest(asn1Data []byte) (*CertificateRequest, error)
    func (c *CertificateRequest) CheckSignature() error
type ConstraintViolationError
    func (ConstraintViolationError) Error() string
type ExtKeyUsage
type HostnameError
    func (h HostnameError) Error() string
type InsecureAlgorithmError
    func (e InsecureAlgorithmError) Error() string
type InvalidReason
type KeyUsage
type PEMCipher
type PublicKeyAlgorithm
    func (algo PublicKeyAlgorithm) String() string
type SignatureAlgorithm
    func (algo SignatureAlgorithm) String() string
type SystemRootsError
    func (se SystemRootsError) Error() string
type UnhandledCriticalExtension
    func (h UnhandledCriticalExtension) Error() string
type UnknownAuthorityError
    func (e UnknownAuthorityError) Error() string
type VerifyOptions

Package files

cert_pool.go pem_decrypt.go pkcs1.go pkcs8.go root.go root_linux.go root_unix.go sec1.go verify.go x509.go

Variables

ErrUnsupportedAlgorithm results from attempting to perform an operation that involves algorithms that are not currently implemented.

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

IncorrectPasswordError is returned when an incorrect password is detected.

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

func CreateCertificate

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

CreateCertificate creates a new X.509v3 certificate based on a template. The following members of template are used: AuthorityKeyId, BasicConstraintsValid, DNSNames, ExcludedDNSDomains, ExtKeyUsage, IsCA, KeyUsage, MaxPathLen, MaxPathLenZero, NotAfter, NotBefore, PermittedDNSDomains, PermittedDNSDomainsCritical, SerialNumber, SignatureAlgorithm, Subject, SubjectKeyId, and UnknownExtKeyUsage.

The certificate is signed by parent. If parent is equal to template then the certificate is self-signed. The parameter pub is the public key of the signee and priv is the private key of the signer.

The returned slice is the certificate in DER encoding.

All keys types that are implemented via crypto.Signer are supported (This includes *rsa.PublicKey and *ecdsa.PublicKey.)

The AuthorityKeyId will be taken from the SubjectKeyId of parent, if any, unless the resulting certificate is self-signed. Otherwise the value from template will be used.

func CreateCertificateRequest

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

CreateCertificateRequest creates a new certificate request based on a template. The following members of template are used: Attributes, DNSNames, EmailAddresses, ExtraExtensions, IPAddresses, URIs, SignatureAlgorithm, and Subject. The private key is the private key of the signer.

The returned slice is the certificate request in DER encoding.

All keys types that are implemented via crypto.Signer are supported (This includes *rsa.PublicKey and *ecdsa.PublicKey.)

func DecryptPEMBlock

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

DecryptPEMBlock takes a password encrypted PEM block and the password used to encrypt it and returns a slice of decrypted DER encoded bytes. It inspects the DEK-Info header to determine the algorithm used for decryption. If no DEK-Info header is present, an error is returned. If an incorrect password is detected an IncorrectPasswordError is returned. Because of deficiencies in the encrypted-PEM format, it's not always possible to detect an incorrect password. In these cases no error will be returned but the decrypted DER bytes will be random noise.

func EncryptPEMBlock

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

EncryptPEMBlock returns a PEM block of the specified type holding the given DER-encoded data encrypted with the specified algorithm and password.

func IsEncryptedPEMBlock

func IsEncryptedPEMBlock(b *pem.Block) bool

IsEncryptedPEMBlock returns if the PEM block is password encrypted.

func MarshalECPrivateKey

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

MarshalECPrivateKey marshals an EC private key into ASN.1, DER format.

func MarshalPKCS1PrivateKey

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

MarshalPKCS1PrivateKey converts a private key to ASN.1 DER encoded form.

func MarshalPKCS1PublicKey

func MarshalPKCS1PublicKey(key *rsa.PublicKey) []byte

MarshalPKCS1PublicKey converts an RSA public key to PKCS#1, ASN.1 DER form.

func MarshalPKCS8PrivateKey

func MarshalPKCS8PrivateKey(key interface{}) ([]byte, error)

MarshalPKCS8PrivateKey converts a private key to PKCS#8 encoded form. The following key types are supported: *rsa.PrivateKey, *ecdsa.PublicKey. Unsupported key types result in an error.

See RFC 5208.

func MarshalPKIXPublicKey

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

MarshalPKIXPublicKey serialises a public key to DER-encoded PKIX format.

func ParseCRL

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

ParseCRL parses a CRL from the given bytes. It's often the case that PEM encoded CRLs will appear where they should be DER encoded, so this function will transparently handle PEM encoding as long as there isn't any leading garbage.

func ParseCertificates

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

ParseCertificates parses one or more certificates from the given ASN.1 DER data. The certificates must be concatenated with no intermediate padding.

func ParseDERCRL

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

ParseDERCRL parses a DER encoded CRL from the given bytes.

func ParseECPrivateKey

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

ParseECPrivateKey parses an ASN.1 Elliptic Curve Private Key Structure.

func ParsePKCS1PrivateKey

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

ParsePKCS1PrivateKey returns an RSA private key from its ASN.1 PKCS#1 DER encoded form.

func ParsePKCS1PublicKey

func ParsePKCS1PublicKey(der []byte) (*rsa.PublicKey, error)

ParsePKCS1PublicKey parses a PKCS#1 public key in ASN.1 DER form.

func ParsePKCS8PrivateKey

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

ParsePKCS8PrivateKey parses an unencrypted, PKCS#8 private key. See RFC 5208.

func ParsePKIXPublicKey

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

ParsePKIXPublicKey parses a DER encoded public key. These values are typically found in PEM blocks with "BEGIN PUBLIC KEY".

Supported key types include RSA, DSA, and ECDSA. Unknown key types result in an error.

On success, pub will be of type *rsa.PublicKey, *dsa.PublicKey, or *ecdsa.PublicKey.

Example

type CertPool

CertPool is a set of certificates.

type CertPool struct {
        // contains filtered or unexported fields
}

func NewCertPool

func NewCertPool() *CertPool

NewCertPool returns a new, empty CertPool.

func SystemCertPool

func SystemCertPool() (*CertPool, error)

SystemCertPool returns a copy of the system cert pool.

Any mutations to the returned pool are not written to disk and do not affect any other pool.

func (*CertPool) AddCert

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

AddCert adds a certificate to a pool.

func (*CertPool) AppendCertsFromPEM

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

AppendCertsFromPEM attempts to parse a series of PEM encoded certificates. It appends any certificates found to s and reports whether any certificates were successfully parsed.

On many Linux systems, /etc/ssl/cert.pem will contain the system wide set of root CAs in a format suitable for this function.

func (*CertPool) Subjects

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

Subjects returns a list of the DER-encoded subjects of all of the certificates in the pool.

type Certificate

A Certificate represents an X.509 certificate.

type Certificate struct {
        Raw                     []byte // Complete ASN.1 DER content (certificate, signature algorithm and signature).
        RawTBSCertificate       []byte // Certificate part of raw ASN.1 DER content.
        RawSubjectPublicKeyInfo []byte // DER encoded SubjectPublicKeyInfo.
        RawSubject              []byte // DER encoded Subject
        RawIssuer               []byte // DER encoded Issuer

        Signature          []byte
        SignatureAlgorithm SignatureAlgorithm

        PublicKeyAlgorithm PublicKeyAlgorithm
        PublicKey          interface{}

        Version             int
        SerialNumber        *big.Int
        Issuer              pkix.Name
        Subject             pkix.Name
        NotBefore, NotAfter time.Time // Validity bounds.
        KeyUsage            KeyUsage

        // Extensions contains raw X.509 extensions. When parsing certificates,
        // this can be used to extract non-critical extensions that are not
        // parsed by this package. When marshaling certificates, the Extensions
        // field is ignored, see ExtraExtensions.
        Extensions []pkix.Extension

        // ExtraExtensions contains extensions to be copied, raw, into any
        // marshaled certificates. Values override any extensions that would
        // otherwise be produced based on the other fields. The ExtraExtensions
        // field is not populated when parsing certificates, see Extensions.
        ExtraExtensions []pkix.Extension

        // UnhandledCriticalExtensions contains a list of extension IDs that
        // were not (fully) processed when parsing. Verify will fail if this
        // slice is non-empty, unless verification is delegated to an OS
        // library which understands all the critical extensions.
        //
        // Users can access these extensions using Extensions and can remove
        // elements from this slice if they believe that they have been
        // handled.
        UnhandledCriticalExtensions []asn1.ObjectIdentifier

        ExtKeyUsage        []ExtKeyUsage           // Sequence of extended key usages.
        UnknownExtKeyUsage []asn1.ObjectIdentifier // Encountered extended key usages unknown to this package.

        // BasicConstraintsValid indicates whether IsCA, MaxPathLen,
        // and MaxPathLenZero are valid.
        BasicConstraintsValid bool
        IsCA                  bool

        // MaxPathLen and MaxPathLenZero indicate the presence and
        // value of the BasicConstraints' "pathLenConstraint".
        //
        // When parsing a certificate, a positive non-zero MaxPathLen
        // means that the field was specified, -1 means it was unset,
        // and MaxPathLenZero being true mean that the field was
        // explicitly set to zero. The case of MaxPathLen==0 with MaxPathLenZero==false
        // should be treated equivalent to -1 (unset).
        //
        // When generating a certificate, an unset pathLenConstraint
        // can be requested with either MaxPathLen == -1 or using the
        // zero value for both MaxPathLen and MaxPathLenZero.
        MaxPathLen int
        // MaxPathLenZero indicates that BasicConstraintsValid==true
        // and MaxPathLen==0 should be interpreted as an actual
        // maximum path length of zero. Otherwise, that combination is
        // interpreted as MaxPathLen not being set.
        MaxPathLenZero bool

        SubjectKeyId   []byte
        AuthorityKeyId []byte

        // RFC 5280, 4.2.2.1 (Authority Information Access)
        OCSPServer            []string
        IssuingCertificateURL []string

        // Subject Alternate Name values
        DNSNames       []string
        EmailAddresses []string
        IPAddresses    []net.IP
        URIs           []*url.URL

        // Name constraints
        PermittedDNSDomainsCritical bool // if true then the name constraints are marked critical.
        PermittedDNSDomains         []string
        ExcludedDNSDomains          []string
        PermittedIPRanges           []*net.IPNet
        ExcludedIPRanges            []*net.IPNet
        PermittedEmailAddresses     []string
        ExcludedEmailAddresses      []string
        PermittedURIDomains         []string
        ExcludedURIDomains          []string

        // CRL Distribution Points
        CRLDistributionPoints []string

        PolicyIdentifiers []asn1.ObjectIdentifier
}

func ParseCertificate

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

ParseCertificate parses a single certificate from the given ASN.1 DER data.

func (*Certificate) CheckCRLSignature

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

CheckCRLSignature checks that the signature in crl is from c.

func (*Certificate) CheckSignature

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

CheckSignature verifies that signature is a valid signature over signed from c's public key.

func (*Certificate) CheckSignatureFrom

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

CheckSignatureFrom verifies that the signature on c is a valid signature from parent.

func (*Certificate) CreateCRL

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

CreateCRL returns a DER encoded CRL, signed by this Certificate, that contains the given list of revoked certificates.

func (*Certificate) Equal

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

func (*Certificate) Verify

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

Verify attempts to verify c by building one or more chains from c to a certificate in opts.Roots, using certificates in opts.Intermediates if needed. If successful, it returns one or more chains where the first element of the chain is c and the last element is from opts.Roots.

If opts.Roots is nil and system roots are unavailable the returned error will be of type SystemRootsError.

Name constraints in the intermediates will be applied to all names claimed in the chain, not just opts.DNSName. Thus it is invalid for a leaf to claim example.com if an intermediate doesn't permit it, even if example.com is not the name being validated. Note that DirectoryName constraints are not supported.

Extended Key Usage values are enforced down a chain, so an intermediate or root that enumerates EKUs prevents a leaf from asserting an EKU not in that list.

WARNING: this function doesn't do any revocation checking.

Example

func (*Certificate) VerifyHostname

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

VerifyHostname returns nil if c is a valid certificate for the named host. Otherwise it returns an error describing the mismatch.

type CertificateInvalidError

CertificateInvalidError results when an odd error occurs. Users of this library probably want to handle all these errors uniformly.

type CertificateInvalidError struct {
        Cert   *Certificate
        Reason InvalidReason
        Detail string
}

func (CertificateInvalidError) Error

func (e CertificateInvalidError) Error() string

type CertificateRequest

CertificateRequest represents a PKCS #10, certificate signature request.

type CertificateRequest struct {
        Raw                      []byte // Complete ASN.1 DER content (CSR, signature algorithm and signature).
        RawTBSCertificateRequest []byte // Certificate request info part of raw ASN.1 DER content.
        RawSubjectPublicKeyInfo  []byte // DER encoded SubjectPublicKeyInfo.
        RawSubject               []byte // DER encoded Subject.

        Version            int
        Signature          []byte
        SignatureAlgorithm SignatureAlgorithm

        PublicKeyAlgorithm PublicKeyAlgorithm
        PublicKey          interface{}

        Subject pkix.Name

        // Attributes is the dried husk of a bug and shouldn't be used.
        Attributes []pkix.AttributeTypeAndValueSET

        // Extensions contains raw X.509 extensions. When parsing CSRs, this
        // can be used to extract extensions that are not parsed by this
        // package.
        Extensions []pkix.Extension

        // ExtraExtensions contains extensions to be copied, raw, into any
        // marshaled CSR. Values override any extensions that would otherwise
        // be produced based on the other fields but are overridden by any
        // extensions specified in Attributes.
        //
        // The ExtraExtensions field is not populated when parsing CSRs, see
        // Extensions.
        ExtraExtensions []pkix.Extension

        // Subject Alternate Name values.
        DNSNames       []string
        EmailAddresses []string
        IPAddresses    []net.IP
        URIs           []*url.URL
}

func ParseCertificateRequest

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

ParseCertificateRequest parses a single certificate request from the given ASN.1 DER data.

func (*CertificateRequest) CheckSignature

func (c *CertificateRequest) CheckSignature() error

CheckSignature reports whether the signature on c is valid.

type ConstraintViolationError

ConstraintViolationError results when a requested usage is not permitted by a certificate. For example: checking a signature when the public key isn't a certificate signing key.

type ConstraintViolationError struct{}

func (ConstraintViolationError) Error

func (ConstraintViolationError) Error() string

type ExtKeyUsage

ExtKeyUsage represents an extended set of actions that are valid for a given key. Each of the ExtKeyUsage* constants define a unique action.

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

type HostnameError

HostnameError results when the set of authorized names doesn't match the requested name.

type HostnameError struct {
        Certificate *Certificate
        Host        string
}

func (HostnameError) Error

func (h HostnameError) Error() string

type InsecureAlgorithmError

An InsecureAlgorithmError

type InsecureAlgorithmError SignatureAlgorithm

func (InsecureAlgorithmError) Error

func (e InsecureAlgorithmError) Error() string

type InvalidReason

type InvalidReason int
const (
        // NotAuthorizedToSign results when a certificate is signed by another
        // which isn't marked as a CA certificate.
        NotAuthorizedToSign InvalidReason = iota
        // Expired results when a certificate has expired, based on the time
        // given in the VerifyOptions.
        Expired
        // CANotAuthorizedForThisName results when an intermediate or root
        // certificate has a name constraint which doesn't permit a DNS or
        // other name (including IP address) in the leaf certificate.
        CANotAuthorizedForThisName
        // TooManyIntermediates results when a path length constraint is
        // violated.
        TooManyIntermediates
        // IncompatibleUsage results when the certificate's key usage indicates
        // that it may only be used for a different purpose.
        IncompatibleUsage
        // NameMismatch results when the subject name of a parent certificate
        // does not match the issuer name in the child.
        NameMismatch
        // NameConstraintsWithoutSANs results when a leaf certificate doesn't
        // contain a Subject Alternative Name extension, but a CA certificate
        // contains name constraints.
        NameConstraintsWithoutSANs
        // UnconstrainedName results when a CA certificate contains permitted
        // name constraints, but leaf certificate contains a name of an
        // unsupported or unconstrained type.
        UnconstrainedName
        // TooManyConstraints results when the number of comparision operations
        // needed to check a certificate exceeds the limit set by
        // VerifyOptions.MaxConstraintComparisions. This limit exists to
        // prevent pathological certificates can consuming excessive amounts of
        // CPU time to verify.
        TooManyConstraints
        // CANotAuthorizedForExtKeyUsage results when an intermediate or root
        // certificate does not permit an extended key usage that is claimed by
        // the leaf certificate.
        CANotAuthorizedForExtKeyUsage
)

type KeyUsage

KeyUsage represents the set of actions that are valid for a given key. It's a bitmap of the KeyUsage* constants.

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

type PEMCipher

type PEMCipher int

Possible values for the EncryptPEMBlock encryption algorithm.

const (
        PEMCipherDES PEMCipher
        PEMCipher3DES
        PEMCipherAES128
        PEMCipherAES192
        PEMCipherAES256
)

type PublicKeyAlgorithm

type PublicKeyAlgorithm int
const (
        UnknownPublicKeyAlgorithm PublicKeyAlgorithm = iota
        RSA
        DSA
        ECDSA
)

func (PublicKeyAlgorithm) String

func (algo PublicKeyAlgorithm) String() string

type SignatureAlgorithm

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

func (SignatureAlgorithm) String

func (algo SignatureAlgorithm) String() string

type SystemRootsError

SystemRootsError results when we fail to load the system root certificates.

type SystemRootsError struct {
        Err error
}

func (SystemRootsError) Error

func (se SystemRootsError) Error() string

type UnhandledCriticalExtension

type UnhandledCriticalExtension struct{}

func (UnhandledCriticalExtension) Error

func (h UnhandledCriticalExtension) Error() string

type UnknownAuthorityError

UnknownAuthorityError results when the certificate issuer is unknown

type UnknownAuthorityError struct {
        Cert *Certificate
        // contains filtered or unexported fields
}

func (UnknownAuthorityError) Error

func (e UnknownAuthorityError) Error() string

type VerifyOptions

VerifyOptions contains parameters for Certificate.Verify. It's a structure because other PKIX verification APIs have ended up needing many options.

type VerifyOptions struct {
        DNSName       string
        Intermediates *CertPool
        Roots         *CertPool // if nil, the system roots are used
        CurrentTime   time.Time // if zero, the current time is used
        // KeyUsage specifies which Extended Key Usage values are acceptable.
        // An empty list means ExtKeyUsageServerAuth. Key usage is considered a
        // constraint down the chain which mirrors Windows CryptoAPI behavior,
        // but not the spec. To accept any key usage, include ExtKeyUsageAny.
        KeyUsages []ExtKeyUsage
        // MaxConstraintComparisions is the maximum number of comparisons to
        // perform when checking a given certificate's name constraints. If
        // zero, a sensible default is used. This limit prevents pathalogical
        // certificates from consuming excessive amounts of CPU time when
        // validating.
        MaxConstraintComparisions int
}

Subdirectories

Name Synopsis
..
pkix Package pkix contains shared, low level structures used for ASN.1 parsing and serialization of X.509 certificates, CRL and OCSP.