| // Copyright 2025 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| package dnsmessage | |
| import ( | |
| "bytes" | |
| "math" | |
| "reflect" | |
| "testing" | |
| ) | |
| func TestSVCBParamsRoundTrip(t *testing.T) { | |
| testSVCBParam := func(t *testing.T, p *SVCParam) { | |
| t.Helper() | |
| rr := &SVCBResource{ | |
| Priority: 1, | |
| Target: MustNewName("svc.example.com."), | |
| Params: []SVCParam{*p}, | |
| } | |
| buf, err := rr.pack([]byte{}, nil, 0) | |
| if err != nil { | |
| t.Fatalf("pack() = %v", err) | |
| } | |
| got, n, err := unpackResourceBody(buf, 0, ResourceHeader{Type: TypeSVCB, Length: uint16(len(buf))}) | |
| if err != nil { | |
| t.Fatalf("unpackResourceBody() = %v", err) | |
| } | |
| if n != len(buf) { | |
| t.Fatalf("unpacked different amount than packed: got = %d, want = %d", n, len(buf)) | |
| } | |
| if !reflect.DeepEqual(got, rr) { | |
| t.Fatalf("roundtrip mismatch: got = %#v, want = %#v", got, rr) | |
| } | |
| } | |
| testSVCBParam(t, &SVCParam{Key: SVCParamMandatory, Value: []byte{0x00, 0x01, 0x00, 0x03, 0x00, 0x05}}) | |
| testSVCBParam(t, &SVCParam{Key: SVCParamALPN, Value: []byte{0x02, 'h', '2', 0x02, 'h', '3'}}) | |
| testSVCBParam(t, &SVCParam{Key: SVCParamNoDefaultALPN, Value: []byte{}}) | |
| testSVCBParam(t, &SVCParam{Key: SVCParamPort, Value: []byte{0x1f, 0x90}}) // 8080 | |
| testSVCBParam(t, &SVCParam{Key: SVCParamIPv4Hint, Value: []byte{192, 0, 2, 1, 198, 51, 100, 2}}) | |
| testSVCBParam(t, &SVCParam{Key: SVCParamECH, Value: []byte{0x01, 0x02, 0x03, 0x04}}) | |
| testSVCBParam(t, &SVCParam{Key: SVCParamIPv6Hint, Value: []byte{0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}}) | |
| testSVCBParam(t, &SVCParam{Key: SVCParamDOHPath, Value: []byte("/dns-query{?dns}")}) | |
| testSVCBParam(t, &SVCParam{Key: SVCParamOHTTP, Value: []byte{0x00, 0x01, 0x02, 0x03}}) | |
| testSVCBParam(t, &SVCParam{Key: SVCParamTLSSupportedGroups, Value: []byte{0x00, 0x1d, 0x00, 0x17}}) | |
| } | |
| func TestSVCBParsingAllocs(t *testing.T) { | |
| name := MustNewName("foo.bar.example.com.") | |
| msg := Message{ | |
| Header: Header{Response: true, Authoritative: true}, | |
| Questions: []Question{{Name: name, Type: TypeA, Class: ClassINET}}, | |
| Answers: []Resource{{ | |
| Header: ResourceHeader{Name: name, Type: TypeSVCB, Class: ClassINET, TTL: 300}, | |
| Body: &SVCBResource{ | |
| Priority: 1, | |
| Target: MustNewName("svc.example.com."), | |
| Params: []SVCParam{ | |
| {Key: SVCParamMandatory, Value: []byte{0x00, 0x01, 0x00, 0x03, 0x00, 0x05}}, | |
| {Key: SVCParamALPN, Value: []byte{0x02, 'h', '2', 0x02, 'h', '3'}}, | |
| {Key: SVCParamPort, Value: []byte{0x1f, 0x90}}, // 8080 | |
| {Key: SVCParamIPv4Hint, Value: []byte{192, 0, 2, 1, 198, 51, 100, 2}}, | |
| {Key: SVCParamIPv6Hint, Value: []byte{0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}}, | |
| }, | |
| }, | |
| }}, | |
| } | |
| buf, err := msg.Pack() | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| allocs := int(testing.AllocsPerRun(1, func() { | |
| var p Parser | |
| if _, err := p.Start(buf); err != nil { | |
| t.Fatal("Parser.Start(non-nil) =", err) | |
| } | |
| if err := p.SkipAllQuestions(); err != nil { | |
| t.Fatal("Parser.SkipAllQuestions(non-nil) =", err) | |
| } | |
| if _, err = p.AnswerHeader(); err != nil { | |
| t.Fatal("Parser.AnswerHeader(non-nil) =", err) | |
| } | |
| if _, err = p.SVCBResource(); err != nil { | |
| t.Fatal("Parser.SVCBResource(non-nil) =", err) | |
| } | |
| })) | |
| // Make sure we have only two allocations: one for the SVCBResource.Params slice, and one | |
| // for the SVCParam Values. | |
| if allocs != 2 { | |
| t.Errorf("allocations during parsing: got = %d, want 2", allocs) | |
| } | |
| } | |
| func TestHTTPSBuildAllocs(t *testing.T) { | |
| b := NewBuilder([]byte{}, Header{Response: true, Authoritative: true}) | |
| b.EnableCompression() | |
| if err := b.StartQuestions(); err != nil { | |
| t.Fatalf("StartQuestions() = %v", err) | |
| } | |
| if err := b.Question(Question{Name: MustNewName("foo.bar.example.com."), Type: TypeHTTPS, Class: ClassINET}); err != nil { | |
| t.Fatalf("Question() = %v", err) | |
| } | |
| if err := b.StartAnswers(); err != nil { | |
| t.Fatalf("StartAnswers() = %v", err) | |
| } | |
| header := ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeHTTPS, Class: ClassINET, TTL: 300} | |
| resource := HTTPSResource{SVCBResource{Priority: 1, Target: MustNewName("svc.example.com.")}} | |
| // AllocsPerRun runs the function once to "warm up" before running the measurement. | |
| // So technically this function is running twice, on different data, which can potentially | |
| // make the measurement inaccurate (e.g. by using the name cache the second time). | |
| // So we make sure we don't run in the warm-up phase. | |
| warmUp := true | |
| allocs := int(testing.AllocsPerRun(1, func() { | |
| if warmUp { | |
| warmUp = false | |
| return | |
| } | |
| if err := b.HTTPSResource(header, resource); err != nil { | |
| t.Fatalf("HTTPSResource() = %v", err) | |
| } | |
| })) | |
| if allocs != 1 { | |
| t.Fatalf("unexpected allocations: got = %d, want = 1", allocs) | |
| } | |
| } | |
| func TestSVCBParams(t *testing.T) { | |
| rr := SVCBResource{Priority: 1, Target: MustNewName("svc.example.com.")} | |
| if _, ok := rr.GetParam(SVCParamALPN); ok { | |
| t.Fatal("GetParam found non-existent param") | |
| } | |
| rr.SetParam(SVCParamIPv4Hint, []byte{192, 0, 2, 1}) | |
| inALPN := []byte{0x02, 'h', '2', 0x02, 'h', '3'} | |
| rr.SetParam(SVCParamALPN, inALPN) | |
| // Check sorting of params | |
| packed, err := rr.pack([]byte{}, nil, 0) | |
| if err != nil { | |
| t.Fatal("pack() =", err) | |
| } | |
| expectedBytes := []byte{ | |
| 0x00, 0x01, // priority | |
| 0x03, 0x73, 0x76, 0x63, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // target | |
| 0x00, 0x01, // key 1 | |
| 0x00, 0x06, // length 6 | |
| 0x02, 'h', '2', 0x02, 'h', '3', // value | |
| 0x00, 0x04, // key 4 | |
| 0x00, 0x04, // length 4 | |
| 192, 0, 2, 1, // value | |
| } | |
| if !reflect.DeepEqual(packed, expectedBytes) { | |
| t.Fatalf("pack() produced unexpected output: want = %v, got = %v", expectedBytes, packed) | |
| } | |
| // Check GetParam and DeleteParam. | |
| if outALPN, ok := rr.GetParam(SVCParamALPN); !ok || !bytes.Equal(outALPN, inALPN) { | |
| t.Fatal("GetParam failed to retrieve set param") | |
| } | |
| if !rr.DeleteParam(SVCParamALPN) { | |
| t.Fatal("DeleteParam failed to remove existing param") | |
| } | |
| if _, ok := rr.GetParam(SVCParamALPN); ok { | |
| t.Fatal("GetParam found deleted param") | |
| } | |
| if len(rr.Params) != 1 || rr.Params[0].Key != SVCParamIPv4Hint { | |
| t.Fatalf("DeleteParam removed wrong param: got = %#v, want = [%#v]", rr.Params, SVCParam{Key: SVCParamIPv4Hint, Value: []byte{192, 0, 2, 1}}) | |
| } | |
| } | |
| func TestSVCBWireFormat(t *testing.T) { | |
| testRecord := func(bytesInput []byte, parsedInput *SVCBResource) { | |
| parsedOutput, n, err := unpackResourceBody(bytesInput, 0, ResourceHeader{Type: TypeSVCB, Length: uint16(len(bytesInput))}) | |
| if err != nil { | |
| t.Fatalf("unpackResourceBody() = %v", err) | |
| } | |
| if n != len(bytesInput) { | |
| t.Fatalf("unpacked different amount than packed: got = %d, want = %d", n, len(bytesInput)) | |
| } | |
| if !reflect.DeepEqual(parsedOutput, parsedInput) { | |
| t.Fatalf("unpack mismatch: got = %#v, want = %#v", parsedOutput, parsedInput) | |
| } | |
| bytesOutput, err := parsedInput.pack([]byte{}, nil, 0) | |
| if err != nil { | |
| t.Fatalf("pack() = %v", err) | |
| } | |
| if !reflect.DeepEqual(bytesOutput, bytesInput) { | |
| t.Fatalf("pack mismatch: got = %#v, want = %#v", bytesOutput, bytesInput) | |
| } | |
| } | |
| // Test examples from https://datatracker.ietf.org/doc/html/rfc9460#name-test-vectors | |
| // Example D.1. Alias Mode | |
| // Figure 2: AliasMode | |
| // example.com. HTTPS 0 foo.example.com. | |
| bytes := []byte{ | |
| 0x00, 0x00, // priority | |
| 0x03, 0x66, 0x6f, 0x6f, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // target: foo.example.com. | |
| } | |
| parsed := &SVCBResource{ | |
| Priority: 0, | |
| Target: MustNewName("foo.example.com."), | |
| Params: []SVCParam{}, | |
| } | |
| testRecord(bytes, parsed) | |
| // Example D.2. Service Mode | |
| // Figure 3: TargetName Is "." | |
| // example.com. SVCB 1 . | |
| bytes = []byte{ | |
| 0x00, 0x01, // priority | |
| 0x00, // target (root label) | |
| } | |
| parsed = &SVCBResource{ | |
| Priority: 1, | |
| Target: MustNewName("."), | |
| Params: []SVCParam{}, | |
| } | |
| testRecord(bytes, parsed) | |
| // Figure 4: Specifies a Port | |
| // example.com. SVCB 16 foo.example.com. port=53 | |
| bytes = []byte{ | |
| 0x00, 0x10, // priority | |
| 0x03, 0x66, 0x6f, 0x6f, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // target | |
| 0x00, 0x03, // key 3 | |
| 0x00, 0x02, // length 2 | |
| 0x00, 0x35, // value | |
| } | |
| parsed = &SVCBResource{ | |
| Priority: 16, | |
| Target: MustNewName("foo.example.com."), | |
| Params: []SVCParam{{Key: SVCParamPort, Value: []byte{0x00, 0x35}}}, | |
| } | |
| testRecord(bytes, parsed) | |
| // Figure 5: A Generic Key and Unquoted Value | |
| // example.com. SVCB 1 foo.example.com. key667=hello | |
| bytes = []byte{ | |
| 0x00, 0x01, // priority | |
| 0x03, 0x66, 0x6f, 0x6f, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // target | |
| 0x02, 0x9b, // key 667 | |
| 0x00, 0x05, // length 5 | |
| 0x68, 0x65, 0x6c, 0x6c, 0x6f, // value | |
| } | |
| parsed = &SVCBResource{ | |
| Priority: 1, | |
| Target: MustNewName("foo.example.com."), | |
| Params: []SVCParam{{Key: 667, Value: []byte("hello")}}, | |
| } | |
| testRecord(bytes, parsed) | |
| // Figure 6: A Generic Key and Quoted Value with a Decimal Escape | |
| // example.com. SVCB 1 foo.example.com. key667="hello\210qoo" | |
| bytes = []byte{ | |
| 0x00, 0x01, // priority | |
| 0x03, 0x66, 0x6f, 0x6f, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // target | |
| 0x02, 0x9b, // key 667 | |
| 0x00, 0x09, // length 9 | |
| 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xd2, 0x71, 0x6f, 0x6f, // value | |
| } | |
| parsed = &SVCBResource{ | |
| Priority: 1, | |
| Target: MustNewName("foo.example.com."), | |
| Params: []SVCParam{{Key: 667, Value: []byte("hello\xd2qoo")}}, | |
| } | |
| testRecord(bytes, parsed) | |
| // Figure 7: Two Quoted IPv6 Hints | |
| // example.com. SVCB 1 foo.example.com. ( | |
| // ipv6hint="2001:db8::1,2001:db8::53:1" | |
| // ) | |
| bytes = []byte{ | |
| 0x00, 0x01, // priority | |
| 0x03, 0x66, 0x6f, 0x6f, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // target | |
| 0x00, 0x06, // key 6 | |
| 0x00, 0x20, // length 32 | |
| 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, // first address | |
| 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x00, 0x01, // second address | |
| } | |
| parsed = &SVCBResource{ | |
| Priority: 1, | |
| Target: MustNewName("foo.example.com."), | |
| Params: []SVCParam{{Key: SVCParamIPv6Hint, Value: []byte{0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x00, 0x01}}}, | |
| } | |
| testRecord(bytes, parsed) | |
| // Figure 8: An IPv6 Hint Using the Embedded IPv4 Syntax | |
| // example.com. SVCB 1 example.com. ( | |
| // ipv6hint="2001:db8:122:344::192.0.2.33" | |
| // ) | |
| bytes = []byte{ | |
| 0x00, 0x01, // priority | |
| 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // target | |
| 0x00, 0x06, // key 6 | |
| 0x00, 0x10, // length 16 | |
| 0x20, 0x01, 0x0d, 0xb8, 0x01, 0x22, 0x03, 0x44, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x02, 0x21, // address | |
| } | |
| parsed = &SVCBResource{ | |
| Priority: 1, | |
| Target: MustNewName("example.com."), | |
| Params: []SVCParam{{Key: SVCParamIPv6Hint, Value: []byte{0x20, 0x01, 0x0d, 0xb8, 0x01, 0x22, 0x03, 0x44, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x02, 0x21}}}, | |
| } | |
| testRecord(bytes, parsed) | |
| // Figure 9: SvcParamKey Ordering Is Arbitrary in Presentation Format but Sorted in Wire Format | |
| // example.com. SVCB 16 foo.example.org. ( | |
| // alpn=h2,h3-19 mandatory=ipv4hint,alpn | |
| // ipv4hint=192.0.2.1 | |
| // ) | |
| bytes = []byte{ | |
| 0x00, 0x10, // priority | |
| 0x03, 0x66, 0x6f, 0x6f, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x6f, 0x72, 0x67, 0x00, // target | |
| 0x00, 0x00, // key 0 | |
| 0x00, 0x04, // param length 4 | |
| 0x00, 0x01, // value: key 1 | |
| 0x00, 0x04, // value: key 4 | |
| 0x00, 0x01, // key 1 | |
| 0x00, 0x09, // param length 9 | |
| 0x02, // alpn length 2 | |
| 0x68, 0x32, // alpn value | |
| 0x05, // alpn length 5 | |
| 0x68, 0x33, 0x2d, 0x31, 0x39, // alpn value | |
| 0x00, 0x04, // key 4 | |
| 0x00, 0x04, // param length 4 | |
| 0xc0, 0x00, 0x02, 0x01, // param value | |
| } | |
| parsed = &SVCBResource{ | |
| Priority: 16, | |
| Target: MustNewName("foo.example.org."), | |
| Params: []SVCParam{ | |
| {Key: SVCParamMandatory, Value: []byte{0x00, 0x01, 0x00, 0x04}}, | |
| {Key: SVCParamALPN, Value: []byte{0x02, 0x68, 0x32, 0x05, 0x68, 0x33, 0x2d, 0x31, 0x39}}, | |
| {Key: SVCParamIPv4Hint, Value: []byte{0xc0, 0x00, 0x02, 0x01}}, | |
| }, | |
| } | |
| testRecord(bytes, parsed) | |
| // Figure 10: An "alpn" Value with an Escaped Comma and an Escaped Backslash in Two Presentation Formats | |
| // example.com. SVCB 16 foo.example.org. alpn=f\\\092oo\092,bar,h2 | |
| bytes = []byte{ | |
| 0x00, 0x10, // priority | |
| 0x03, 0x66, 0x6f, 0x6f, 0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x6f, 0x72, 0x67, 0x00, // target | |
| 0x00, 0x01, // key 1 | |
| 0x00, 0x0c, // param length 12 | |
| 0x08, // alpn length 8 | |
| 0x66, 0x5c, 0x6f, 0x6f, 0x2c, 0x62, 0x61, 0x72, // alpn value | |
| 0x02, // alpn length 2 | |
| 0x68, 0x32, // alpn value | |
| } | |
| parsed = &SVCBResource{ | |
| Priority: 16, | |
| Target: MustNewName("foo.example.org."), | |
| Params: []SVCParam{ | |
| {Key: SVCParamALPN, Value: []byte{0x08, 0x66, 0x5c, 0x6f, 0x6f, 0x2c, 0x62, 0x61, 0x72, 0x02, 0x68, 0x32}}, | |
| }, | |
| } | |
| testRecord(bytes, parsed) | |
| } | |
| func TestSVCBPackErrors(t *testing.T) { | |
| for _, test := range []struct { | |
| name string | |
| r SVCBResource | |
| }{ | |
| { | |
| name: "long value", | |
| r: SVCBResource{ | |
| Target: MustNewName("example.com."), | |
| Params: []SVCParam{ | |
| { | |
| Key: SVCParamMandatory, | |
| Value: make([]byte, math.MaxUint16+1), | |
| }, | |
| }, | |
| }, | |
| }, | |
| { | |
| name: "out-of-order keys", | |
| r: SVCBResource{ | |
| Target: MustNewName("example.com."), | |
| Params: []SVCParam{ | |
| { | |
| Key: SVCParamPort, // 3 | |
| Value: []byte("443"), | |
| }, | |
| { | |
| Key: SVCParamALPN, // 1 | |
| Value: []byte("h2"), | |
| }, | |
| }, | |
| }, | |
| }, | |
| { | |
| name: "duplicate keys", | |
| r: SVCBResource{ | |
| Target: MustNewName("example.com."), | |
| Params: []SVCParam{ | |
| { | |
| Key: SVCParamALPN, | |
| Value: []byte("h3"), | |
| }, | |
| { | |
| Key: SVCParamALPN, | |
| Value: []byte("h2"), | |
| }, | |
| }, | |
| }, | |
| }, | |
| } { | |
| t.Run(test.name, func(t *testing.T) { | |
| b := NewBuilder(nil, Header{}) | |
| b.StartQuestions() | |
| b.StartAnswers() | |
| if err := b.SVCBResource(ResourceHeader{ | |
| Name: MustNewName("example.com."), | |
| }, test.r); err == nil { | |
| t.Errorf("b.SVCBResource() succeeded; want error") | |
| } | |
| b = NewBuilder(nil, Header{}) | |
| b.StartQuestions() | |
| b.StartAnswers() | |
| if err := b.HTTPSResource(ResourceHeader{ | |
| Name: MustNewName("example.com."), | |
| }, HTTPSResource{test.r}); err == nil { | |
| t.Errorf("b.HTTPSResource() succeeded; want error") | |
| } | |
| }) | |
| } | |
| } | |
| func TestSVCBUnpackOutOfBounds(t *testing.T) { | |
| // A minimal DNS message with an SVCB record where the header Length | |
| // field (65535) maliciously exceeds the physical bounds of the buffer. | |
| msg := []byte{ | |
| 0x00, 0x01, // ID | |
| 0x00, 0x00, // Flags | |
| 0x00, 0x00, // QDCount = 0 | |
| 0x00, 0x01, // ANCount = 1 | |
| 0x00, 0x00, // NSCount = 0 | |
| 0x00, 0x00, // ARCount = 0 | |
| 0x00, // Name: "." | |
| 0x00, 0x40, // Type: SVCB | |
| 0x00, 0x01, // Class: INET | |
| 0x00, 0x00, 0x00, 0x00, // TTL | |
| 0xff, 0xff, // Length: 65535 (Spoofed) | |
| 0x00, 0x01, // Priority | |
| 0x00, // Target | |
| 0x00, 0x01, // Param Key | |
| 0xff, 0xf8, // Param Length | |
| } | |
| var m Message | |
| err := m.Unpack(msg) | |
| if err == nil { | |
| t.Fatal("expected error parsing malformed message, got nil") | |
| } | |
| } |