Documentation ¶
Overview ¶
Package x509 parses X.509-encoded keys and certificates.
START CT CHANGES This is a fork of the go library crypto/x509 package, it's more relaxed about certificates that it'll accept, and exports the TBSCertificate structure. END CT CHANGES
Index ¶
- Variables
- func CreateCertificate(rand io.Reader, template, parent *Certificate, pub interface{}, ...) (cert []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) (certList *pkix.CertificateList, err error)
- func ParseDERCRL(derBytes []byte) (certList *pkix.CertificateList, err error)
- func ParseECPrivateKey(der []byte) (key *ecdsa.PrivateKey, err error)
- func ParsePKCS1PrivateKey(der []byte) (key *rsa.PrivateKey, err error)
- func ParsePKCS8PrivateKey(der []byte) (key interface{}, err error)
- func ParsePKIXPublicKey(derBytes []byte) (pub interface{}, err error)
- type CertPool
- type Certificate
- func (c *Certificate) CheckCRLSignature(crl *pkix.CertificateList) (err error)
- func (c *Certificate) CheckSignature(algo SignatureAlgorithm, signed, signature []byte) (err error)
- func (c *Certificate) CheckSignatureFrom(parent *Certificate) (err error)
- func (c *Certificate) CreateCRL(rand io.Reader, priv interface{}, revokedCerts []pkix.RevokedCertificate, ...) (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
- type ConstraintViolationError
- type ExtKeyUsage
- type HostnameError
- type InvalidReason
- type KeyUsage
- type NonFatalErrors
- type PEMCipher
- type PublicKeyAlgorithm
- type SignatureAlgorithm
- type SystemRootsError
- type UnhandledCriticalExtension
- type UnknownAuthorityError
- type VerifyOptions
Constants ¶
This section is empty.
Variables ¶
var ErrUnsupportedAlgorithm = errors.New("x509: cannot verify signature: algorithm unimplemented")
ErrUnsupportedAlgorithm results from attempting to perform an operation that involves algorithms that are not currently implemented.
var IncorrectPasswordError = errors.New("x509: decryption password incorrect")
IncorrectPasswordError is returned when an incorrect password is detected.
Functions ¶
func CreateCertificate ¶
func CreateCertificate(rand io.Reader, template, parent *Certificate, pub interface{}, priv interface{}) (cert []byte, err error)
CreateCertificate creates a new certificate based on a template. The following members of template are used: SerialNumber, Subject, NotBefore, NotAfter, KeyUsage, ExtKeyUsage, UnknownExtKeyUsage, BasicConstraintsValid, IsCA, MaxPathLen, SubjectKeyId, DNSNames, PermittedDNSDomainsCritical, PermittedDNSDomains.
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 only supported key types are RSA and ECDSA (*rsa.PublicKey or *ecdsa.PublicKey for pub, *rsa.PrivateKey or *ecdsa.PublicKey for priv).
func DecryptPEMBlock ¶
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 ¶
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 MarshalPKIXPublicKey ¶
MarshalPKIXPublicKey serialises a public key to DER-encoded PKIX format.
func ParseCRL ¶
func ParseCRL(crlBytes []byte) (certList *pkix.CertificateList, err 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 ParseDERCRL ¶
func ParseDERCRL(derBytes []byte) (certList *pkix.CertificateList, err error)
ParseDERCRL parses a DER encoded CRL from the given bytes.
func ParseECPrivateKey ¶
func ParseECPrivateKey(der []byte) (key *ecdsa.PrivateKey, err error)
ParseECPrivateKey parses an ASN.1 Elliptic Curve Private Key Structure.
func ParsePKCS1PrivateKey ¶
func ParsePKCS1PrivateKey(der []byte) (key *rsa.PrivateKey, err error)
ParsePKCS1PrivateKey returns an RSA private key from its ASN.1 PKCS#1 DER encoded form.
func ParsePKCS8PrivateKey ¶
ParsePKCS8PrivateKey parses an unencrypted, PKCS#8 private key. See http://www.rsa.com/rsalabs/node.asp?id=2130 and RFC5208.
func ParsePKIXPublicKey ¶
ParsePKIXPublicKey parses a DER encoded public key. These values are typically found in PEM blocks with "BEGIN PUBLIC KEY".
Types ¶
type CertPool ¶
type CertPool struct {
// contains filtered or unexported fields
}
CertPool is a set of certificates.
func (*CertPool) AddCert ¶
func (s *CertPool) AddCert(cert *Certificate)
AddCert adds a certificate to a pool.
func (*CertPool) AppendCertsFromPEM ¶
AppendCertsFromPEM attempts to parse a series of PEM encoded certificates. It appends any certificates found to s and returns true if 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.
type 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 ExtKeyUsage []ExtKeyUsage // Sequence of extended key usages. UnknownExtKeyUsage []asn1.ObjectIdentifier // Encountered extended key usages unknown to this package. BasicConstraintsValid bool // if true then the next two fields are valid. IsCA bool MaxPathLen int 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 // Name constraints PermittedDNSDomainsCritical bool // if true then the name constraints are marked critical. PermittedDNSDomains []string // CRL Distribution Points CRLDistributionPoints []string IsPrecert bool PolicyIdentifiers []asn1.ObjectIdentifier }
A Certificate represents an X.509 certificate.
func ParseCertificate ¶
func ParseCertificate(asn1Data []byte) (*Certificate, error)
ParseCertificate parses a single certificate from the given ASN.1 DER data.
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 ParseTBSCertificate ¶
func ParseTBSCertificate(asn1Data []byte) (*Certificate, error)
ParseTBSCertificate parses a single TBSCertificate from the given ASN.1 DER data. The parsed data is returned in a Certificate struct for ease of access.
func (*Certificate) CheckCRLSignature ¶
func (c *Certificate) CheckCRLSignature(crl *pkix.CertificateList) (err error)
CheckCRLSignature checks that the signature in crl is from c.
func (*Certificate) CheckSignature ¶
func (c *Certificate) CheckSignature(algo SignatureAlgorithm, signed, signature []byte) (err 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) (err 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.
The only supported key type is RSA (*rsa.PrivateKey for priv).
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.
WARNING: this doesn't do any revocation checking.
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 ¶
type CertificateInvalidError struct { Cert *Certificate Reason InvalidReason }
CertificateInvalidError results when an odd error occurs. Users of this library probably want to handle all these errors uniformly.
func (CertificateInvalidError) Error ¶
func (e CertificateInvalidError) Error() string
type ConstraintViolationError ¶
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.
func (ConstraintViolationError) Error ¶
func (ConstraintViolationError) Error() string
type ExtKeyUsage ¶
type ExtKeyUsage int
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 ExtKeyUsage = iota ExtKeyUsageServerAuth ExtKeyUsageClientAuth ExtKeyUsageCodeSigning ExtKeyUsageEmailProtection ExtKeyUsageIPSECEndSystem ExtKeyUsageIPSECTunnel ExtKeyUsageIPSECUser ExtKeyUsageTimeStamping ExtKeyUsageOCSPSigning ExtKeyUsageMicrosoftServerGatedCrypto ExtKeyUsageNetscapeServerGatedCrypto )
type HostnameError ¶
type HostnameError struct { Certificate *Certificate Host string }
HostnameError results when the set of authorized names doesn't match the requested name.
func (HostnameError) Error ¶
func (h HostnameError) 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 include the name // being checked. 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 )
type KeyUsage ¶
type KeyUsage int
KeyUsage represents the set of actions that are valid for a given key. It's a bitmap of the KeyUsage* constants.
type NonFatalErrors ¶
type NonFatalErrors struct {
Errors []error
}
NonFatalErrors is an error type which can hold a number of other errors. It's used to collect a range of non-fatal errors which occur while parsing a certificate, that way we can still match on certs which technically are invalid.
func (*NonFatalErrors) AddError ¶
func (e *NonFatalErrors) AddError(err error)
Adds an error to the list of errors contained by NonFatalErrors.
func (NonFatalErrors) Error ¶
func (e NonFatalErrors) Error() string
Returns a string consisting of the values of Error() from all of the errors contained in |e|
func (*NonFatalErrors) HasError ¶
func (e *NonFatalErrors) HasError() bool
Returns true if |e| contains at least one error
type PEMCipher ¶
type PEMCipher int
const ( PEMCipherDES PEMCipher PEMCipher3DES PEMCipherAES128 PEMCipherAES192 PEMCipherAES256 )
Possible values for the EncryptPEMBlock encryption algorithm.
type PublicKeyAlgorithm ¶
type PublicKeyAlgorithm int
const ( UnknownPublicKeyAlgorithm PublicKeyAlgorithm = iota RSA DSA ECDSA )
type SignatureAlgorithm ¶
type SignatureAlgorithm int
const ( UnknownSignatureAlgorithm SignatureAlgorithm = iota MD2WithRSA MD5WithRSA SHA1WithRSA SHA256WithRSA SHA384WithRSA SHA512WithRSA DSAWithSHA1 DSAWithSHA256 ECDSAWithSHA1 ECDSAWithSHA256 ECDSAWithSHA384 ECDSAWithSHA512 )
type SystemRootsError ¶
type SystemRootsError struct { }
SystemRootsError results when we fail to load the system root certificates.
func (SystemRootsError) Error ¶
func (e SystemRootsError) Error() string
type UnhandledCriticalExtension ¶
type UnhandledCriticalExtension struct {
ID asn1.ObjectIdentifier
}
START CT CHANGES
func (UnhandledCriticalExtension) Error ¶
func (h UnhandledCriticalExtension) Error() string
type UnknownAuthorityError ¶
type UnknownAuthorityError struct {
// contains filtered or unexported fields
}
UnknownAuthorityError results when the certificate issuer is unknown
func (UnknownAuthorityError) Error ¶
func (e UnknownAuthorityError) Error() string
type VerifyOptions ¶
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 DisableTimeChecks bool // 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 behaviour, // but not the spec. To accept any key usage, include ExtKeyUsageAny. KeyUsages []ExtKeyUsage }
VerifyOptions contains parameters for Certificate.Verify. It's a structure because other PKIX verification APIs have ended up needing many options.