101 lines
3.1 KiB
Go
101 lines
3.1 KiB
Go
package edns
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"testing"
|
|
|
|
"golang.org/x/net/dns/dnsmessage"
|
|
)
|
|
|
|
func TestBuildAndParseResponse(t *testing.T) {
|
|
queryWire, query, transactionID, err := BuildQuery("Example.COM.", "A")
|
|
if err != nil {
|
|
t.Fatalf("build query: %v", err)
|
|
}
|
|
if query.Name != "example.com" || query.Type != "A" {
|
|
t.Fatalf("canonical query = %#v", query)
|
|
}
|
|
|
|
var request dnsmessage.Message
|
|
if err := request.Unpack(queryWire); err != nil {
|
|
t.Fatalf("unpack query: %v", err)
|
|
}
|
|
response := dnsmessage.Message{
|
|
Header: dnsmessage.Header{
|
|
ID: transactionID,
|
|
Response: true,
|
|
RecursionDesired: true,
|
|
RecursionAvailable: true,
|
|
AuthenticData: true,
|
|
},
|
|
Questions: request.Questions,
|
|
Answers: []dnsmessage.Resource{{
|
|
Header: dnsmessage.ResourceHeader{Name: request.Questions[0].Name, Class: dnsmessage.ClassINET, TTL: 60},
|
|
Body: &dnsmessage.AResource{A: [4]byte{192, 0, 2, 1}},
|
|
}},
|
|
}
|
|
responseWire, err := response.Pack()
|
|
if err != nil {
|
|
t.Fatalf("pack response: %v", err)
|
|
}
|
|
|
|
dnsResult, err := ParseResponse(responseWire, transactionID, query)
|
|
if err != nil {
|
|
t.Fatalf("parse response: %v", err)
|
|
}
|
|
if dnsResult.RCode != "NOERROR" || !dnsResult.ResolverReportsDNSSECAuthenticated {
|
|
t.Fatalf("unexpected DNS result: %#v", dnsResult)
|
|
}
|
|
if got := dnsResult.Answers[0]["address"]; got != "192.0.2.1" {
|
|
t.Fatalf("address = %v, want 192.0.2.1", got)
|
|
}
|
|
}
|
|
|
|
func TestBuildQueryIDNAAndBlockedNames(t *testing.T) {
|
|
_, query, _, err := BuildQuery("bücher.example", "AAAA")
|
|
if err != nil {
|
|
t.Fatalf("build IDNA query: %v", err)
|
|
}
|
|
if query.Name != "xn--bcher-kva.example" {
|
|
t.Fatalf("IDNA name = %q", query.Name)
|
|
}
|
|
|
|
blocked := []string{"localhost", "router.local", "service.internal", "host.lan", "1.0.0.127.in-addr.arpa", "127.0.0.1"}
|
|
for _, name := range blocked {
|
|
if _, _, _, err := BuildQuery(name, "A"); err == nil {
|
|
t.Errorf("BuildQuery(%q) succeeded, want policy error", name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNormalizeCAA(t *testing.T) {
|
|
name := dnsmessage.MustNewName("example.com.")
|
|
data := append([]byte{0, 5}, []byte("issueletsencrypt.org")...)
|
|
record := normalizeAnswer(dnsmessage.Resource{
|
|
Header: dnsmessage.ResourceHeader{Name: name, Type: dnsmessage.Type(257), Class: dnsmessage.ClassINET, TTL: 300},
|
|
Body: &dnsmessage.UnknownResource{Type: dnsmessage.Type(257), Data: data},
|
|
})
|
|
if record["tag"] != "issue" || record["value"] != "letsencrypt.org" {
|
|
t.Fatalf("unexpected CAA normalization: %#v", record)
|
|
}
|
|
}
|
|
|
|
func TestParseResponseRejectsTransactionMismatch(t *testing.T) {
|
|
name := dnsmessage.MustNewName("example.com.")
|
|
message := dnsmessage.Message{
|
|
Header: dnsmessage.Header{ID: 2, Response: true},
|
|
Questions: []dnsmessage.Question{{Name: name, Type: dnsmessage.TypeA, Class: dnsmessage.ClassINET}},
|
|
}
|
|
wire, err := message.Pack()
|
|
if err != nil {
|
|
t.Fatalf("pack response: %v", err)
|
|
}
|
|
if _, err := ParseResponse(wire, 1, QueryInfo{Name: "example.com", Type: "A"}); err == nil {
|
|
t.Fatal("transaction mismatch was accepted")
|
|
}
|
|
|
|
if binary.BigEndian.Uint16(wire[:2]) != 2 {
|
|
t.Fatal("test response ID was not encoded")
|
|
}
|
|
}
|