rcodezero.go raw

   1  // Package rcodezero implements a DNS provider for solving the DNS-01 challenge using RcodeZero Anycast network.
   2  package rcodezero
   3  
   4  import (
   5  	"context"
   6  	"errors"
   7  	"fmt"
   8  	"net/http"
   9  	"time"
  10  
  11  	"github.com/go-acme/lego/v4/challenge"
  12  	"github.com/go-acme/lego/v4/challenge/dns01"
  13  	"github.com/go-acme/lego/v4/platform/config/env"
  14  	"github.com/go-acme/lego/v4/providers/dns/internal/clientdebug"
  15  	"github.com/go-acme/lego/v4/providers/dns/rcodezero/internal"
  16  )
  17  
  18  // Environment variables names.
  19  const (
  20  	envNamespace = "RCODEZERO_"
  21  
  22  	EnvAPIToken = envNamespace + "API_TOKEN"
  23  
  24  	EnvTTL                = envNamespace + "TTL"
  25  	EnvPropagationTimeout = envNamespace + "PROPAGATION_TIMEOUT"
  26  	EnvPollingInterval    = envNamespace + "POLLING_INTERVAL"
  27  	EnvHTTPTimeout        = envNamespace + "HTTP_TIMEOUT"
  28  )
  29  
  30  var _ challenge.ProviderTimeout = (*DNSProvider)(nil)
  31  
  32  // Config is used to configure the creation of the DNSProvider.
  33  type Config struct {
  34  	APIToken           string
  35  	PropagationTimeout time.Duration
  36  	PollingInterval    time.Duration
  37  	TTL                int
  38  	HTTPClient         *http.Client
  39  }
  40  
  41  // NewDefaultConfig returns a default configuration for the DNSProvider.
  42  func NewDefaultConfig() *Config {
  43  	return &Config{
  44  		TTL:                env.GetOrDefaultInt(EnvTTL, dns01.DefaultTTL),
  45  		PropagationTimeout: env.GetOrDefaultSecond(EnvPropagationTimeout, 4*time.Minute),
  46  		PollingInterval:    env.GetOrDefaultSecond(EnvPollingInterval, 10*time.Second),
  47  		HTTPClient: &http.Client{
  48  			Timeout: env.GetOrDefaultSecond(EnvHTTPTimeout, 30*time.Second),
  49  		},
  50  	}
  51  }
  52  
  53  // DNSProvider implements the challenge.Provider interface.
  54  type DNSProvider struct {
  55  	config *Config
  56  	client *internal.Client
  57  }
  58  
  59  // NewDNSProvider returns a DNSProvider instance configured for RcodeZero.
  60  // Credentials must be passed in the environment variable:
  61  // RCODEZERO_API_URL and RCODEZERO_API_TOKEN.
  62  func NewDNSProvider() (*DNSProvider, error) {
  63  	values, err := env.Get(EnvAPIToken)
  64  	if err != nil {
  65  		return nil, fmt.Errorf("rcodezero: %w", err)
  66  	}
  67  
  68  	config := NewDefaultConfig()
  69  	config.APIToken = values[EnvAPIToken]
  70  
  71  	return NewDNSProviderConfig(config)
  72  }
  73  
  74  // NewDNSProviderConfig return a DNSProvider instance configured for RcodeZero.
  75  func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
  76  	if config == nil {
  77  		return nil, errors.New("rcodezero: the configuration of the DNS provider is nil")
  78  	}
  79  
  80  	if config.APIToken == "" {
  81  		return nil, errors.New("rcodezero: API token missing")
  82  	}
  83  
  84  	client := internal.NewClient(config.APIToken)
  85  
  86  	if config.HTTPClient != nil {
  87  		client.HTTPClient = config.HTTPClient
  88  	}
  89  
  90  	client.HTTPClient = clientdebug.Wrap(client.HTTPClient)
  91  
  92  	return &DNSProvider{config: config, client: client}, nil
  93  }
  94  
  95  // Timeout returns the timeout and interval to use when checking for DNS propagation.
  96  // Adjusting here to cope with spikes in propagation times.
  97  func (d *DNSProvider) Timeout() (timeout, interval time.Duration) {
  98  	return d.config.PropagationTimeout, d.config.PollingInterval
  99  }
 100  
 101  // Present creates a TXT record to fulfill the dns-01 challenge.
 102  func (d *DNSProvider) Present(domain, token, keyAuth string) error {
 103  	info := dns01.GetChallengeInfo(domain, keyAuth)
 104  
 105  	ctx := context.Background()
 106  
 107  	authZone, err := dns01.FindZoneByFqdn(info.EffectiveFQDN)
 108  	if err != nil {
 109  		return fmt.Errorf("rcodezero: could not find zone for domain %q: %w", domain, err)
 110  	}
 111  
 112  	rrSet := []internal.UpdateRRSet{{
 113  		Name:       info.EffectiveFQDN,
 114  		ChangeType: "update",
 115  		Type:       "TXT",
 116  		TTL:        d.config.TTL,
 117  		Records:    []internal.Record{{Content: `"` + info.Value + `"`}},
 118  	}}
 119  
 120  	_, err = d.client.UpdateRecords(ctx, authZone, rrSet)
 121  	if err != nil {
 122  		return fmt.Errorf("rcodezero: %w", err)
 123  	}
 124  
 125  	return nil
 126  }
 127  
 128  // CleanUp removes the TXT record matching the specified parameters.
 129  func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
 130  	info := dns01.GetChallengeInfo(domain, keyAuth)
 131  
 132  	ctx := context.Background()
 133  
 134  	authZone, err := dns01.FindZoneByFqdn(info.EffectiveFQDN)
 135  	if err != nil {
 136  		return fmt.Errorf("rcodezero: could not find zone for domain %q: %w", domain, err)
 137  	}
 138  
 139  	rrSet := []internal.UpdateRRSet{{
 140  		Name:       info.EffectiveFQDN,
 141  		Type:       "TXT",
 142  		ChangeType: "delete",
 143  	}}
 144  
 145  	_, err = d.client.UpdateRecords(ctx, authZone, rrSet)
 146  	if err != nil {
 147  		return fmt.Errorf("rcodezero: %w", err)
 148  	}
 149  
 150  	return nil
 151  }
 152