141 lines
3 KiB
Go
141 lines
3 KiB
Go
//go:build standalone
|
|
|
|
package checker
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net"
|
|
"net/http"
|
|
"strings"
|
|
"sync"
|
|
|
|
"github.com/miekg/dns"
|
|
|
|
sdk "git.happydns.org/checker-sdk-go/checker"
|
|
)
|
|
|
|
func (p *authoritativeConsistencyProvider) RenderForm() []sdk.CheckerOptionField {
|
|
return []sdk.CheckerOptionField{
|
|
{
|
|
Id: "zone",
|
|
Type: "string",
|
|
Label: "Zone name",
|
|
Placeholder: "example.com",
|
|
Required: true,
|
|
Description: "Apex name of the zone whose authoritative servers should be cross-checked.",
|
|
},
|
|
}
|
|
}
|
|
|
|
func (p *authoritativeConsistencyProvider) ParseForm(r *http.Request) (sdk.CheckerOptions, error) {
|
|
zone := strings.TrimSpace(r.FormValue("zone"))
|
|
if zone == "" {
|
|
return nil, fmt.Errorf("zone is required")
|
|
}
|
|
fqdn := dns.Fqdn(zone)
|
|
|
|
resolver := interactiveResolver()
|
|
|
|
ctx := r.Context()
|
|
var (
|
|
wg sync.WaitGroup
|
|
nsRecords []*dns.NS
|
|
soaRecord *dns.SOA
|
|
nsErr error
|
|
soaErr error
|
|
)
|
|
wg.Add(2)
|
|
go func() {
|
|
defer wg.Done()
|
|
nsRecords, nsErr = lookupRecords[*dns.NS](ctx, resolver, fqdn, dns.TypeNS, false)
|
|
}()
|
|
go func() {
|
|
defer wg.Done()
|
|
soas, err := lookupRecords[*dns.SOA](ctx, resolver, fqdn, dns.TypeSOA, false)
|
|
if err != nil {
|
|
soaErr = err
|
|
return
|
|
}
|
|
if len(soas) > 0 {
|
|
soaRecord = soas[0]
|
|
}
|
|
}()
|
|
wg.Wait()
|
|
|
|
if nsErr != nil {
|
|
return nil, fmt.Errorf("NS lookup for %s: %w", zone, nsErr)
|
|
}
|
|
if len(nsRecords) == 0 {
|
|
return nil, fmt.Errorf("no NS records found for %s", zone)
|
|
}
|
|
if soaErr != nil {
|
|
return nil, fmt.Errorf("SOA lookup for %s: %w", zone, soaErr)
|
|
}
|
|
|
|
svcType := "abstract.Origin"
|
|
payload := originService{SOA: soaRecord, NameServers: nsRecords}
|
|
if soaRecord == nil {
|
|
svcType = "abstract.NSOnlyOrigin"
|
|
}
|
|
|
|
body, err := json.Marshal(payload)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("marshal origin service: %w", err)
|
|
}
|
|
|
|
svc := serviceMessage{
|
|
Type: svcType,
|
|
Service: body,
|
|
}
|
|
|
|
return sdk.CheckerOptions{
|
|
"domain_name": strings.TrimSuffix(fqdn, "."),
|
|
"service": svc,
|
|
}, nil
|
|
}
|
|
|
|
var (
|
|
resolverOnce sync.Once
|
|
resolverAddr string
|
|
|
|
interactiveClient = &dns.Client{Timeout: dnsTimeout}
|
|
)
|
|
|
|
func interactiveResolver() string {
|
|
resolverOnce.Do(func() {
|
|
cfg, err := dns.ClientConfigFromFile("/etc/resolv.conf")
|
|
if err != nil || len(cfg.Servers) == 0 {
|
|
resolverAddr = net.JoinHostPort("1.1.1.1", "53")
|
|
return
|
|
}
|
|
resolverAddr = net.JoinHostPort(cfg.Servers[0], cfg.Port)
|
|
})
|
|
return resolverAddr
|
|
}
|
|
|
|
func lookupRecords[T dns.RR](ctx context.Context, resolver, fqdn string, qtype uint16, edns bool) ([]T, error) {
|
|
msg := new(dns.Msg)
|
|
msg.SetQuestion(fqdn, qtype)
|
|
msg.RecursionDesired = true
|
|
if edns {
|
|
msg.SetEdns0(4096, true)
|
|
}
|
|
|
|
in, _, err := interactiveClient.ExchangeContext(ctx, msg, resolver)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if in.Rcode != dns.RcodeSuccess && in.Rcode != dns.RcodeNameError {
|
|
return nil, fmt.Errorf("rcode %s", dns.RcodeToString[in.Rcode])
|
|
}
|
|
|
|
var out []T
|
|
for _, rr := range in.Answer {
|
|
if t, ok := rr.(T); ok {
|
|
out = append(out, t)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|