Files
cairnobs/internal/check/rbl.go
T
jcoffey-dev db156c4f06
release / release (push) Successful in 7m6s
Cairn OBS
The new Cairn OBS: a self-hosted monitor for networks, hosts and
services. Licensed AGPLv3.
2026-11-14 03:27:09 -07:00

101 lines
2.7 KiB
Go

package check
import (
"context"
"errors"
"fmt"
"net"
"sort"
"strings"
"sync"
"github.com/cairnobs/cairnobs/internal/report"
)
// DefaultLists are block lists that answer ordinary resolvers. Spamhaus
// isn't here: it refuses queries from public and hosting resolvers
// (answering 127.255.255.254), so it needs its own resolver or a key.
var DefaultLists = []string{"bl.spamcop.net", "b.barracudacentral.org", "dnsbl-1.uceprotect.net", "psbl.surriel.com", "bl.mailspike.net"}
// runRBL looks the address up on every list at once. Listed anywhere
// fails the check; a list that won't answer us is noted, not counted.
func runRBL(ctx context.Context, s Spec, r *report.CheckResult) error {
o := net.ParseIP(s.RBL).To4()
rev := fmt.Sprintf("%d.%d.%d.%d", o[3], o[2], o[1], o[0])
res := resolver(s)
type answer struct {
list string
listed []string
refuse bool
err error
}
answers := make([]answer, len(s.Lists))
var wg sync.WaitGroup
for i, list := range s.Lists {
wg.Add(1)
go func() {
defer wg.Done()
a := answer{list: list}
addrs, err := res.LookupHost(ctx, rev+"."+list)
var de *net.DNSError
switch {
case errors.As(err, &de) && de.IsNotFound:
// not listed
case err != nil:
a.err = err
default:
for _, ad := range addrs {
if strings.HasPrefix(ad, "127.255.255.") {
a.refuse = true // the list's way of saying "not from your resolver"
} else if strings.HasPrefix(ad, "127.") {
a.listed = append(a.listed, ad)
}
}
}
answers[i] = a
}()
}
wg.Wait()
var listed, refused, failed []string
clean := 0
for _, a := range answers {
switch {
case len(a.listed) > 0:
sort.Strings(a.listed)
listed = append(listed, a.list+" ("+strings.Join(a.listed, ", ")+")")
case a.refuse:
refused = append(refused, a.list)
case a.err != nil:
failed = append(failed, a.list)
default:
clean++
}
}
parts := []string{fmt.Sprintf("clean on %d of %d", clean, len(s.Lists))}
if len(refused) > 0 {
parts = append(parts, "won't answer us: "+strings.Join(refused, ", "))
}
if len(failed) > 0 {
parts = append(parts, "no answer: "+strings.Join(failed, ", "))
}
r.Answer = short(strings.Join(parts, "; "))
switch {
case len(listed) > 0:
return fmt.Errorf("listed on %s", strings.Join(listed, "; "))
case clean == 0:
return errors.New("no block list could be asked: " + r.Answer)
}
return nil
}
// resolver is the host's, or the check's own server.
func resolver(s Spec) *net.Resolver {
if s.Server == "" {
return net.DefaultResolver
}
return &net.Resolver{PreferGo: true, Dial: func(ctx context.Context, network, _ string) (net.Conn, error) {
var d net.Dialer
return d.DialContext(ctx, network, s.Server)
}}
}