func (s *fdbStore) validateCert(certID string, c *fdb.Collection) error {
ss, err := fdb.String(c.Open("url"))
if err != nil {
return err
}
ss = strings.TrimSpace(ss)
if !acmeapi.ValidURL(ss) {
return fmt.Errorf("certificate has invalid URI")
}
actualCertID := determineCertificateID(ss)
if certID != actualCertID {
return fmt.Errorf("cert ID mismatch: %#v != %#v", certID, actualCertID)
}
crt := &Certificate{
URL: ss,
Certificates: nil,
Cached: false,
RevocationDesired: fdb.Exists(c, "revoke"),
Revoked: fdb.Exists(c, "revoked"),
}
fullchain, err := fdb.Bytes(c.Open("fullchain"))
if err == nil {
certs, err := acmeutils.LoadCertificates(fullchain)
if err != nil {
return err
}
xcrt, err := x509.ParseCertificate(certs[0])
if err != nil {
return err
}
keyID := determineKeyIDFromCert(xcrt)
crt.Key = s.keys[keyID]
if crt.Key != nil {
err := c.WriteLink("privkey", fdb.Link{Target: "keys/" + keyID + "/privkey"})
if err != nil {
return err
}
}
crt.Certificates = certs
crt.Cached = true
}
s.certs[certID] = crt
return nil
}
func (s *Store) validateTargetInner(desiredKey string, c *fdb.Collection, loadingDefault bool) (*Target, error) {
b, err := fdb.Bytes(c.Open(desiredKey))
if err != nil {
return nil, err
}
var tgt *Target
if loadingDefault {
tgt = &Target{}
} else {
tgt = s.defaultTarget.CopyGeneric()
}
err = yaml.Unmarshal(b, tgt)
if err != nil {
return nil, err
}
if len(tgt.Satisfy.Names) == 0 {
if len(tgt.LegacyNames) > 0 {
tgt.Satisfy.Names = tgt.LegacyNames
} else {
tgt.Satisfy.Names = []string{desiredKey}
}
}
if tgt.Request.Provider == "" {
tgt.Request.Provider = tgt.LegacyProvider
}
err = normalizeNames(tgt.Satisfy.Names)
if err != nil {
return nil, fmt.Errorf("invalid target: %s: %v", desiredKey, err)
}
if len(tgt.Request.Names) == 0 {
tgt.Request.Names = tgt.Satisfy.Names
tgt.Request.implicitNames = true
}
tgt.Request.Account, err = s.getAccountByProviderString(tgt.Request.Provider)
if err != nil {
return nil, err
}
// TODO: tgt.Priority
return tgt, nil
}