Find, verify, and analyze leaked credentials
Go credentialsdevsecopsdynamic-analysisprecommitscanningsecretsecret-managementsecretssecuritysecurity-toolstrufflehogverification
package github
import (
"context"
"reflect"
"strings"
"testing"
regexp "github.com/wasilibs/go-re2"
"github.com/google/go-cmp/cmp"
"github.com/trufflesecurity/trufflehog/v3/pkg/detectors"
"github.com/trufflesecurity/trufflehog/v3/pkg/engine/ahocorasick"
)
var (
validPattern = `[{
"_id": "1a8d0cca-e1a9-4318-bc2f-f5658ab2dcb5",
"name": "Github",
"type": "Detector",
"api": true,
"authentication_type": "",
"verification_url": "https://api.example.com/example",
"test_secrets": {
"github_secret": "ghs_RWGUZ6kS8_Ut7PbtR72k2miJwwYtxkpe8mOpT8feAWYZcwz43PxBVGCNATnycaQV9VUlPJe1uST5Xen7d3uZ5lilVlEVvT9AbxnhURdT3OzPtCvXydIrvE4LrDO"
},
"expected_response": "200",
"method": "GET",
"deprecated": false
}]`
secret = "ghs_RWGUZ6kS8_Ut7PbtR72k2miJwwYtxkpe8mOpT8feAWYZcwz43PxBVGCNATnycaQV9VUlPJe1uST5Xen7d3uZ5lilVlEVvT9AbxnhURdT3OzPtCvXydIrvE4LrDO"
)
func TestGithub_Pattern(t *testing.T) {
d := Scanner{}
ahoCorasickCore := ahocorasick.NewAhoCorasickCore([]detectors.Detector{d})
tests := []struct {
name string
input string
want []string
}{
{
name: "valid pattern",
input: validPattern,
want: []string{secret},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
matchedDetectors := ahoCorasickCore.FindDetectorMatches([]byte(test.input))
if len(matchedDetectors) == 0 {
t.Errorf("keywords '%v' not matched by: %s", d.Keywords(), test.input)
return
}
results, err := d.FromData(context.Background(), false, []byte(test.input))
if err != nil {
t.Errorf("error = %v", err)
return
}
if len(results) != len(test.want) {
if len(results) == 0 {
t.Errorf("did not receive result")
} else {
t.Errorf("expected %d results, only received %d", len(test.want), len(results))
}
return
}
actual := make(map[string]struct{}, len(results))
for _, r := range results {
if len(r.RawV2) > 0 {
actual[string(r.RawV2)] = struct{}{}
} else {
actual[string(r.Raw)] = struct{}{}
}
}
expected := make(map[string]struct{}, len(test.want))
for _, v := range test.want {
expected[v] = struct{}{}
}
if diff := cmp.Diff(expected, actual); diff != "" {
t.Errorf("%s diff: (-want +got)\n%s", test.name, diff)
}
})
}
}
func TestGithubTokenType(t *testing.T) {
tests := []struct {
prefix string
token string
want string
}{
{"ghp_", "ghp_" + strings.Repeat("a", 36), "Personal Access Token (classic)"},
{"github_pat_", "github_pat_" + strings.Repeat("a", 36), "Personal Access Token (fine-grained)"},
{"gho_", "gho_" + strings.Repeat("a", 36), "OAuth Access Token"},
{"ghu_", "ghu_" + strings.Repeat("a", 36), "GitHub App User-to-Server Token"},
{"ghs_", "ghs_" + strings.Repeat("a", 36), "GitHub App Server-to-Server (installation) Token"},
{"ghr_", "ghr_" + strings.Repeat("a", 36), "GitHub App Refresh Token"},
{"unknown", "not_a_github_token", "Unknown GitHub token"},
}
for _, test := range tests {
t.Run(test.prefix, func(t *testing.T) {
got := githubTokenType(test.token)
if got != test.want {
t.Errorf("githubTokenType(%q) = %q, want %q", test.token, got, test.want)
}
})
}
}
// prefixAlternationPat pulls the prefix alternation out of keyPat's source,
// e.g. `(?:ghp|gho|ghu|ghs|ghr|github_pat)_` -> `ghp|gho|ghu|ghs|ghr|github_pat`.
var prefixAlternationPat = regexp.MustCompile(`\(\?:([a-zA-Z0-9_|]+)\)_`)
// keyPatPrefixes derives the token prefixes directly from keyPat's own source
// rather than from a hand-maintained list. If the two disagree, the regex is
// the authority — it is what actually decides whether a token is matched at
// all.
func keyPatPrefixes(t *testing.T) []string {
t.Helper()
m := prefixAlternationPat.FindStringSubmatch(keyPat.String())
if m == nil {
t.Fatalf("could not find a prefix alternation group in keyPat: %s\n"+
"keyPat's shape changed; update prefixAlternationPat to match, or this "+
"drift guard is silently testing nothing.", keyPat.String())
}
var prefixes []string
for _, alt := range strings.Split(m[1], "|") {
prefixes = append(prefixes, alt+"_")
}
return prefixes
}
// TestGithubTokenType_MappingMatchesKeyPatExactly is the drift guard: it
// derives the prefix set from keyPat itself rather than a hand-maintained
// list, so a seventh prefix added to keyPat and forgotten in the map cannot
// slip past silently — the regex and the map cannot diverge without a
// failure.
//
// This matters more than a normal mapping test: an unmapped prefix does not
// crash, it silently reports "Unknown GitHub token", which puts a responder
// back in the position this detector change exists to fix — holding a real
// leaked credential with no idea how to revoke it.
func TestGithubTokenType_MappingMatchesKeyPatExactly(t *testing.T) {
prefixes := keyPatPrefixes(t)
if len(prefixes) == 0 {
t.Fatal("derived zero prefixes from keyPat; the guard is not testing anything")
}
fromKeyPat := make(map[string]bool, len(prefixes))
for _, p := range prefixes {
fromKeyPat[p] = true
if _, ok := tokenTypesByPrefix[p]; !ok {
t.Errorf("keyPat matches prefix %q but tokenTypesByPrefix has no entry for it; "+
"a leaked token with this prefix would be reported as %q",
p, "Unknown GitHub token")
}
}
// The reverse direction: a mapping entry for a prefix keyPat cannot match is
// dead weight, and usually means a prefix was renamed in one place only.
for p := range tokenTypesByPrefix {
if !fromKeyPat[p] {
t.Errorf("tokenTypesByPrefix has an entry for %q, but keyPat never matches that prefix", p)
}
}
}
// assertNoBlankFields checks that v is not a blank string, or — if v is a
// struct — that none of its exported fields are blank strings. It exists so
// that if a row's value type grows a second field (tokenTypesByPrefix held a
// {TokenType, Remediation} struct before remediation was removed, and could
// again), row validation below catches an unset field automatically instead
// of depending on someone remembering to add a field-specific check.
func assertNoBlankFields(t *testing.T, label string, v reflect.Value) {
t.Helper()
switch v.Kind() {
case reflect.String:
if strings.TrimSpace(v.String()) == "" {
t.Errorf("%s: blank value", label)
}
case reflect.Struct:
vt := v.Type()
for i := 0; i < v.NumField(); i++ {
field := vt.Field(i)
if !field.IsExported() {
continue
}
assertNoBlankFields(t, label+"."+field.Name, v.Field(i))
}
default:
t.Fatalf("%s: assertNoBlankFields does not know how to validate kind %s; extend the helper for the new row type", label, v.Kind())
}
}
// TestTokenTypesByPrefix_RowsAreWellFormed checks each row in
// tokenTypesByPrefix in isolation, independent of keyPat. The tests above
// confirm the map's keys line up with keyPat; none of them would catch a
// malformed row added alongside a correct key — e.g. a copy-pasted value
// that leaves two different prefixes describing the same token type, or a
// field left blank.
func TestTokenTypesByPrefix_RowsAreWellFormed(t *testing.T) {
const unknown = "Unknown GitHub token"
seenValues := make(map[string]string, len(tokenTypesByPrefix)) // value -> first prefix that used it
for prefix, tokenType := range tokenTypesByPrefix {
if prefix == "" {
t.Error("tokenTypesByPrefix has an empty-string prefix key")
}
if !strings.HasSuffix(prefix, "_") {
t.Errorf("prefix %q does not end in \"_\"; githubTokenType matches by strings.HasPrefix, so a bare prefix can match unrelated tokens", prefix)
}
assertNoBlankFields(t, prefix, reflect.ValueOf(tokenType))
if tokenType == unknown {
t.Errorf("prefix %q maps to the reserved fallback value %q; a real row must not collide with it", prefix, unknown)
}
if other, dup := seenValues[tokenType]; dup {
t.Errorf("prefixes %q and %q both map to token type %q; each prefix must describe a distinct credential", prefix, other, tokenType)
} else {
seenValues[tokenType] = prefix
}
}
}
// TestGithubTokenType_EveryKeyPatPrefixResolves closes the loop end to end:
// build a token for each prefix keyPat actually accepts, confirm keyPat
// matches it, and confirm githubTokenType resolves it to something other than
// the unknown fallback. The two tests above check the data structures agree;
// this one checks the behaviour they produce is correct for every real input.
func TestGithubTokenType_EveryKeyPatPrefixResolves(t *testing.T) {
const unknown = "Unknown GitHub token"
for _, prefix := range keyPatPrefixes(t) {
t.Run(prefix, func(t *testing.T) {
token := prefix + strings.Repeat("a", 36)
if !keyPat.MatchString(token) {
t.Fatalf("keyPat does not match %q built from its own prefix alternation; "+
"the derived prefix is wrong or keyPat's body changed", token)
}
got := githubTokenType(token)
if got == unknown {
t.Errorf("githubTokenType(%q) = %q; every prefix keyPat matches must resolve to a real type", token, got)
}
if got == "" {
t.Errorf("githubTokenType(%q) returned an empty type", token)
}
})
}
}