type Certificate(struct)
A Certificate represents an X.509 certificate.
AuthorityKeyId[]byte
BasicConstraintsValid indicates whether IsCA, MaxPathLen,
and MaxPathLenZero are valid.
CRL Distribution Points
Subject Alternate Name values. (Note that these values may not be valid
if invalid values were contained within a parsed certificate. For
example, an element of DNSNames may not be a valid DNS domain name.)
EmailAddresses[]stringExcludedDNSDomains[]stringExcludedEmailAddresses[]stringExcludedIPRanges[]*net.IPNetExcludedURIDomains[]string
// Sequence of extended key usages.
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.
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.
IPAddresses[]net.IPIsCAboolIssuerpkix.NameIssuingCertificateURL[]stringKeyUsageKeyUsage
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.
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.
// Validity bounds.
// Validity bounds.
RFC 5280, 4.2.2.1 (Authority Information Access)
PermittedDNSDomains[]string
Name constraints
// if true then the name constraints are marked critical.
PermittedEmailAddresses[]stringPermittedIPRanges[]*net.IPNetPermittedURIDomains[]stringPolicyIdentifiers[]asn1.ObjectIdentifierPublicKeyinterface{}PublicKeyAlgorithmPublicKeyAlgorithm
// Complete ASN.1 DER content (certificate, signature algorithm and signature).
// DER encoded Issuer
// DER encoded Subject
// DER encoded SubjectPublicKeyInfo.
// Certificate part of raw ASN.1 DER content.
SerialNumber*big.IntSignature[]byteSignatureAlgorithmSignatureAlgorithmSubjectpkix.NameSubjectKeyId[]byteURIs[]*url.URL
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.
// Encountered extended key usages unknown to this package.
Versionint
CheckCRLSignature checks that the signature in crl is from c.
CheckSignature verifies that signature is a valid signature over signed from
c's public key.
CheckSignatureFrom verifies that the signature on c is a valid signature
from parent.
CreateCRL returns a DER encoded CRL, signed by this Certificate, that
contains the given list of revoked certificates.
Note: this method does not generate an RFC 5280 conformant X.509 v2 CRL.
To generate a standards compliant CRL, use CreateRevocationList instead.
(*T) Equal(other *Certificate) bool
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, the platform verifier might be used, and
verification details might differ from what is described below. If 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.
Name constraint validation follows the rules from RFC 5280, with the
addition that DNS name constraints may use the leading period format
defined for emails and URIs. When a constraint has a leading period
it indicates that at least one additional label must be prepended to
the constrained name to be considered valid.
Extended Key Usage values are enforced nested down a chain, so an intermediate
or root that enumerates EKUs prevents a leaf from asserting an EKU not in that
list. (While this is not specified, it is common practice in order to limit
the types of certificates a CA can issue.)
WARNING: this function doesn't do any revocation checking.
VerifyHostname returns nil if c is a valid certificate for the named host.
Otherwise it returns an error describing the mismatch.
IP addresses can be optionally enclosed in square brackets and are checked
against the IPAddresses field. Other names are checked case insensitively
against the DNSNames field. If the names are valid hostnames, the certificate
fields can have a wildcard as the left-most label.
The legacy Common Name field is ignored unless it's a valid hostname, the
certificate doesn't have any Subject Alternative Names, and the GODEBUG
environment variable is set to "x509ignoreCN=0". Support for Common Name is
deprecated will be entirely removed in the future.
func ParseCertificate(asn1Data []byte) (*Certificate, error)
func ParseCertificates(asn1Data []byte) ([]*Certificate, error)
func (*Certificate).Verify(opts VerifyOptions) (chains [][]*Certificate, err error)
func net/http/httptest.(*Server).Certificate() *Certificate
func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv interface{}) (cert []byte, err error)
func CreateRevocationList(rand io.Reader, template *RevocationList, issuer *Certificate, priv crypto.Signer) ([]byte, error)
func (*Certificate).CheckSignatureFrom(parent *Certificate) error
func (*Certificate).Equal(other *Certificate) bool
func (*CertPool).AddCert(cert *Certificate)
type CertificateRequest(struct)
CertificateRequest represents a PKCS #10, certificate signature request.
Attributes contains the CSR attributes that can parse as
pkix.AttributeTypeAndValueSET.
Deprecated: Use Extensions and ExtraExtensions instead for parsing and
generating the requestedExtensions attribute.
Subject Alternate Name values.
EmailAddresses[]string
Extensions contains all requested extensions, in raw form. When parsing
CSRs, this can be used to extract extensions that are not parsed by this
package.
ExtraExtensions contains extensions to be copied, raw, into any CSR
marshaled by CreateCertificateRequest. 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 by ParseCertificateRequest,
see Extensions instead.
IPAddresses[]net.IPPublicKeyinterface{}PublicKeyAlgorithmPublicKeyAlgorithm
// Complete ASN.1 DER content (CSR, signature algorithm and signature).
// DER encoded Subject.
// DER encoded SubjectPublicKeyInfo.
// Certificate request info part of raw ASN.1 DER content.
Signature[]byteSignatureAlgorithmSignatureAlgorithmSubjectpkix.NameURIs[]*url.URLVersionint
CheckSignature reports whether the signature on c is valid.
func ParseCertificateRequest(asn1Data []byte) (*CertificateRequest, error)
func CreateCertificateRequest(rand io.Reader, template *CertificateRequest, priv interface{}) (csr []byte, err error)
type CertPool(struct)
CertPool is a set of certificates.
AddCert adds a certificate to a pool.
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.
Subjects returns a list of the DER-encoded subjects of
all of the certificates in the pool.
func NewCertPool() *CertPool
func SystemCertPool() (*CertPool, error)
type ConstraintViolationError(struct)
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.
( T) Error() string
T : error
type RevocationList(struct)
RevocationList contains the fields used to create an X.509 v2 Certificate
Revocation list with CreateRevocationList.
ExtraExtensions contains any additional extensions to add directly to
the CRL.
NextUpdate is used to populate the nextUpdate field in the CRL, which
indicates the date by which the next CRL will be issued. NextUpdate
must be greater than ThisUpdate.
Number is used to populate the X.509 v2 cRLNumber extension in the CRL,
which should be a monotonically increasing sequence number for a given
CRL scope and CRL issuer.
RevokedCertificates is used to populate the revokedCertificates
sequence in the CRL, it may be empty. RevokedCertificates may be nil,
in which case an empty CRL will be created.
SignatureAlgorithm is used to determine the signature algorithm to be
used when signing the CRL. If 0 the default algorithm for the signing
key will be used.
ThisUpdate is used to populate the thisUpdate field in the CRL, which
indicates the issuance date of the CRL.
func CreateRevocationList(rand io.Reader, template *RevocationList, issuer *Certificate, priv crypto.Signer) ([]byte, error)
type VerifyOptions(struct)
VerifyOptions contains parameters for Certificate.Verify.
CurrentTime is used to check the validity of all certificates in the
chain. If zero, the current time is used.
DNSName, if set, is checked against the leaf certificate with
Certificate.VerifyHostname or the platform verifier.
Intermediates is an optional pool of certificates that are not trust
anchors, but can be used to form a chain from the leaf certificate to a
root certificate.
KeyUsages specifies which Extended Key Usage values are acceptable. A
chain is accepted if it allows any of the listed values. An empty list
means ExtKeyUsageServerAuth. To accept any key usage, include ExtKeyUsageAny.
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 pathological
certificates from consuming excessive amounts of CPU time when
validating. It does not apply to the platform verifier.
Roots is the set of trusted root certificates the leaf certificate needs
to chain up to. If nil, the system roots or the platform verifier are used.
func (*Certificate).Verify(opts VerifyOptions) (chains [][]*Certificate, err error)
Exported Values
const CANotAuthorizedForExtKeyUsageInvalidReason = 9
CANotAuthorizedForExtKeyUsage results when an intermediate or root
certificate does not permit a requested extended key usage.
const CANotAuthorizedForThisNameInvalidReason = 2
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.
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
- CRLDistributionPoints
- DNSNames
- EmailAddresses
- ExcludedDNSDomains
- ExcludedEmailAddresses
- ExcludedIPRanges
- ExcludedURIDomains
- ExtKeyUsage
- ExtraExtensions
- IPAddresses
- IsCA
- IssuingCertificateURL
- KeyUsage
- MaxPathLen
- MaxPathLenZero
- NotAfter
- NotBefore
- OCSPServer
- PermittedDNSDomains
- PermittedDNSDomainsCritical
- PermittedEmailAddresses
- PermittedIPRanges
- PermittedURIDomains
- PolicyIdentifiers
- SerialNumber
- SignatureAlgorithm
- Subject
- SubjectKeyId
- URIs
- 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.
The currently supported key types are *rsa.PublicKey, *ecdsa.PublicKey and
ed25519.PublicKey. pub must be a supported key type, and priv must be a
crypto.Signer with a supported public key.
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.
If SubjectKeyId from template is empty and the template is a CA, SubjectKeyId
will be generated from the hash of the public key.
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:
- SignatureAlgorithm
- Subject
- DNSNames
- EmailAddresses
- IPAddresses
- URIs
- ExtraExtensions
- Attributes (deprecated)
priv is the private key to sign the CSR with, and the corresponding public
key will be included in the CSR. It must implement crypto.Signer and its
Public() method must return a *rsa.PublicKey or a *ecdsa.PublicKey or a
ed25519.PublicKey. (A *rsa.PrivateKey, *ecdsa.PrivateKey or
ed25519.PrivateKey satisfies this.)
The returned slice is the certificate request in DER encoding.
func CreateRevocationList(rand io.Reader, template *RevocationList, issuer *Certificate, priv crypto.Signer) ([]byte, error)
CreateRevocationList creates a new X.509 v2 Certificate Revocation List,
according to RFC 5280, based on template.
The CRL is signed by priv which should be the private key associated with
the public key in the issuer certificate.
The issuer may not be nil, and the crlSign bit must be set in KeyUsage in
order to use it as a CRL issuer.
The issuer distinguished name CRL field and authority key identifier
extension are populated using the issuer certificate. issuer must have
SubjectKeyId set.
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(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.
var ErrUnsupportedAlgorithmerror
ErrUnsupportedAlgorithm results from attempting to perform an operation that
involves algorithms that are not currently implemented.
const ExpiredInvalidReason = 1
Expired results when a certificate has expired, based on the time
given in the VerifyOptions.
const IncompatibleUsageInvalidReason = 4
IncompatibleUsage results when the certificate's key usage indicates
that it may only be used for a different purpose.
func MarshalECPrivateKey(key *ecdsa.PrivateKey) ([]byte, error)
MarshalECPrivateKey converts an EC private key to SEC 1, ASN.1 DER form.
This kind of key is commonly encoded in PEM blocks of type "EC PRIVATE KEY".
For a more flexible key format which is not EC specific, use
MarshalPKCS8PrivateKey.
func MarshalPKCS1PrivateKey(key *rsa.PrivateKey) []byte
MarshalPKCS1PrivateKey converts an RSA private key to PKCS #1, ASN.1 DER form.
This kind of key is commonly encoded in PEM blocks of type "RSA PRIVATE KEY".
For a more flexible key format which is not RSA specific, use
MarshalPKCS8PrivateKey.
func MarshalPKCS1PublicKey(key *rsa.PublicKey) []byte
MarshalPKCS1PublicKey converts an RSA public key to PKCS #1, ASN.1 DER form.
This kind of key is commonly encoded in PEM blocks of type "RSA PUBLIC KEY".
func MarshalPKCS8PrivateKey(key interface{}) ([]byte, error)
MarshalPKCS8PrivateKey converts a private key to PKCS #8, ASN.1 DER form.
The following key types are currently supported: *rsa.PrivateKey, *ecdsa.PrivateKey
and ed25519.PrivateKey. Unsupported key types result in an error.
This kind of key is commonly encoded in PEM blocks of type "PRIVATE KEY".
func MarshalPKIXPublicKey(pub interface{}) ([]byte, error)
MarshalPKIXPublicKey converts a public key to PKIX, ASN.1 DER form.
The encoded public key is a SubjectPublicKeyInfo structure
(see RFC 5280, Section 4.1).
The following key types are currently supported: *rsa.PublicKey, *ecdsa.PublicKey
and ed25519.PublicKey. Unsupported key types result in an error.
This kind of key is commonly encoded in PEM blocks of type "PUBLIC KEY".
const NameConstraintsWithoutSANsInvalidReason = 6
NameConstraintsWithoutSANs results when a leaf certificate doesn't
contain a Subject Alternative Name extension, but a CA certificate
contains name constraints, and the Common Name can be interpreted as
a hostname.
This error is only returned when legacy Common Name matching is enabled
by setting the GODEBUG environment variable to "x509ignoreCN=1". This
setting might be removed in the future.
const NameMismatchInvalidReason = 5
NameMismatch results when the subject name of a parent certificate
does not match the issuer name in the child.
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 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 ParseECPrivateKey(der []byte) (*ecdsa.PrivateKey, error)
ParseECPrivateKey parses an EC private key in SEC 1, ASN.1 DER form.
This kind of key is commonly encoded in PEM blocks of type "EC PRIVATE KEY".
func ParsePKCS1PrivateKey(der []byte) (*rsa.PrivateKey, error)
ParsePKCS1PrivateKey parses an RSA private key in PKCS #1, ASN.1 DER form.
This kind of key is commonly encoded in PEM blocks of type "RSA PRIVATE KEY".
func ParsePKCS1PublicKey(der []byte) (*rsa.PublicKey, error)
ParsePKCS1PublicKey parses an RSA public key in PKCS #1, ASN.1 DER form.
This kind of key is commonly encoded in PEM blocks of type "RSA PUBLIC KEY".
func ParsePKCS8PrivateKey(der []byte) (key interface{}, err error)
ParsePKCS8PrivateKey parses an unencrypted private key in PKCS #8, ASN.1 DER form.
It returns a *rsa.PrivateKey, a *ecdsa.PrivateKey, or a ed25519.PrivateKey.
More types might be supported in the future.
This kind of key is commonly encoded in PEM blocks of type "PRIVATE KEY".
func ParsePKIXPublicKey(derBytes []byte) (pub interface{}, err error)
ParsePKIXPublicKey parses a public key in PKIX, ASN.1 DER form.
The encoded public key is a SubjectPublicKeyInfo structure
(see RFC 5280, Section 4.1).
It returns a *rsa.PublicKey, *dsa.PublicKey, *ecdsa.PublicKey, or
ed25519.PublicKey. More types might be supported in the future.
This kind of key is commonly encoded in PEM blocks of type "PUBLIC KEY".
const PEMCipher3DESPEMCipher = 2
Possible values for the EncryptPEMBlock encryption algorithm.
const PEMCipherAES128PEMCipher = 3
Possible values for the EncryptPEMBlock encryption algorithm.
const PEMCipherAES192PEMCipher = 4
Possible values for the EncryptPEMBlock encryption algorithm.
const PEMCipherAES256PEMCipher = 5
Possible values for the EncryptPEMBlock encryption algorithm.
const PEMCipherDESPEMCipher = 1
Possible values for the EncryptPEMBlock encryption algorithm.
func SystemCertPool() (*CertPool, error)
SystemCertPool returns a copy of the system cert pool.
On Unix systems other than macOS 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. The
latter can be a colon-separated list.
Any mutations to the returned pool are not written to disk and do not affect
any other pool returned by SystemCertPool.
New changes in the system cert pool might not be reflected in subsequent calls.
const TooManyConstraintsInvalidReason = 8
TooManyConstraints results when the number of comparison 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.
const UnconstrainedNameInvalidReason = 7
UnconstrainedName results when a CA certificate contains permitted
name constraints, but leaf certificate contains a name of an
unsupported or unconstrained type.
The pages are generated with Goldsv0.1.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project and developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.
