package x509

Import Path
	crypto/x509 (on go.dev)

Dependency Relation
	imports 36 packages, and imported by 3 packages

Involved Source Files cert_pool.go pem_decrypt.go pkcs1.go pkcs8.go root.go root_darwin.go sec1.go verify.go Package x509 parses X.509-encoded keys and certificates.
Code Examples package main import ( "crypto/x509" "encoding/pem" ) func main() { // Verifying with a custom list of root certificates. 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-----` // First, create the set of root certificates. For this example we only // have one. It's also possible to omit this in order to use the // default root set of the current operating system. 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()) } } package main import ( "crypto/dsa" "crypto/ecdsa" "crypto/ed25519" "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) case ed25519.PublicKey: fmt.Println("pub is of type Ed25519:", pub) default: panic("unknown type of public key") } }
Package-Level Type Names (total 42, in which 18 are exported)
/* sort exporteds by: | */
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 []string ExcludedDNSDomains []string ExcludedEmailAddresses []string ExcludedIPRanges []*net.IPNet ExcludedURIDomains []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.IP IsCA bool Issuer pkix.Name IssuingCertificateURL []string KeyUsage KeyUsage 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 []string PermittedIPRanges []*net.IPNet PermittedURIDomains []string PolicyIdentifiers []asn1.ObjectIdentifier PublicKey interface{} PublicKeyAlgorithm PublicKeyAlgorithm // 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.Int Signature []byte SignatureAlgorithm SignatureAlgorithm Subject pkix.Name SubjectKeyId []byte URIs []*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. Version int 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 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)
CertificateInvalidError results when an odd error occurs. Users of this library probably want to handle all these errors uniformly. Cert *Certificate Detail string Reason InvalidReason ( T) Error() string T : error
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.IP PublicKey interface{} PublicKeyAlgorithm PublicKeyAlgorithm // 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 []byte SignatureAlgorithm SignatureAlgorithm Subject pkix.Name URIs []*url.URL Version int 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)
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)
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
ExtKeyUsage represents an extended set of actions that are valid for a given key. Each of the ExtKeyUsage* constants define a unique action. const ExtKeyUsageAny const ExtKeyUsageClientAuth const ExtKeyUsageCodeSigning const ExtKeyUsageEmailProtection const ExtKeyUsageIPSECEndSystem const ExtKeyUsageIPSECTunnel const ExtKeyUsageIPSECUser const ExtKeyUsageMicrosoftCommercialCodeSigning const ExtKeyUsageMicrosoftKernelCodeSigning const ExtKeyUsageMicrosoftServerGatedCrypto const ExtKeyUsageNetscapeServerGatedCrypto const ExtKeyUsageOCSPSigning const ExtKeyUsageServerAuth const ExtKeyUsageTimeStamping
HostnameError results when the set of authorized names doesn't match the requested name. Certificate *Certificate Host string ( T) Error() string T : error
An InsecureAlgorithmError ( T) Error() string T : error
KeyUsage represents the set of actions that are valid for a given key. It's a bitmap of the KeyUsage* constants. const KeyUsageCertSign const KeyUsageContentCommitment const KeyUsageCRLSign const KeyUsageDataEncipherment const KeyUsageDecipherOnly const KeyUsageDigitalSignature const KeyUsageEncipherOnly const KeyUsageKeyAgreement const KeyUsageKeyEncipherment
func EncryptPEMBlock(rand io.Reader, blockType string, data, password []byte, alg PEMCipher) (*pem.Block, error) const PEMCipher3DES const PEMCipherAES128 const PEMCipherAES192 const PEMCipherAES256 const PEMCipherDES
( T) String() string T : fmt.Stringer const DSA const ECDSA const Ed25519 const RSA const UnknownPublicKeyAlgorithm
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)
( T) String() string T : fmt.Stringer func (*Certificate).CheckSignature(algo SignatureAlgorithm, signed, signature []byte) error const DSAWithSHA1 const DSAWithSHA256 const ECDSAWithSHA1 const ECDSAWithSHA256 const ECDSAWithSHA384 const ECDSAWithSHA512 const MD2WithRSA const MD5WithRSA const PureEd25519 const SHA1WithRSA const SHA256WithRSA const SHA256WithRSAPSS const SHA384WithRSA const SHA384WithRSAPSS const SHA512WithRSA const SHA512WithRSAPSS const UnknownSignatureAlgorithm
SystemRootsError results when we fail to load the system root certificates. Err error ( T) Error() string ( T) Unwrap() error T : error
( T) Error() string T : error
UnknownAuthorityError results when the certificate issuer is unknown Cert *Certificate ( T) Error() string T : error
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)
Package-Level Functions (total 84, in which 23 are exported)
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.
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.
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.
DecryptPEMBlock takes a PEM block encrypted according to RFC 1423 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 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. Deprecated: Legacy PEM encryption as specified in RFC 1423 is insecure by design. Since it does not authenticate the ciphertext, it is vulnerable to padding oracle attacks that can let an attacker recover the plaintext.
EncryptPEMBlock returns a PEM block of the specified type holding the given DER encoded data encrypted with the specified algorithm and password according to RFC 1423. Deprecated: Legacy PEM encryption as specified in RFC 1423 is insecure by design. Since it does not authenticate the ciphertext, it is vulnerable to padding oracle attacks that can let an attacker recover the plaintext.
IsEncryptedPEMBlock returns whether the PEM block is password encrypted according to RFC 1423. Deprecated: Legacy PEM encryption as specified in RFC 1423 is insecure by design. Since it does not authenticate the ciphertext, it is vulnerable to padding oracle attacks that can let an attacker recover the plaintext.
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.
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.
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".
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".
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".
NewCertPool returns a new, empty CertPool.
ParseCertificate parses a single certificate from the given ASN.1 DER data.
ParseCertificateRequest parses a single certificate request from the given ASN.1 DER data.
ParseCertificates parses one or more certificates from the given ASN.1 DER data. The certificates must be concatenated with no intermediate padding.
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.
ParseDERCRL parses a DER encoded CRL from the given bytes.
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".
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".
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".
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".
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".
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.
Package-Level Variables (total 71, in which 2 are exported)
ErrUnsupportedAlgorithm results from attempting to perform an operation that involves algorithms that are not currently implemented.
IncorrectPasswordError is returned when an incorrect password is detected.
Package-Level Constants (total 69, in which 60 are exported)
CANotAuthorizedForExtKeyUsage results when an intermediate or root certificate does not permit a requested extended key usage.
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.
const DSA PublicKeyAlgorithm = 2 // Unsupported.
const DSAWithSHA1 SignatureAlgorithm = 7 // Unsupported.
const DSAWithSHA256 SignatureAlgorithm = 8 // Unsupported.
Expired results when a certificate has expired, based on the time given in the VerifyOptions.
IncompatibleUsage results when the certificate's key usage indicates that it may only be used for a different purpose.
const MD2WithRSA SignatureAlgorithm = 1 // Unsupported.
const MD5WithRSA SignatureAlgorithm = 2 // Only supported for signing, not verification.
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.
NameMismatch results when the subject name of a parent certificate does not match the issuer name in the child.
NotAuthorizedToSign results when a certificate is signed by another which isn't marked as a CA certificate.
Possible values for the EncryptPEMBlock encryption algorithm.
Possible values for the EncryptPEMBlock encryption algorithm.
Possible values for the EncryptPEMBlock encryption algorithm.
Possible values for the EncryptPEMBlock encryption algorithm.
Possible values for the EncryptPEMBlock encryption algorithm.
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.
TooManyIntermediates results when a path length constraint is violated.
UnconstrainedName results when a CA certificate contains permitted name constraints, but leaf certificate contains a name of an unsupported or unconstrained type.