a685e3fc98
Vndr has a simpler configuration and allows pointing to forked packages. Additionally other docker projects are now using vndr making vendoring in distribution more consistent. Updates letsencrypt to use fork. No longer uses sub-vendored packages. Signed-off-by: Derek McGowan <derek@mcgstyle.net> (github: dmcgowan)
323 lines
8.6 KiB
Go
323 lines
8.6 KiB
Go
package acme
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto"
|
|
"crypto/ecdsa"
|
|
"crypto/elliptic"
|
|
"crypto/rand"
|
|
"crypto/rsa"
|
|
"crypto/x509"
|
|
"crypto/x509/pkix"
|
|
"encoding/base64"
|
|
"encoding/pem"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"math/big"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"golang.org/x/crypto/ocsp"
|
|
)
|
|
|
|
// KeyType represents the key algo as well as the key size or curve to use.
|
|
type KeyType string
|
|
type derCertificateBytes []byte
|
|
|
|
// Constants for all key types we support.
|
|
const (
|
|
EC256 = KeyType("P256")
|
|
EC384 = KeyType("P384")
|
|
RSA2048 = KeyType("2048")
|
|
RSA4096 = KeyType("4096")
|
|
RSA8192 = KeyType("8192")
|
|
)
|
|
|
|
const (
|
|
// OCSPGood means that the certificate is valid.
|
|
OCSPGood = ocsp.Good
|
|
// OCSPRevoked means that the certificate has been deliberately revoked.
|
|
OCSPRevoked = ocsp.Revoked
|
|
// OCSPUnknown means that the OCSP responder doesn't know about the certificate.
|
|
OCSPUnknown = ocsp.Unknown
|
|
// OCSPServerFailed means that the OCSP responder failed to process the request.
|
|
OCSPServerFailed = ocsp.ServerFailed
|
|
)
|
|
|
|
// GetOCSPForCert takes a PEM encoded cert or cert bundle returning the raw OCSP response,
|
|
// the parsed response, and an error, if any. The returned []byte can be passed directly
|
|
// into the OCSPStaple property of a tls.Certificate. If the bundle only contains the
|
|
// issued certificate, this function will try to get the issuer certificate from the
|
|
// IssuingCertificateURL in the certificate. If the []byte and/or ocsp.Response return
|
|
// values are nil, the OCSP status may be assumed OCSPUnknown.
|
|
func GetOCSPForCert(bundle []byte) ([]byte, *ocsp.Response, error) {
|
|
certificates, err := parsePEMBundle(bundle)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
// We expect the certificate slice to be ordered downwards the chain.
|
|
// SRV CRT -> CA. We need to pull the leaf and issuer certs out of it,
|
|
// which should always be the first two certificates. If there's no
|
|
// OCSP server listed in the leaf cert, there's nothing to do. And if
|
|
// we have only one certificate so far, we need to get the issuer cert.
|
|
issuedCert := certificates[0]
|
|
if len(issuedCert.OCSPServer) == 0 {
|
|
return nil, nil, errors.New("no OCSP server specified in cert")
|
|
}
|
|
if len(certificates) == 1 {
|
|
// TODO: build fallback. If this fails, check the remaining array entries.
|
|
if len(issuedCert.IssuingCertificateURL) == 0 {
|
|
return nil, nil, errors.New("no issuing certificate URL")
|
|
}
|
|
|
|
resp, err := httpGet(issuedCert.IssuingCertificateURL[0])
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
issuerBytes, err := ioutil.ReadAll(limitReader(resp.Body, 1024*1024))
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
issuerCert, err := x509.ParseCertificate(issuerBytes)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
// Insert it into the slice on position 0
|
|
// We want it ordered right SRV CRT -> CA
|
|
certificates = append(certificates, issuerCert)
|
|
}
|
|
issuerCert := certificates[1]
|
|
|
|
// Finally kick off the OCSP request.
|
|
ocspReq, err := ocsp.CreateRequest(issuedCert, issuerCert, nil)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
reader := bytes.NewReader(ocspReq)
|
|
req, err := httpPost(issuedCert.OCSPServer[0], "application/ocsp-request", reader)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
defer req.Body.Close()
|
|
|
|
ocspResBytes, err := ioutil.ReadAll(limitReader(req.Body, 1024*1024))
|
|
ocspRes, err := ocsp.ParseResponse(ocspResBytes, issuerCert)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
if ocspRes.Certificate == nil {
|
|
err = ocspRes.CheckSignatureFrom(issuerCert)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
}
|
|
|
|
return ocspResBytes, ocspRes, nil
|
|
}
|
|
|
|
func getKeyAuthorization(token string, key interface{}) (string, error) {
|
|
var publicKey crypto.PublicKey
|
|
switch k := key.(type) {
|
|
case *ecdsa.PrivateKey:
|
|
publicKey = k.Public()
|
|
case *rsa.PrivateKey:
|
|
publicKey = k.Public()
|
|
}
|
|
|
|
// Generate the Key Authorization for the challenge
|
|
jwk := keyAsJWK(publicKey)
|
|
if jwk == nil {
|
|
return "", errors.New("Could not generate JWK from key.")
|
|
}
|
|
thumbBytes, err := jwk.Thumbprint(crypto.SHA256)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// unpad the base64URL
|
|
keyThumb := base64.URLEncoding.EncodeToString(thumbBytes)
|
|
index := strings.Index(keyThumb, "=")
|
|
if index != -1 {
|
|
keyThumb = keyThumb[:index]
|
|
}
|
|
|
|
return token + "." + keyThumb, nil
|
|
}
|
|
|
|
// parsePEMBundle parses a certificate bundle from top to bottom and returns
|
|
// a slice of x509 certificates. This function will error if no certificates are found.
|
|
func parsePEMBundle(bundle []byte) ([]*x509.Certificate, error) {
|
|
var certificates []*x509.Certificate
|
|
var certDERBlock *pem.Block
|
|
|
|
for {
|
|
certDERBlock, bundle = pem.Decode(bundle)
|
|
if certDERBlock == nil {
|
|
break
|
|
}
|
|
|
|
if certDERBlock.Type == "CERTIFICATE" {
|
|
cert, err := x509.ParseCertificate(certDERBlock.Bytes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
certificates = append(certificates, cert)
|
|
}
|
|
}
|
|
|
|
if len(certificates) == 0 {
|
|
return nil, errors.New("No certificates were found while parsing the bundle.")
|
|
}
|
|
|
|
return certificates, nil
|
|
}
|
|
|
|
func parsePEMPrivateKey(key []byte) (crypto.PrivateKey, error) {
|
|
keyBlock, _ := pem.Decode(key)
|
|
|
|
switch keyBlock.Type {
|
|
case "RSA PRIVATE KEY":
|
|
return x509.ParsePKCS1PrivateKey(keyBlock.Bytes)
|
|
case "EC PRIVATE KEY":
|
|
return x509.ParseECPrivateKey(keyBlock.Bytes)
|
|
default:
|
|
return nil, errors.New("Unknown PEM header value")
|
|
}
|
|
}
|
|
|
|
func generatePrivateKey(keyType KeyType) (crypto.PrivateKey, error) {
|
|
|
|
switch keyType {
|
|
case EC256:
|
|
return ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
|
case EC384:
|
|
return ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
|
|
case RSA2048:
|
|
return rsa.GenerateKey(rand.Reader, 2048)
|
|
case RSA4096:
|
|
return rsa.GenerateKey(rand.Reader, 4096)
|
|
case RSA8192:
|
|
return rsa.GenerateKey(rand.Reader, 8192)
|
|
}
|
|
|
|
return nil, fmt.Errorf("Invalid KeyType: %s", keyType)
|
|
}
|
|
|
|
func generateCsr(privateKey crypto.PrivateKey, domain string, san []string) ([]byte, error) {
|
|
template := x509.CertificateRequest{
|
|
Subject: pkix.Name{
|
|
CommonName: domain,
|
|
},
|
|
}
|
|
|
|
if len(san) > 0 {
|
|
template.DNSNames = san
|
|
}
|
|
|
|
return x509.CreateCertificateRequest(rand.Reader, &template, privateKey)
|
|
}
|
|
|
|
func pemEncode(data interface{}) []byte {
|
|
var pemBlock *pem.Block
|
|
switch key := data.(type) {
|
|
case *ecdsa.PrivateKey:
|
|
keyBytes, _ := x509.MarshalECPrivateKey(key)
|
|
pemBlock = &pem.Block{Type: "EC PRIVATE KEY", Bytes: keyBytes}
|
|
case *rsa.PrivateKey:
|
|
pemBlock = &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)}
|
|
break
|
|
case derCertificateBytes:
|
|
pemBlock = &pem.Block{Type: "CERTIFICATE", Bytes: []byte(data.(derCertificateBytes))}
|
|
}
|
|
|
|
return pem.EncodeToMemory(pemBlock)
|
|
}
|
|
|
|
func pemDecode(data []byte) (*pem.Block, error) {
|
|
pemBlock, _ := pem.Decode(data)
|
|
if pemBlock == nil {
|
|
return nil, fmt.Errorf("Pem decode did not yield a valid block. Is the certificate in the right format?")
|
|
}
|
|
|
|
return pemBlock, nil
|
|
}
|
|
|
|
func pemDecodeTox509(pem []byte) (*x509.Certificate, error) {
|
|
pemBlock, err := pemDecode(pem)
|
|
if pemBlock == nil {
|
|
return nil, err
|
|
}
|
|
|
|
return x509.ParseCertificate(pemBlock.Bytes)
|
|
}
|
|
|
|
// GetPEMCertExpiration returns the "NotAfter" date of a PEM encoded certificate.
|
|
// The certificate has to be PEM encoded. Any other encodings like DER will fail.
|
|
func GetPEMCertExpiration(cert []byte) (time.Time, error) {
|
|
pemBlock, err := pemDecode(cert)
|
|
if pemBlock == nil {
|
|
return time.Time{}, err
|
|
}
|
|
|
|
return getCertExpiration(pemBlock.Bytes)
|
|
}
|
|
|
|
// getCertExpiration returns the "NotAfter" date of a DER encoded certificate.
|
|
func getCertExpiration(cert []byte) (time.Time, error) {
|
|
pCert, err := x509.ParseCertificate(cert)
|
|
if err != nil {
|
|
return time.Time{}, err
|
|
}
|
|
|
|
return pCert.NotAfter, nil
|
|
}
|
|
|
|
func generatePemCert(privKey *rsa.PrivateKey, domain string) ([]byte, error) {
|
|
derBytes, err := generateDerCert(privKey, time.Time{}, domain)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: derBytes}), nil
|
|
}
|
|
|
|
func generateDerCert(privKey *rsa.PrivateKey, expiration time.Time, domain string) ([]byte, error) {
|
|
serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
|
|
serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if expiration.IsZero() {
|
|
expiration = time.Now().Add(365)
|
|
}
|
|
|
|
template := x509.Certificate{
|
|
SerialNumber: serialNumber,
|
|
Subject: pkix.Name{
|
|
CommonName: "ACME Challenge TEMP",
|
|
},
|
|
NotBefore: time.Now(),
|
|
NotAfter: expiration,
|
|
|
|
KeyUsage: x509.KeyUsageKeyEncipherment,
|
|
BasicConstraintsValid: true,
|
|
DNSNames: []string{domain},
|
|
}
|
|
|
|
return x509.CreateCertificate(rand.Reader, &template, &template, &privKey.PublicKey, privKey)
|
|
}
|
|
|
|
func limitReader(rd io.ReadCloser, numBytes int64) io.ReadCloser {
|
|
return http.MaxBytesReader(nil, rd, numBytes)
|
|
}
|