DataDog
diff --git a/‎pkg/dyninst/gosymname/BUILD.bazel‎
Lines changed: 1 addition & 0 deletions b/‎pkg/dyninst/gosymname/BUILD.bazel‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎pkg/dyninst/gosymname/escape.go‎
Lines changed: 34 additions & 0 deletions b/‎pkg/dyninst/gosymname/escape.go‎
Lines changed: 34 additions & 0 deletions
diff --git a/‎pkg/dyninst/gosymname/escape_test.go‎
Lines changed: 79 additions & 0 deletions b/‎pkg/dyninst/gosymname/escape_test.go‎
Lines changed: 79 additions & 0 deletions
@@ -21,6 +21,7 @@ go_test(
     srcs = [
         "benchmark_test.go",
         "comparison_test.go",
+        "escape_test.go",
         "fuzz_test.go",
         "generic_test.go",
         "symbol_test.go",
 
@@ -37,6 +37,40 @@ func splitPkg(name string) (pkgpath, sym string) {
 	return "", name
 }
 
+// EscapePkg escapes a Go package import path the same way the Go toolchain
+// does when emitting linker symbol names. Specifically: control bytes,
+// space, '%', '"', non-7-bit-clean bytes, and '.' bytes that appear after
+// the last '/' are encoded as %XX (lowercase hex). Other bytes are left
+// untouched. This mirrors cmd/internal/objabi.PathToPrefix in the Go
+// source tree.
+func EscapePkg(s string) string {
+	slash := strings.LastIndex(s, "/")
+	n := 0
+	for i := 0; i < len(s); i++ {
+		if needsEscape(s[i], i, slash) {
+			n++
+		}
+	}
+	if n == 0 {
+		return s
+	}
+	const hex = "0123456789abcdef"
+	p := make([]byte, 0, len(s)+2*n)
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if needsEscape(c, i, slash) {
+			p = append(p, '%', hex[c>>4], hex[c&0xF])
+		} else {
+			p = append(p, c)
+		}
+	}
+	return string(p)
+}
+
+func needsEscape(c byte, i, lastSlash int) bool {
+	return c <= ' ' || (c == '.' && i > lastSlash) || c == '%' || c == '"' || c >= 0x7F
+}
+
 // unescapePkg unescapes a package import path, replacing %XX escape sequences
 // with the original characters. Returns the unescaped path.
 func unescapePkg(s string) (string, error) {
 
@@ -0,0 +1,79 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2025-present Datadog, Inc.
+
+package gosymname
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestEscapePkg(t *testing.T) {
+	cases := []struct {
+		name string
+		in   string
+		out  string
+	}{
+		{"plain", "main", "main"},
+		{"single_dot_in_segment", "lib.v2", "lib%2ev2"},
+		{"slash_then_dot", "gopkg.in/ini.v1", "gopkg.in/ini%2ev1"},
+		{"multi_segment_no_dot_last", "github.com/DataDog/datadog-agent/pkg/foo", "github.com/DataDog/datadog-agent/pkg/foo"},
+		{"multi_segment_dot_last", "github.com/DataDog/datadog-agent/pkg/foo.v2", "github.com/DataDog/datadog-agent/pkg/foo%2ev2"},
+		{"multiple_dots_last", "a.b.c", "a%2eb%2ec"},
+		{"percent", "weird%name", "weird%25name"},
+		{"quote", `q"x`, `q%22x`},
+		{"empty", "", ""},
+		{"trailing_dot", "pkg.", "pkg%2e"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got := EscapePkg(c.in)
+			require.Equal(t, c.out, got)
+			// Round-trip through unescapePkg.
+			back, err := unescapePkg(got)
+			require.NoError(t, err)
+			require.Equal(t, c.in, back)
+		})
+	}
+}
+
+// FuzzEscapePkg asserts that unescapePkg ∘ EscapePkg is the identity:
+// every input round-trips through escape and unescape unchanged. Seeds
+// cover the kinds of paths we observe in real Go binaries: plain import
+// paths, paths with dotted last segments, the corner cases EscapePkg
+// specifically handles (control bytes, quotes, percent, high bytes),
+// and a few empty/edge inputs.
+func FuzzEscapePkg(f *testing.F) {
+	seeds := []string{
+		"",
+		"main",
+		"lib.v2",
+		"gopkg.in/ini.v1",
+		"github.com/DataDog/datadog-agent/pkg/dyninst/symdb",
+		"github.com/DataDog/datadog-agent/pkg/dyninst/testprogs/progs/sample/lib.v2",
+		"a.b.c",
+		"a/b.c",
+		"a/b.c/d",
+		"weird%name",
+		`q"x`,
+		"pkg.",
+		"\x00\x01 \x7f",
+		"\xc3\xa9",            // multi-byte UTF-8 (é)
+		"go.opencensus.io",    // dotted top-level
+		"k8s.io/api/core/v1",  // dotted top, plain last
+		"sigs.k8s.io/yaml.v1", // dotted top + dotted last
+	}
+	for _, s := range seeds {
+		f.Add(s)
+	}
+
+	f.Fuzz(func(t *testing.T, s string) {
+		got := EscapePkg(s)
+		back, err := unescapePkg(got)
+		require.NoError(t, err, "unescapePkg failed on EscapePkg(%q)=%q", s, got)
+		require.Equal(t, s, back, "round-trip mismatch for %q (escaped=%q)", s, got)
+	})
+}