diff --git a/README.md b/README.md
index f2f84c0..39bb409 100644
--- a/README.md
+++ b/README.md
@@ -18,6 +18,7 @@ Get the container image from [ghcr.io](https://github.com/0xFelix/hetzner-dnsapi
| API | Endpoint |
|--------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| lego HTTP request | POST `/httpreq/present`
POST `/httpreq/cleanup`
(see https://go-acme.github.io/lego/dns/httpreq/) |
+| Generic records | POST `/records/present`
POST `/records/cleanup`
(JSON body `fqdn`, `type` (A, AAAA, TXT, CNAME or SRV) and `value`; SRV values are `priority weight port target` and are added to existing SRV records of the same name, all other types replace existing records; CNAME/SRV targets are made absolute; opt-in, see [Enabled endpoints](#enabled-endpoints)) |
| ACMEDNS | POST `/acmedns/update`
(see https://github.com/joohoi/acme-dns#update-endpoint) |
| DirectAdmin Legacy | GET `/directadmin/CMD_API_SHOW_DOMAINS`
GET `/directadmin/CMD_API_DNS_CONTROL` (only adding A/AAAA/TXT records, everything else always returns `200 OK`)
GET `/directadmin/CMD_API_DOMAIN_POINTER` (only a stub, always returns `200 OK`)
(see https://docs.directadmin.com/developer/api/legacy-api.html and https://www.directadmin.com/features.php?id=504) |
| plain HTTP | GET `/plain/update` (query params `hostname` and `ip` (can be ipv4 for A or ipv6 for AAAA records), if auth method is `users` then HTTP Basic auth is used)
|
@@ -98,6 +99,8 @@ active by listing only the ones you want:
- `acmedns` - `/acmedns/update`
- `httpreq` - `/httpreq/present`, `/httpreq/cleanup`
- `directadmin` - `/directadmin/CMD_API_*`
+- `records` - `/records/present`, `/records/cleanup` (supports CNAME and SRV,
+ **not** enabled by default, must be listed explicitly)
Via config file set the `endpoints` key; via environment variable set
`ENDPOINTS` to a comma-separated list (e.g. `ENDPOINTS=plain,nic`). Listing
@@ -166,5 +169,5 @@ debug: false
| `LOCKOUT_MAX_ATTEMPTS` | int | Failures before lockout | N | `10` |
| `LOCKOUT_DURATION_SECONDS` | int | Lockout duration in seconds | N | `3600` |
| `LOCKOUT_WINDOW_SECONDS` | int | Window in seconds during which consecutive failures accumulate | N | `900` |
-| `ENDPOINTS` | string | Comma-separated list of endpoint groups to enable: `plain`, `nic`, `acmedns`, `httpreq`, `directadmin`. All enabled when unset. | N | All enabled |
+| `ENDPOINTS` | string | Comma-separated list of endpoint groups to enable: `plain`, `nic`, `acmedns`, `httpreq`, `directadmin`, `records`. All but `records` enabled when unset. | N | All but `records` |
| `DEBUG` | bool | Output debug logs of received requests | N | `false` |
diff --git a/pkg/app/app.go b/pkg/app/app.go
index a5b042d..b931222 100644
--- a/pkg/app/app.go
+++ b/pkg/app/app.go
@@ -63,6 +63,12 @@ func New(cfg *config.Config) http.Handler {
mux.Handle("POST /httpreq/cleanup",
handle(cfg, rl, middleware.ContentTypeJSON, middleware.BindHTTPReq, authorizer, cleaner, middleware.StatusOk))
}
+ if cfg.Endpoints.Records {
+ mux.Handle("POST /records/present",
+ handle(cfg, rl, middleware.ContentTypeJSON, middleware.BindRecords, authorizer, updater, middleware.StatusOk))
+ mux.Handle("POST /records/cleanup",
+ handle(cfg, rl, middleware.ContentTypeJSON, middleware.BindRecords, authorizer, cleaner, middleware.StatusOk))
+ }
if cfg.Endpoints.DirectAdmin {
mux.Handle("GET /directadmin/CMD_API_SHOW_DOMAINS",
handle(cfg, rl, middleware.NewShowDomainsDirectAdmin(cfg, lockout)))
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 5bad855..7632811 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -77,6 +77,7 @@ type Endpoints struct {
AcmeDNS bool `yaml:"acmedns"`
HTTPReq bool `yaml:"httpreq"`
DirectAdmin bool `yaml:"directadmin"`
+ Records bool `yaml:"records"`
}
func (e *Endpoints) Enabled() []string {
@@ -96,6 +97,9 @@ func (e *Endpoints) Enabled() []string {
if e.DirectAdmin {
names = append(names, EndpointDirectAdmin)
}
+ if e.Records {
+ names = append(names, EndpointRecords)
+ }
return names
}
@@ -121,6 +125,7 @@ const (
EndpointAcmeDNS = "acmedns"
EndpointHTTPReq = "httpreq"
EndpointDirectAdmin = "directadmin"
+ EndpointRecords = "records"
)
const (
@@ -298,6 +303,8 @@ func envEndpoints(endpoints *Endpoints) error {
endpoints.HTTPReq = true
case EndpointDirectAdmin:
endpoints.DirectAdmin = true
+ case EndpointRecords:
+ endpoints.Records = true
default:
return fmt.Errorf("invalid endpoint %q in ENDPOINTS", name)
}
diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go
index 29c81e6..14a5fea 100644
--- a/pkg/config/config_test.go
+++ b/pkg/config/config_test.go
@@ -127,6 +127,7 @@ var _ = Describe("Config", func() {
envDebug = "DEBUG"
envRateLimitRPS = "RATE_LIMIT_RPS"
envLockoutMaxAtt = "LOCKOUT_MAX_ATTEMPTS"
+ envEndpoints = "ENDPOINTS"
)
BeforeEach(func() {
@@ -146,6 +147,7 @@ var _ = Describe("Config", func() {
Expect(os.Unsetenv(envDebug)).To(Succeed())
Expect(os.Unsetenv(envRateLimitRPS)).To(Succeed())
Expect(os.Unsetenv(envLockoutMaxAtt)).To(Succeed())
+ Expect(os.Unsetenv(envEndpoints)).To(Succeed())
})
It("should parse environment successfully", func() {
@@ -187,6 +189,28 @@ var _ = Describe("Config", func() {
}))
})
+ It("should enable all endpoints but records when ENDPOINTS is unset", func() {
+ Expect(os.Setenv(envAPIToken, apiToken)).To(Succeed())
+ Expect(os.Setenv(envAllowedDomains, allowedDomainsStr)).To(Succeed())
+
+ cfg, err := config.ParseEnv()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(cfg.Endpoints).To(Equal(config.Endpoints{
+ Plain: true, Nic: true, AcmeDNS: true, HTTPReq: true, DirectAdmin: true,
+ }))
+ })
+
+ It("should enable only the endpoints listed in ENDPOINTS", func() {
+ Expect(os.Setenv(envAPIToken, apiToken)).To(Succeed())
+ Expect(os.Setenv(envAllowedDomains, allowedDomainsStr)).To(Succeed())
+ Expect(os.Setenv(envEndpoints, "plain, records")).To(Succeed())
+
+ cfg, err := config.ParseEnv()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(cfg.Endpoints).To(Equal(config.Endpoints{Plain: true, Records: true}))
+ Expect(cfg.Endpoints.Enabled()).To(Equal([]string{config.EndpointPlain, config.EndpointRecords}))
+ })
+
It("should lowercase domains of ALLOWED_DOMAINS", func() {
Expect(os.Setenv(envAPIToken, apiToken)).To(Succeed())
Expect(os.Setenv(envAllowedDomains, "Example.COM,127.0.0.1/32")).To(Succeed())
@@ -243,6 +267,11 @@ var _ = Describe("Config", func() {
Expect(os.Setenv(envAllowedDomains, allowedDomainsStr)).To(Succeed())
Expect(os.Setenv(envLockoutMaxAtt, "0")).To(Succeed())
}, "lockout.maxAttempts must be > 0"),
+ Entry("ENDPOINTS contains an unknown endpoint", func() {
+ Expect(os.Setenv(envAPIToken, apiToken)).To(Succeed())
+ Expect(os.Setenv(envAllowedDomains, allowedDomainsStr)).To(Succeed())
+ Expect(os.Setenv(envEndpoints, "plain,unknown")).To(Succeed())
+ }, `invalid endpoint "unknown" in ENDPOINTS`),
)
})
diff --git a/pkg/hetzner/hcloud.go b/pkg/hetzner/hcloud.go
index 9be62ff..1c85425 100644
--- a/pkg/hetzner/hcloud.go
+++ b/pkg/hetzner/hcloud.go
@@ -51,10 +51,11 @@ func RRSetTypeFromString(rType string) (hcloud.ZoneRRSetType, error) {
switch rrType := hcloud.ZoneRRSetType(rType); rrType {
case hcloud.ZoneRRSetTypeA,
hcloud.ZoneRRSetTypeAAAA,
+ hcloud.ZoneRRSetTypeCNAME,
+ hcloud.ZoneRRSetTypeSRV,
hcloud.ZoneRRSetTypeTXT:
return rrType, nil
case hcloud.ZoneRRSetTypeCAA,
- hcloud.ZoneRRSetTypeCNAME,
hcloud.ZoneRRSetTypeDS,
hcloud.ZoneRRSetTypeHINFO,
hcloud.ZoneRRSetTypeHTTPS,
@@ -63,7 +64,6 @@ func RRSetTypeFromString(rType string) (hcloud.ZoneRRSetType, error) {
hcloud.ZoneRRSetTypePTR,
hcloud.ZoneRRSetTypeRP,
hcloud.ZoneRRSetTypeSOA,
- hcloud.ZoneRRSetTypeSRV,
hcloud.ZoneRRSetTypeSVCB,
hcloud.ZoneRRSetTypeTLSA:
return "", fmt.Errorf("unsupported resource record set type %s", rrType)
diff --git a/pkg/middleware/bind.go b/pkg/middleware/bind.go
index baefeef..a088342 100644
--- a/pkg/middleware/bind.go
+++ b/pkg/middleware/bind.go
@@ -7,6 +7,8 @@ import (
"log"
"net/http"
"net/netip"
+ "regexp"
+ "strconv"
"strings"
"golang.org/x/net/publicsuffix"
@@ -18,10 +20,16 @@ const (
recordTypeA = "A"
recordTypeAAAA = "AAAA"
recordTypeTXT = "TXT"
+ recordTypeCNAME = "CNAME"
+ recordTypeSRV = "SRV"
failedParseRequestFmt = "failed to parse request: %v"
maxRequestBodySize = 1 << 10 // 1 KB
+ maxHostnameLength = 253
+ srvFieldCount = 4
)
+var hostnameRegexp = regexp.MustCompile(`^([a-z0-9_]([a-z0-9_-]{0,61}[a-z0-9_])?\.)*[a-z0-9_]([a-z0-9_-]{0,61}[a-z0-9_])?$`)
+
func BindPlain(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
r.Body = http.MaxBytesReader(w, r.Body, maxRequestBodySize)
@@ -180,6 +188,67 @@ func BindHTTPReq(next http.Handler) http.Handler {
})
}
+// BindRecords binds requests of the generic records endpoint, which in
+// addition to A, AAAA and TXT also supports CNAME and SRV records.
+func BindRecords(next http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ r.Body = http.MaxBytesReader(w, r.Body, maxRequestBodySize)
+ d := &struct {
+ FQDN string `json:"fqdn"`
+ Type string `json:"type"`
+ Value string `json:"value"`
+ }{}
+ if err := json.UnmarshalRead(r.Body, d); err != nil {
+ log.Printf(failedParseRequestFmt, err)
+ w.WriteHeader(http.StatusBadRequest)
+ return
+ }
+
+ if d.FQDN == "" || d.Type == "" || d.Value == "" {
+ http.Error(w, "fqdn, type or value is missing", http.StatusBadRequest)
+ return
+ }
+
+ recordType := strings.ToUpper(d.Type)
+ fqdn := NormalizeFQDN(d.FQDN)
+ name, zone, err := SplitFQDN(fqdn)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusBadRequest)
+ return
+ }
+
+ if recordType == recordTypeCNAME && name == "" {
+ http.Error(w, "a CNAME record is not allowed at the zone apex", http.StatusBadRequest)
+ return
+ }
+
+ value, err := normalizeRecordValue(d.Value, recordType)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusBadRequest)
+ return
+ }
+
+ username, password, _ := r.BasicAuth()
+ next.ServeHTTP(
+ w, r.WithContext(
+ data.NewContextWithReqData(
+ r.Context(),
+ &data.ReqData{
+ FullName: fqdn,
+ Name: name,
+ Zone: zone,
+ Value: value,
+ Type: recordType,
+ Username: username,
+ Password: password,
+ BasicAuth: true,
+ },
+ ),
+ ),
+ )
+ })
+}
+
func BindDirectAdmin(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
r.Body = http.MaxBytesReader(w, r.Body, maxRequestBodySize)
@@ -262,6 +331,57 @@ func validateValue(value, recordType string) error {
return nil
}
+// normalizeRecordValue validates the value for the given record type and
+// returns it in the form expected by the API. Hostnames in CNAME and SRV
+// values are made absolute by appending a trailing dot.
+func normalizeRecordValue(value, recordType string) (string, error) {
+ switch recordType {
+ case recordTypeA, recordTypeAAAA:
+ return value, validateValue(value, recordType)
+ case recordTypeTXT:
+ return value, nil
+ case recordTypeCNAME:
+ target, err := normalizeHostname(value)
+ if err != nil {
+ return "", err
+ }
+ return target + ".", nil
+ case recordTypeSRV:
+ // priority weight port target
+ fields := strings.Fields(value)
+ if len(fields) != srvFieldCount {
+ return "", errors.New("srv value must be 'priority weight port target'")
+ }
+ for i, f := range fields[:srvFieldCount-1] {
+ n, err := strconv.ParseUint(f, 10, 16)
+ if err != nil {
+ return "", errors.New("srv priority, weight and port must be numbers between 0 and 65535")
+ }
+ // Canonicalize, e.g. strip leading zeros, so values compare equal
+ fields[i] = strconv.FormatUint(n, 10)
+ }
+ // A target of '.' means that the service is not available.
+ if fields[srvFieldCount-1] != "." {
+ target, err := normalizeHostname(fields[srvFieldCount-1])
+ if err != nil {
+ return "", err
+ }
+ fields[srvFieldCount-1] = target + "."
+ }
+ return strings.Join(fields, " "), nil
+ default:
+ return "", errors.New("type can only be A, AAAA, TXT, CNAME or SRV")
+ }
+}
+
+func normalizeHostname(host string) (string, error) {
+ host = NormalizeFQDN(host)
+ if len(host) > maxHostnameLength || !hostnameRegexp.MatchString(host) {
+ return "", errors.New("invalid hostname")
+ }
+ return host, nil
+}
+
// NormalizeFQDN strips trailing dots and lowercases the name, so that
// comparisons against configured domains are case-insensitive.
func NormalizeFQDN(fqdn string) string {
diff --git a/pkg/middleware/bind_test.go b/pkg/middleware/bind_test.go
index 3306191..1a8943d 100644
--- a/pkg/middleware/bind_test.go
+++ b/pkg/middleware/bind_test.go
@@ -152,6 +152,70 @@ var _ = Describe("Binding of names", func() {
Entry("trailing dot", "example.com.", "sub"),
Entry("upper case", "Example.COM", "SUB"),
)
+
+ DescribeTable(
+ "should bind records requests", func(fqdn, recordType, value, expectedName, expectedType, expectedValue string) {
+ reqData, code := bind(middleware.BindRecords, newJSONRequest(
+ `{"fqdn":"`+fqdn+`","type":"`+recordType+`","value":"`+value+`"}`,
+ ))
+ Expect(code).To(Equal(http.StatusOK))
+ Expect(reqData.Name).To(Equal(expectedName))
+ Expect(reqData.Zone).To(Equal("example.com"))
+ Expect(reqData.Type).To(Equal(expectedType))
+ Expect(reqData.Value).To(Equal(expectedValue))
+ },
+ Entry("A", "sub.example.com", "A", "127.0.0.1", "sub", "A", "127.0.0.1"),
+ Entry("AAAA", "sub.example.com", "AAAA", "::1", "sub", "AAAA", "::1"),
+ Entry("TXT at the zone apex", "example.com", "TXT", "some text", "", "TXT", "some text"),
+ Entry("lower case type", "sub.example.com", "cname", "target.example.com", "sub", "CNAME", "target.example.com."),
+ Entry("CNAME", "sub.example.com", "CNAME", "target.example.com", "sub", "CNAME", "target.example.com."),
+ Entry(
+ "CNAME with absolute upper case target", "SUB.example.com.", "CNAME", "Target.Example.COM.",
+ "sub", "CNAME", "target.example.com.",
+ ),
+ Entry("CNAME with underscore", "sub.example.com", "CNAME", "_dkim.example.com", "sub", "CNAME", "_dkim.example.com."),
+ Entry("SRV", "_sip._tcp.example.com", "SRV", "10 5 5060 sip.example.com", "_sip._tcp", "SRV", "10 5 5060 sip.example.com."),
+ Entry(
+ "SRV with extra whitespace", "_sip._tcp.example.com", "SRV", ` 10 5 5060\tSIP.example.com. `,
+ "_sip._tcp", "SRV", "10 5 5060 sip.example.com.",
+ ),
+ Entry(
+ "SRV with maximum values", "_sip._tcp.example.com", "SRV", "65535 65535 65535 sip.example.com",
+ "_sip._tcp", "SRV", "65535 65535 65535 sip.example.com.",
+ ),
+ Entry(
+ "SRV with leading zeros", "_sip._tcp.example.com", "SRV", "00 05 05060 sip.example.com",
+ "_sip._tcp", "SRV", "0 5 5060 sip.example.com.",
+ ),
+ Entry("SRV with unavailable service", "_sip._tcp.example.com", "SRV", "0 0 0 .", "_sip._tcp", "SRV", "0 0 0 ."),
+ )
+
+ DescribeTable(
+ "should reject invalid records requests", func(body string) {
+ reqData, code := bind(middleware.BindRecords, newJSONRequest(body))
+ Expect(code).To(Equal(http.StatusBadRequest))
+ Expect(reqData).To(BeNil())
+ },
+ Entry("missing fqdn", `{"type":"A","value":"127.0.0.1"}`),
+ Entry("missing type", `{"fqdn":"sub.example.com","value":"127.0.0.1"}`),
+ Entry("missing value", `{"fqdn":"sub.example.com","type":"A"}`),
+ Entry("unsupported type", `{"fqdn":"sub.example.com","type":"MX","value":"10 mx.example.com"}`),
+ Entry("invalid fqdn", `{"fqdn":"com","type":"A","value":"127.0.0.1"}`),
+ Entry("A with ipv6 address", `{"fqdn":"sub.example.com","type":"A","value":"::1"}`),
+ Entry("AAAA with ipv4 address", `{"fqdn":"sub.example.com","type":"AAAA","value":"127.0.0.1"}`),
+ Entry("CNAME at the zone apex", `{"fqdn":"example.com","type":"CNAME","value":"target.example.com"}`),
+ Entry("CNAME with space in target", `{"fqdn":"sub.example.com","type":"CNAME","value":"a b.example.com"}`),
+ Entry("CNAME with empty label", `{"fqdn":"sub.example.com","type":"CNAME","value":"a..example.com"}`),
+ Entry("CNAME with leading hyphen", `{"fqdn":"sub.example.com","type":"CNAME","value":"-a.example.com"}`),
+ Entry("CNAME with too long label", `{"fqdn":"sub.example.com","type":"CNAME","value":"`+strings.Repeat("a", 64)+`.example.com"}`),
+ Entry("CNAME with too long target", `{"fqdn":"sub.example.com","type":"CNAME","value":"`+strings.Repeat("a.", 127)+`com"}`),
+ Entry("SRV with too few fields", `{"fqdn":"_sip._tcp.example.com","type":"SRV","value":"10 5 sip.example.com"}`),
+ Entry("SRV with too many fields", `{"fqdn":"_sip._tcp.example.com","type":"SRV","value":"10 5 5060 sip.example.com x"}`),
+ Entry("SRV with negative priority", `{"fqdn":"_sip._tcp.example.com","type":"SRV","value":"-1 5 5060 sip.example.com"}`),
+ Entry("SRV with non-numeric weight", `{"fqdn":"_sip._tcp.example.com","type":"SRV","value":"10 x 5060 sip.example.com"}`),
+ Entry("SRV with port out of range", `{"fqdn":"_sip._tcp.example.com","type":"SRV","value":"10 5 65536 sip.example.com"}`),
+ Entry("SRV with invalid target", `{"fqdn":"_sip._tcp.example.com","type":"SRV","value":"10 5 5060 sip..example.com"}`),
+ )
})
var _ = Describe("JSON binding", func() {
diff --git a/pkg/middleware/update/cloud/cloud.go b/pkg/middleware/update/cloud/cloud.go
index a7978c9..8064ab7 100644
--- a/pkg/middleware/update/cloud/cloud.go
+++ b/pkg/middleware/update/cloud/cloud.go
@@ -2,6 +2,7 @@ package cloud
import (
"context"
+ "strings"
"github.com/hetznercloud/hcloud-go/v2/hcloud"
@@ -40,24 +41,37 @@ func (u *updater) Update(ctx context.Context, reqData *data.ReqData) error {
}
if rrSet != nil {
+ // SRV records are commonly spread over several records with the
+ // same name, so they are added to the RRSet instead of replacing it.
+ if rrSetType == hcloud.ZoneRRSetTypeSRV {
+ return u.addRecord(ctx, rrSet, reqData.Value)
+ }
return u.updateRRSet(ctx, rrSet, reqData.Value)
}
return u.createRRSet(ctx, zone, rrSetType, name, reqData.Value)
}
+func (u *updater) changeTTL(ctx context.Context, rrSet *hcloud.ZoneRRSet) error {
+ if rrSet.TTL != nil && *rrSet.TTL == u.cfg.RecordTTL {
+ return nil
+ }
+
+ opts := hcloud.ZoneRRSetChangeTTLOpts{TTL: &u.cfg.RecordTTL}
+ action, _, err := u.client.Zone.ChangeRRSetTTL(ctx, rrSet, opts)
+ if err != nil {
+ return err
+ }
+ if action != nil {
+ return u.client.Action.WaitFor(ctx, action)
+ }
+
+ return nil
+}
+
func (u *updater) updateRRSet(ctx context.Context, rrSet *hcloud.ZoneRRSet, val string) error {
- if rrSet.TTL == nil || *rrSet.TTL != u.cfg.RecordTTL {
- opts := hcloud.ZoneRRSetChangeTTLOpts{TTL: &u.cfg.RecordTTL}
- action, _, err := u.client.Zone.ChangeRRSetTTL(ctx, rrSet, opts)
- if err != nil {
- return err
- }
- if action != nil {
- if err := u.client.Action.WaitFor(ctx, action); err != nil {
- return err
- }
- }
+ if err := u.changeTTL(ctx, rrSet); err != nil {
+ return err
}
opts := hcloud.ZoneRRSetSetRecordsOpts{
@@ -76,6 +90,32 @@ func (u *updater) updateRRSet(ctx context.Context, rrSet *hcloud.ZoneRRSet, val
return nil
}
+func (u *updater) addRecord(ctx context.Context, rrSet *hcloud.ZoneRRSet, val string) error {
+ if err := u.changeTTL(ctx, rrSet); err != nil {
+ return err
+ }
+
+ val = hetzner.QuoteIfRequired(val, rrSet.Type)
+ for _, record := range rrSet.Records {
+ if strings.EqualFold(record.Value, val) {
+ return nil
+ }
+ }
+
+ opts := hcloud.ZoneRRSetAddRecordsOpts{
+ Records: []hcloud.ZoneRRSetRecord{{Value: val}},
+ }
+ action, _, err := u.client.Zone.AddRRSetRecords(ctx, rrSet, opts)
+ if err != nil {
+ return err
+ }
+ if action != nil {
+ return u.client.Action.WaitFor(ctx, action)
+ }
+
+ return nil
+}
+
func (u *updater) createRRSet(ctx context.Context, zone *hcloud.Zone, rrSetType hcloud.ZoneRRSetType, name, val string) error {
opts := hcloud.ZoneRRSetCreateOpts{
Name: name,
diff --git a/tests/libcloudapi/libcloudapi.go b/tests/libcloudapi/libcloudapi.go
index bf04d5b..911d4ec 100644
--- a/tests/libcloudapi/libcloudapi.go
+++ b/tests/libcloudapi/libcloudapi.go
@@ -176,6 +176,40 @@ func UpdatedRRSetTXT() schema.ZoneRRSet {
return r
}
+func NewRRSetCNAME() schema.ZoneRRSet {
+ return schema.ZoneRRSet{
+ Name: libserver.CNAMERecordName,
+ Type: libserver.RecordTypeCNAME,
+ TTL: new(libserver.DefaultTTL),
+ Records: []schema.ZoneRRSetRecord{{Value: libserver.CNAMETarget}},
+ Zone: mustParseInt(libserver.ZoneID),
+ }
+}
+
+func NewRRSetSRV() schema.ZoneRRSet {
+ return schema.ZoneRRSet{
+ Name: libserver.SRVRecordName,
+ Type: libserver.RecordTypeSRV,
+ TTL: new(libserver.DefaultTTL),
+ Records: []schema.ZoneRRSetRecord{{Value: libserver.SRVValue}},
+ Zone: mustParseInt(libserver.ZoneID),
+ }
+}
+
+func ExistingRRSetCNAME() schema.ZoneRRSet {
+ r := NewRRSetCNAME()
+ r.ID = libserver.CNAMERecordName + "/" + libserver.RecordTypeCNAME
+ r.Records = []schema.ZoneRRSetRecord{{Value: libserver.CNAMEExisting}}
+ return r
+}
+
+func ExistingRRSetSRV() schema.ZoneRRSet {
+ r := NewRRSetSRV()
+ r.ID = libserver.SRVRecordName + "/" + libserver.RecordTypeSRV
+ r.Records = []schema.ZoneRRSetRecord{{Value: libserver.SRVExisting}}
+ return r
+}
+
func GetZone(token string, zone schema.Zone) http.HandlerFunc {
return ghttp.CombineHandlers(
ghttp.VerifyRequest(http.MethodGet, "/v1/zones/"+zone.Name),
@@ -256,6 +290,19 @@ func SetRRSetRecords(token string, zone schema.Zone, rrSet schema.ZoneRRSet) htt
)
}
+func AddRRSetRecords(token string, zone schema.Zone, rrSet schema.ZoneRRSet, records []schema.ZoneRRSetRecord) http.HandlerFunc {
+ return ghttp.CombineHandlers(
+ ghttp.VerifyRequest(http.MethodPost, fmt.Sprintf("/v1/zones/%d/rrsets/%s/%s/actions/add_records", zone.ID, rrSet.Name, rrSet.Type)),
+ ghttp.VerifyHeader(http.Header{
+ headerAuthorization: []string{authBearerPrefix + token},
+ }),
+ ghttp.VerifyJSONRepresenting(schema.ZoneRRSetAddRecordsRequest{
+ Records: records,
+ }),
+ getResponseSuccess(),
+ )
+}
+
func RemoveRRSetRecords(token string, zone schema.Zone, rrSet schema.ZoneRRSet, records []schema.ZoneRRSetRecord) http.HandlerFunc {
return ghttp.CombineHandlers(
ghttp.VerifyRequest(http.MethodPost, fmt.Sprintf("/v1/zones/%d/rrsets/%s/%s/actions/remove_records", zone.ID, rrSet.Name, rrSet.Type)),
diff --git a/tests/libserver/consts.go b/tests/libserver/consts.go
index 46bf7f4..30ef096 100644
--- a/tests/libserver/consts.go
+++ b/tests/libserver/consts.go
@@ -11,6 +11,16 @@ const (
TXTRecordNameNoPrefix = "txtsub.test.tld"
TXTRecordName = "_acme-challenge.txtsub"
TXTRecordNameFull = "_acme-challenge.txtsub.test.tld"
+ CNAMERecordName = "cnamesub"
+ CNAMERecordNameFull = "cnamesub.test.tld"
+ CNAMETarget = "target.test.tld."
+ CNAMEExisting = "old.test.tld."
+ SRVExisting = "10 5 25567 mc2.test.tld."
+ SRVRecordName = "_minecraft._tcp.survival"
+ SRVRecordNameFull = "_minecraft._tcp.survival.test.tld"
+ SRVValue = "0 5 25567 mc.test.tld."
+ RecordTypeCNAME = "CNAME"
+ RecordTypeSRV = "SRV"
DefaultTTL = 60
AExisting = "127.0.0.1"
AUpdated = "1.2.3.4"
diff --git a/tests/libserver/libserver.go b/tests/libserver/libserver.go
index b33684b..7bc208e 100644
--- a/tests/libserver/libserver.go
+++ b/tests/libserver/libserver.go
@@ -10,6 +10,12 @@ import (
)
func New(url string, ttl int) (server *httptest.Server, token, username, password string) {
+ return NewWithEndpoints(url, ttl, config.Endpoints{
+ Plain: true, Nic: true, AcmeDNS: true, HTTPReq: true, DirectAdmin: true, Records: true,
+ })
+}
+
+func NewWithEndpoints(url string, ttl int, endpoints config.Endpoints) (server *httptest.Server, token, username, password string) {
token = rand.Text()
username = rand.Text()
password = rand.Text()
@@ -29,7 +35,7 @@ func New(url string, ttl int) (server *httptest.Server, token, username, passwor
Domains: []string{"*"},
}},
},
- Endpoints: config.Endpoints{Plain: true, Nic: true, AcmeDNS: true, HTTPReq: true, DirectAdmin: true},
+ Endpoints: endpoints,
RecordTTL: ttl,
RateLimit: config.RateLimit{RPS: 1000, Burst: 1000, IdleSeconds: 600},
Lockout: config.Lockout{MaxAttempts: 1000, DurationSeconds: 3600, WindowSeconds: 900},
@@ -44,7 +50,7 @@ func NewNoAllowedDomains(url string) *httptest.Server {
Auth: config.Auth{
Method: config.AuthMethodAllowedDomains,
},
- Endpoints: config.Endpoints{Plain: true, Nic: true, AcmeDNS: true, HTTPReq: true, DirectAdmin: true},
+ Endpoints: config.Endpoints{Plain: true, Nic: true, AcmeDNS: true, HTTPReq: true, DirectAdmin: true, Records: true},
RateLimit: config.RateLimit{RPS: 1000, Burst: 1000, IdleSeconds: 600},
Lockout: config.Lockout{MaxAttempts: 1000, DurationSeconds: 3600, WindowSeconds: 900},
}
diff --git a/tests/records_test.go b/tests/records_test.go
new file mode 100644
index 0000000..9202395
--- /dev/null
+++ b/tests/records_test.go
@@ -0,0 +1,224 @@
+package tests
+
+import (
+ "bytes"
+ "context"
+ "encoding/json/v2"
+ "net/http"
+ "net/http/httptest"
+
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+ "github.com/onsi/gomega/ghttp"
+
+ "github.com/hetznercloud/hcloud-go/v2/hcloud/schema"
+
+ "github.com/0xfelix/hetzner-dnsapi-proxy/pkg/config"
+ "github.com/0xfelix/hetzner-dnsapi-proxy/tests/libcloudapi"
+ "github.com/0xfelix/hetzner-dnsapi-proxy/tests/libserver"
+)
+
+const (
+ typeCNAME = "CNAME"
+ typeSRV = "SRV"
+ otherHost = "a.test.tld"
+ srvInput = "0 5 25567 mc.test.tld"
+)
+
+func rec(fqdn, typ, value string) map[string]string {
+ return map[string]string{keyFQDN: fqdn, "type": typ, keyValue: value}
+}
+
+var _ = Describe("Records", func() {
+ var (
+ api *ghttp.Server
+ server *httptest.Server
+ token string
+ username string
+ password string
+ )
+
+ BeforeEach(func() {
+ api = ghttp.NewServer()
+ server, token, username, password = libserver.New(api.URL(), libserver.DefaultTTL)
+ })
+
+ AfterEach(func() {
+ server.Close()
+ api.Close()
+ })
+
+ Context("should succeed", func() {
+ DescribeTable(
+ "creating a new record", func(ctx context.Context, rrSet schema.ZoneRRSet, fqdn, value string) {
+ api.AppendHandlers(
+ libcloudapi.GetZone(token, libcloudapi.Zone()),
+ libcloudapi.GetRRSet(token, libcloudapi.Zone(), rrSet, false),
+ libcloudapi.CreateRRSet(token, libcloudapi.Zone(), rrSet),
+ )
+
+ Expect(doRecordsRequest(
+ ctx, server.URL+"/records/present", username, password,
+ rec(fqdn, rrSet.Type, value),
+ )).To(Equal(http.StatusOK))
+ Expect(api.ReceivedRequests()).To(HaveLen(3))
+ },
+ Entry("CNAME", libcloudapi.NewRRSetCNAME(), libserver.CNAMERecordNameFull, "target.test.tld"),
+ Entry("CNAME with dot suffix", libcloudapi.NewRRSetCNAME(), libserver.CNAMERecordNameFull+".", "target.test.tld."),
+ Entry("SRV", libcloudapi.NewRRSetSRV(), libserver.SRVRecordNameFull, srvInput),
+ Entry("SRV with dot suffix", libcloudapi.NewRRSetSRV(), libserver.SRVRecordNameFull+".", "0 5 25567 MC.test.tld."),
+ )
+
+ It("replacing an existing CNAME record", func(ctx context.Context) {
+ api.AppendHandlers(
+ libcloudapi.GetZone(token, libcloudapi.Zone()),
+ libcloudapi.GetRRSet(token, libcloudapi.Zone(), libcloudapi.ExistingRRSetCNAME(), true),
+ libcloudapi.SetRRSetRecords(token, libcloudapi.Zone(), libcloudapi.NewRRSetCNAME()),
+ )
+
+ Expect(doRecordsRequest(
+ ctx, server.URL+"/records/present", username, password,
+ rec(libserver.CNAMERecordNameFull, typeCNAME, "target.test.tld"),
+ )).To(Equal(http.StatusOK))
+ Expect(api.ReceivedRequests()).To(HaveLen(3))
+ })
+
+ DescribeTable(
+ "adding a SRV record to an existing RRSet", func(ctx context.Context, ttl, expectedRequests int) {
+ rrSet := libcloudapi.ExistingRRSetSRV()
+ rrSet.TTL = &ttl
+ api.AppendHandlers(
+ libcloudapi.GetZone(token, libcloudapi.Zone()),
+ libcloudapi.GetRRSet(token, libcloudapi.Zone(), rrSet, true),
+ )
+ if ttl != libserver.DefaultTTL {
+ api.AppendHandlers(libcloudapi.ChangeRRSetTTL(token, libcloudapi.Zone(), libcloudapi.ExistingRRSetSRV()))
+ }
+ api.AppendHandlers(
+ libcloudapi.AddRRSetRecords(token, libcloudapi.Zone(), rrSet, []schema.ZoneRRSetRecord{
+ {Value: libserver.SRVValue},
+ }),
+ )
+
+ Expect(doRecordsRequest(
+ ctx, server.URL+"/records/present", username, password,
+ rec(libserver.SRVRecordNameFull, typeSRV, srvInput),
+ )).To(Equal(http.StatusOK))
+ Expect(api.ReceivedRequests()).To(HaveLen(expectedRequests))
+ },
+ Entry("with matching TTL", libserver.DefaultTTL, 3),
+ Entry("with different TTL", libserver.DefaultTTL+1, 4),
+ )
+
+ It("not adding a SRV record that already exists", func(ctx context.Context) {
+ rrSet := libcloudapi.ExistingRRSetSRV()
+ rrSet.Records = append(rrSet.Records, schema.ZoneRRSetRecord{Value: libserver.SRVValue})
+ api.AppendHandlers(
+ libcloudapi.GetZone(token, libcloudapi.Zone()),
+ libcloudapi.GetRRSet(token, libcloudapi.Zone(), rrSet, true),
+ )
+
+ Expect(doRecordsRequest(
+ ctx, server.URL+"/records/present", username, password,
+ rec(libserver.SRVRecordNameFull, typeSRV, srvInput),
+ )).To(Equal(http.StatusOK))
+ Expect(api.ReceivedRequests()).To(HaveLen(2))
+ })
+
+ DescribeTable(
+ "cleaning up a record", func(ctx context.Context, rrSet schema.ZoneRRSet, fqdn, value string) {
+ api.AppendHandlers(
+ libcloudapi.GetZone(token, libcloudapi.Zone()),
+ libcloudapi.GetRRSet(token, libcloudapi.Zone(), rrSet, true),
+ libcloudapi.RemoveRRSetRecords(token, libcloudapi.Zone(), rrSet, rrSet.Records),
+ )
+
+ Expect(doRecordsRequest(
+ ctx, server.URL+"/records/cleanup", username, password,
+ rec(fqdn, rrSet.Type, value),
+ )).To(Equal(http.StatusOK))
+ Expect(api.ReceivedRequests()).To(HaveLen(3))
+ },
+ Entry("CNAME", libcloudapi.NewRRSetCNAME(), libserver.CNAMERecordNameFull, "target.test.tld"),
+ Entry("SRV", libcloudapi.NewRRSetSRV(), libserver.SRVRecordNameFull, srvInput),
+ )
+
+ It("cleaning up a record that does not exist", func(ctx context.Context) {
+ api.AppendHandlers(
+ libcloudapi.GetZone(token, libcloudapi.Zone()),
+ libcloudapi.GetRRSet(token, libcloudapi.Zone(), libcloudapi.NewRRSetCNAME(), false),
+ )
+
+ Expect(doRecordsRequest(
+ ctx, server.URL+"/records/cleanup", username, password,
+ rec(libserver.CNAMERecordNameFull, typeCNAME, "target.test.tld"),
+ )).To(Equal(http.StatusOK))
+ Expect(api.ReceivedRequests()).To(HaveLen(2))
+ })
+ })
+
+ Context("should make no api calls and should fail", func() {
+ AfterEach(func() {
+ Expect(api.ReceivedRequests()).To(BeEmpty())
+ })
+
+ DescribeTable(
+ "on invalid input", func(ctx context.Context, data map[string]string) {
+ Expect(doRecordsRequest(
+ ctx, server.URL+"/records/present", username, password, data,
+ )).To(Equal(http.StatusBadRequest))
+ },
+ Entry("missing type", map[string]string{"fqdn": libserver.CNAMERecordNameFull, "value": otherHost}),
+ Entry("unsupported type", rec(libserver.CNAMERecordNameFull, "MX", otherHost)),
+ Entry("CNAME at the zone apex", rec(libserver.ZoneName, typeCNAME, otherHost)),
+ Entry("CNAME with invalid target", rec(libserver.CNAMERecordNameFull, typeCNAME, "a b.test.tld")),
+ Entry("SRV with missing field", rec(libserver.SRVRecordNameFull, typeSRV, "0 5 mc.test.tld")),
+ Entry("SRV with port out of range", rec(libserver.SRVRecordNameFull, typeSRV, "0 5 70000 mc.test.tld")),
+ Entry("A with invalid address", rec(libserver.ARecordNameFull, "A", "nope")),
+ )
+
+ DescribeTable(
+ "when access is denied", func(ctx context.Context, path string) {
+ server.Close()
+ server = libserver.NewNoAllowedDomains(api.URL())
+ Expect(doRecordsRequest(
+ ctx, server.URL+path, username, password,
+ rec(libserver.CNAMERecordNameFull, typeCNAME, otherHost),
+ )).To(Equal(http.StatusUnauthorized))
+ },
+ Entry("present", "/records/present"),
+ Entry("cleanup", "/records/cleanup"),
+ )
+
+ DescribeTable(
+ "when the endpoint is not enabled", func(ctx context.Context, path string) {
+ server.Close()
+ server, _, username, password = libserver.NewWithEndpoints(
+ api.URL(), libserver.DefaultTTL, config.NewConfig().Endpoints,
+ )
+ Expect(doRecordsRequest(
+ ctx, server.URL+path, username, password,
+ rec(libserver.CNAMERecordNameFull, typeCNAME, otherHost),
+ )).To(Equal(http.StatusNotFound))
+ },
+ Entry("present", "/records/present"),
+ Entry("cleanup", "/records/cleanup"),
+ )
+ })
+})
+
+func doRecordsRequest(ctx context.Context, serverURL, username, password string, data map[string]string) int {
+ body, err := json.Marshal(data)
+ Expect(err).ToNot(HaveOccurred())
+
+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, serverURL, bytes.NewReader(body))
+ Expect(err).ToNot(HaveOccurred())
+ req.Header.Add("Content-Type", "application/json")
+ req.SetBasicAuth(username, password)
+
+ res, err := (&http.Client{}).Do(req)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.Body.Close()).To(Succeed())
+
+ return res.StatusCode
+}