Find, verify, and analyze leaked credentials
Go credentialsdevsecopsdynamic-analysisprecommitscanningsecretsecret-managementsecretssecuritysecurity-toolstrufflehogverification
Add Pinecone API key detector (#4917)
dylanTruffleba0a524d6e51
diff --git a/pkg/detectors/pinecone/models.go b/pkg/detectors/pinecone/models.gonew file mode 100644index 000000000..1552d8b93--- /dev/null+++ b/pkg/detectors/pinecone/models.go@@ -0,0 +1,20 @@+package pinecone++type listIndexesResponse struct {+ Indexes []indexInfo `json:"indexes"`+}++type indexInfo struct {+ Name string `json:"name"`+ Host string `json:"host"`+ Spec indexSpec `json:"spec"`+}++type indexSpec struct {+ Serverless *serverlessSpec `json:"serverless,omitempty"`+}++type serverlessSpec struct {+ Cloud string `json:"cloud"`+ Region string `json:"region"`+}diff --git a/pkg/detectors/pinecone/pinecone.go b/pkg/detectors/pinecone/pinecone.gonew file mode 100644index 000000000..99e35e6e7--- /dev/null+++ b/pkg/detectors/pinecone/pinecone.go@@ -0,0 +1,187 @@+package pinecone++import (+ "context"+ "encoding/json"+ "fmt"+ "io"+ "maps"+ "net/http"+ "strconv"+ "strings"++ regexp "github.com/wasilibs/go-re2"++ "github.com/trufflesecurity/trufflehog/v3/pkg/common"+ "github.com/trufflesecurity/trufflehog/v3/pkg/detectors"+ "github.com/trufflesecurity/trufflehog/v3/pkg/pb/detector_typepb"+)++type Scanner struct {+ client *http.Client+}++// Ensure the Scanner satisfies the interface at compile time.+var _ detectors.Detector = (*Scanner)(nil)++var (+ defaultClient = common.SaneHttpClient()++ // Pinecone API keys follow the pattern: pcsk_{label}_{secret}+ // where label is 5-6 alphanumeric chars and secret is exactly 63 alphanumeric+ // chars (total length 74-75). Tight bounds prevent over-reading into adjacent+ // text and rule out partial/malformed matches.+ // Group 1 = whole token, group 2 = label (surfaced as ExtraData["key_id"]).+ keyPat = regexp.MustCompile(`\b(pcsk_([A-Za-z0-9]{5,6})_[A-Za-z0-9]{63})\b`)+)++// Keywords are used for efficiently pre-filtering chunks.+func (s Scanner) Keywords() []string {+ return []string{"pcsk_"}+}++func (s Scanner) getClient() *http.Client {+ if s.client != nil {+ return s.client+ }+ return defaultClient+}++// FromData will find and optionally verify Pinecone secrets in a given set of bytes.+func (s Scanner) FromData(ctx context.Context, verify bool, data []byte) (results []detectors.Result, err error) {+ dataStr := string(data)++ uniqueMatches := make(map[string]string)+ for _, match := range keyPat.FindAllStringSubmatch(dataStr, -1) {+ uniqueMatches[match[1]] = match[2]+ }++ for token, keyID := range uniqueMatches {+ s1 := detectors.Result{+ DetectorType: s.Type(),+ Raw: []byte(token),+ Redacted: token[:8] + "..." + token[len(token)-4:],+ ExtraData: map[string]string{"key_id": keyID},+ SecretParts: map[string]string{"key": token},+ }++ if verify {+ isVerified, extraData, verificationErr := s.verifyMatch(ctx, s.getClient(), token)+ s1.Verified = isVerified+ maps.Copy(s1.ExtraData, extraData)+ s1.SetVerificationError(verificationErr, token)+ }++ results = append(results, s1)+ }++ return results, nil+}++// verifyMatch calls the Pinecone List Indexes endpoint (GET /indexes) to validate the key.+// Per the Pinecone API reference, this control-plane endpoint returns 200/401/500.+// 403 is not documented but is observed in practice for valid keys that lack+// ControlPlane permissions (e.g. DataPlaneViewer role).+func (s Scanner) verifyMatch(ctx context.Context, client *http.Client, token string) (bool, map[string]string, error) {+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://api.pinecone.io/indexes", http.NoBody)+ if err != nil {+ return false, nil, err+ }+ req.Header.Set("Api-Key", token)+ req.Header.Set("X-Pinecone-Api-Version", "2025-10")+ req.Header.Set("Accept", "application/json")++ resp, err := client.Do(req)+ if err != nil {+ return false, nil, err+ }+ defer func() {+ _, _ = io.Copy(io.Discard, resp.Body)+ _ = resp.Body.Close()+ }()++ switch resp.StatusCode {+ case http.StatusOK:+ bodyBytes, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))+ if err != nil {+ return false, nil, err+ }+ var apiResp listIndexesResponse+ if err := json.Unmarshal(bodyBytes, &apiResp); err != nil {+ return false, nil, fmt.Errorf("failed to decode 200 response: %w", err)+ }+ // Guard against a generic 200 that doesn't have the "indexes" key at all:+ // JSON unmarshal leaves Indexes as nil in that case, which we treat as a+ // malformed response rather than a legitimate empty-indexes result.+ if apiResp.Indexes == nil {+ return false, nil, fmt.Errorf("unexpected response body structure")+ }+ return true, buildIndexExtraData(apiResp.Indexes), nil++ case http.StatusUnauthorized:+ return false, nil, nil++ case http.StatusForbidden:+ // 403 means the key authenticated but lacks permission for this endpoint.+ // Official docs do not mention this, but the apikey creation allows setting custom permissions,+ // and we have observed 403 responses in practice for valid keys with insufficient permissions.+ // We treat this as "verified but with limited permissions" rather than indeterminate+ return true, map[string]string{"permission": "restricted"}, nil++ default:+ return false, nil, fmt.Errorf("unexpected HTTP response status %d", resp.StatusCode)+ }+}++// extractProjectID pulls the project slug from a Pinecone index host string.+// Hosts follow the pattern: {index-name}-{project_id}.svc.{env}.pinecone.io+func extractProjectID(host string) string {+ prefix, _, ok := strings.Cut(host, ".svc.")+ if !ok {+ return ""+ }+ lastDash := strings.LastIndex(prefix, "-")+ if lastDash == -1 {+ return ""+ }+ return prefix[lastDash+1:]+}++// buildIndexExtraData derives human-useful context (project id, up to 5 index+// summaries) from the list-indexes response. Returns nil when there are no+// indexes to describe.+func buildIndexExtraData(indexes []indexInfo) map[string]string {+ extraData := map[string]string{+ "total_indexes": strconv.Itoa(len(indexes)),+ }++ for _, idx := range indexes {+ if pid := extractProjectID(idx.Host); pid != "" {+ extraData["project_id"] = pid+ break+ }+ }++ for i, idx := range indexes {+ if i >= 5 {+ break+ }+ prefix := fmt.Sprintf("index_%d_", i)+ extraData[prefix+"name"] = idx.Name+ extraData[prefix+"host"] = idx.Host+ if idx.Spec.Serverless != nil {+ extraData[prefix+"cloud"] = idx.Spec.Serverless.Cloud+ extraData[prefix+"region"] = idx.Spec.Serverless.Region+ }+ }++ return extraData+}++func (s Scanner) Type() detector_typepb.DetectorType {+ return detector_typepb.DetectorType_Pinecone+}++func (s Scanner) Description() string {+ return "Pinecone is a vector database service. API keys can be used to manage indexes and perform vector operations."+}diff --git a/pkg/detectors/pinecone/pinecone_integration_test.go b/pkg/detectors/pinecone/pinecone_integration_test.gonew file mode 100644index 000000000..c31964898--- /dev/null+++ b/pkg/detectors/pinecone/pinecone_integration_test.go@@ -0,0 +1,161 @@+//go:build detectors+// +build detectors++package pinecone++import (+ "context"+ "fmt"+ "testing"+ "time"++ "github.com/google/go-cmp/cmp"+ "github.com/google/go-cmp/cmp/cmpopts"++ "github.com/trufflesecurity/trufflehog/v3/pkg/common"+ "github.com/trufflesecurity/trufflehog/v3/pkg/detectors"+ "github.com/trufflesecurity/trufflehog/v3/pkg/pb/detector_typepb"+)++func TestPinecone_FromChunk(t *testing.T) {+ ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)+ defer cancel()+ testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors6")+ if err != nil {+ t.Fatalf("could not get test secrets from GCP: %s", err)+ }+ secret := testSecrets.MustGetField("PINECONE")+ inactiveSecret := testSecrets.MustGetField("PINECONE_INACTIVE")++ type args struct {+ ctx context.Context+ data []byte+ verify bool+ }+ tests := []struct {+ name string+ s Scanner+ args args+ want []detectors.Result+ wantErr bool+ wantVerificationErr bool+ }{+ {+ name: "found, verified",+ s: Scanner{},+ args: args{+ ctx: context.Background(),+ data: []byte(fmt.Sprintf("You can find a pinecone secret %s within", secret)),+ verify: true,+ },+ want: []detectors.Result{+ {+ DetectorType: detector_typepb.DetectorType_Pinecone,+ Verified: true,+ },+ },+ wantErr: false,+ wantVerificationErr: false,+ },+ {+ name: "found, unverified",+ s: Scanner{},+ args: args{+ ctx: context.Background(),+ data: []byte(fmt.Sprintf("You can find a pinecone secret %s within but not valid", inactiveSecret)),+ verify: true,+ },+ want: []detectors.Result{+ {+ DetectorType: detector_typepb.DetectorType_Pinecone,+ Verified: false,+ },+ },+ wantErr: false,+ wantVerificationErr: false,+ },+ {+ name: "not found",+ s: Scanner{},+ args: args{+ ctx: context.Background(),+ data: []byte("You cannot find the secret within"),+ verify: true,+ },+ want: nil,+ wantErr: false,+ wantVerificationErr: false,+ },+ {+ name: "found, would be verified if not for timeout",+ s: Scanner{client: common.SaneHttpClientTimeOut(1 * time.Microsecond)},+ args: args{+ ctx: context.Background(),+ data: []byte(fmt.Sprintf("You can find a pinecone secret %s within", secret)),+ verify: true,+ },+ want: []detectors.Result{+ {+ DetectorType: detector_typepb.DetectorType_Pinecone,+ Verified: false,+ },+ },+ wantErr: false,+ wantVerificationErr: true,+ },+ {+ name: "found, unexpected api surface",+ s: Scanner{client: common.ConstantResponseHttpClient(500, "")},+ args: args{+ ctx: context.Background(),+ data: []byte(fmt.Sprintf("You can find a pinecone secret %s within", secret)),+ verify: true,+ },+ want: []detectors.Result{+ {+ DetectorType: detector_typepb.DetectorType_Pinecone,+ Verified: false,+ },+ },+ wantErr: false,+ wantVerificationErr: true,+ },+ }+ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ got, err := tt.s.FromData(tt.args.ctx, tt.args.verify, tt.args.data)+ if (err != nil) != tt.wantErr {+ t.Errorf("Pinecone.FromData() error = %v, wantErr %v", err, tt.wantErr)+ return+ }+ for i := range got {+ if len(got[i].Raw) == 0 {+ t.Fatalf("no raw secret present: \n %+v", got[i])+ }+ if (got[i].VerificationError() != nil) != tt.wantVerificationErr {+ t.Fatalf("wantVerificationError = %v, verification error = %v", tt.wantVerificationErr, got[i].VerificationError())+ }+ }+ ignoreOpts := cmpopts.IgnoreFields(detectors.Result{}, "Raw", "RawV2", "Redacted", "ExtraData", "SecretParts", "verificationError", "primarySecret")+ if diff := cmp.Diff(got, tt.want, ignoreOpts); diff != "" {+ t.Errorf("Pinecone.FromData() %s diff: (-got +want)\n%s", tt.name, diff)+ }+ })+ }+}++func BenchmarkFromData(benchmark *testing.B) {+ ctx := context.Background()+ s := Scanner{}+ for name, data := range detectors.MustGetBenchmarkData() {+ benchmark.Run(name, func(b *testing.B) {+ b.ResetTimer()+ for n := 0; n < b.N; n++ {+ _, err := s.FromData(ctx, false, data)+ if err != nil {+ b.Fatal(err)+ }+ }+ })+ }+}diff --git a/pkg/detectors/pinecone/pinecone_test.go b/pkg/detectors/pinecone/pinecone_test.gonew file mode 100644index 000000000..4edc1b7cb--- /dev/null+++ b/pkg/detectors/pinecone/pinecone_test.go@@ -0,0 +1,304 @@+package pinecone++import (+ "context"+ "io"+ "net/http"+ "strings"+ "testing"++ "github.com/google/go-cmp/cmp"++ "github.com/trufflesecurity/trufflehog/v3/pkg/detectors"+ "github.com/trufflesecurity/trufflehog/v3/pkg/engine/ahocorasick"+)++var (+ // 6-char label, 63-char secret (75 chars total)+ validKeyLong = "pcsk_T5Afk6_5qU9s3iLVFmaSaJtMat7gTHaT9fXa7ykiBk7iz4uUMuLGLemkdutTgwJevYhqtn"+ // 5-char label, 63-char secret (74 chars total)+ validKeyShort = "pcsk_wtQV4_J9qqVGjiMW81LJ9H59iajZMWMedenyLnGVR3vbCWq6V3oaEvcQYwPFQpupFUth1"+ invalidKeyNoID = "pcsk__5qU9s3iLVFmaSaJtMat7gTHaT9fXa7ykiBk7iz4uUMuLGLemkdutTgwJevYhqtn"+ invalidPrefix = "pineconeT5Afk6_5qU9s3iLVFmaSaJtMat7gTHaT9fXa7ykiBk7iz4uUMuLGLemkdutTgwJevYhqtn"+ keyword = "pinecone"+)++type roundTripFunc func(*http.Request) (*http.Response, error)++func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {+ return f(req)+}++func TestPinecone_Pattern(t *testing.T) {+ d := Scanner{}+ ahoCorasickCore := ahocorasick.NewAhoCorasickCore([]detectors.Detector{d})++ tests := []struct {+ name string+ input string+ want []string+ }{+ {+ name: "valid pattern - env var assignment",+ input: keyword + "_API_KEY=" + validKeyLong,+ want: []string{validKeyLong},+ },+ {+ name: "valid pattern - short label",+ input: "export PINECONE_API_KEY=" + validKeyShort,+ want: []string{validKeyShort},+ },+ {+ name: "valid pattern - config file",+ input: `+ pinecone:+ api_key: "` + validKeyLong + `"+ environment: us-east-1-aws+ `,+ want: []string{validKeyLong},+ },+ {+ name: "valid pattern - multiple distinct keys",+ input: "primary=" + validKeyLong + " secondary=" + validKeyShort,+ want: []string{validKeyLong, validKeyShort},+ },+ {+ name: "invalid pattern - missing key_id",+ input: invalidKeyNoID,+ want: []string{},+ },+ {+ name: "invalid pattern - wrong prefix",+ input: invalidPrefix,+ want: []string{},+ },+ {+ name: "invalid pattern - secret too short",+ input: "pcsk_abcd1_tooShort",+ want: []string{},+ },+ {+ name: "invalid pattern - label too short (4 chars)",+ input: "pcsk_abcd_5qU9s3iLVFmaSaJtMat7gTHaT9fXa7ykiBk7iz4uUMuLGLemkdutTgwJevYhqtn",+ want: []string{},+ },+ {+ name: "invalid pattern - secret has trailing alphanumeric",+ input: validKeyLong + "EXTRA",+ want: []string{},+ },+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ matchedDetectors := ahoCorasickCore.FindDetectorMatches([]byte(test.input))+ if len(matchedDetectors) == 0 && len(test.want) > 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) {+ t.Errorf("expected %d results, got %d", len(test.want), len(results))+ for _, r := range results {+ t.Logf("got: %s", string(r.Raw))+ }+ return+ }++ actual := make(map[string]struct{}, len(results))+ for _, r := range results {+ 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 TestPinecone_ExtractProjectID(t *testing.T) {+ tests := []struct {+ name string+ host string+ want string+ }{+ {+ name: "serverless host",+ host: "my-index-abc1234.svc.us-east1-aws.pinecone.io",+ want: "abc1234",+ },+ {+ name: "hyphenated index name",+ host: "my-cool-index-xyz9876.svc.us-west-2.pinecone.io",+ want: "xyz9876",+ },+ {+ name: "missing .svc. segment",+ host: "my-index.pinecone.io",+ want: "",+ },+ {+ name: "missing hyphen before .svc.",+ host: "abc.svc.us-east1.pinecone.io",+ want: "",+ },+ {+ name: "empty host",+ host: "",+ want: "",+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ got := extractProjectID(tt.host)+ if got != tt.want {+ t.Errorf("extractProjectID(%q) = %q, want %q", tt.host, got, tt.want)+ }+ })+ }+}++func TestPinecone_VerifyMatchSuccess(t *testing.T) {+ scanner := Scanner{client: &http.Client{+ Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {+ if req.Method != http.MethodGet {+ t.Fatalf("expected GET request, got %s", req.Method)+ }+ if req.URL.String() != "https://api.pinecone.io/indexes" {+ t.Fatalf("unexpected URL %s", req.URL.String())+ }+ if got := req.Header.Get("Api-Key"); got != validKeyLong {+ t.Fatalf("unexpected api key header %q", got)+ }+ if got := req.Header.Get("X-Pinecone-Api-Version"); got != "2025-10" {+ t.Fatalf("unexpected api version header %q", got)+ }++ body := `{"indexes":[{"name":"example-index","host":"example-index-abc1234.svc.us-east1-aws.pinecone.io","spec":{"serverless":{"cloud":"aws","region":"us-east-1"}}}]}`+ return &http.Response{+ StatusCode: http.StatusOK,+ Body: io.NopCloser(strings.NewReader(body)),+ Header: make(http.Header),+ Request: req,+ }, nil+ }),+ }}++ verified, extraData, err := scanner.verifyMatch(context.Background(), scanner.client, validKeyLong)+ if err != nil {+ t.Fatalf("verifyMatch returned error: %v", err)+ }+ if !verified {+ t.Fatal("expected token to verify successfully")+ }+ if extraData["total_indexes"] != "1" {+ t.Fatalf("expected total_indexes=1, got %q", extraData["total_indexes"])+ }+ if extraData["project_id"] != "abc1234" {+ t.Fatalf("expected project_id=abc1234, got %q", extraData["project_id"])+ }+ if extraData["index_0_name"] != "example-index" {+ t.Fatalf("expected index_0_name to be populated, got %q", extraData["index_0_name"])+ }+}++func TestPinecone_VerifyMatchRejectsMissingIndexesKey(t *testing.T) {+ scanner := Scanner{client: &http.Client{+ Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {+ return &http.Response{+ StatusCode: http.StatusOK,+ Body: io.NopCloser(strings.NewReader(`{"projects":[]}`)),+ Header: make(http.Header),+ Request: req,+ }, nil+ }),+ }}++ verified, extraData, err := scanner.verifyMatch(context.Background(), scanner.client, validKeyLong)+ if err == nil {+ t.Fatal("expected an error for malformed 200 response")+ }+ if !strings.Contains(err.Error(), "unexpected response body structure") {+ t.Fatalf("unexpected error: %v", err)+ }+ if verified {+ t.Fatal("expected malformed 200 response to remain unverified")+ }+ if extraData != nil {+ t.Fatalf("expected no extra data, got %#v", extraData)+ }+}++func TestPinecone_VerifyMatchRejectsInvalidIndexesPayload(t *testing.T) {+ scanner := Scanner{client: &http.Client{+ Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {+ return &http.Response{+ StatusCode: http.StatusOK,+ Body: io.NopCloser(strings.NewReader(`{"indexes":{}}`)),+ Header: make(http.Header),+ Request: req,+ }, nil+ }),+ }}++ verified, extraData, err := scanner.verifyMatch(context.Background(), scanner.client, validKeyLong)+ if err == nil {+ t.Fatal("expected a decode error for invalid indexes payload")+ }+ if !strings.Contains(err.Error(), "failed to decode 200 response") {+ t.Fatalf("unexpected error: %v", err)+ }+ if verified {+ t.Fatal("expected invalid indexes payload to remain unverified")+ }+ if extraData != nil {+ t.Fatalf("expected no extra data, got %#v", extraData)+ }+}++func TestPinecone_FromDataPreservesMetadataOnVerificationError(t *testing.T) {+ scanner := Scanner{+ client: &http.Client{+ Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {+ return &http.Response{+ StatusCode: http.StatusOK,+ Body: io.NopCloser(strings.NewReader(`{"indexes":{}}`)),+ Header: make(http.Header),+ Request: req,+ }, nil+ }),+ },+ }++ results, err := scanner.FromData(context.Background(), true, []byte(validKeyLong))+ if err != nil {+ t.Fatalf("FromData returned error: %v", err)+ }+ if len(results) != 1 {+ t.Fatalf("expected one result, got %d", len(results))+ }+ if results[0].Verified {+ t.Fatal("expected malformed verification response to keep result unverified")+ }+ if results[0].VerificationError() == nil {+ t.Fatal("expected malformed verification response to set a verification error")+ }+ if got := results[0].ExtraData["key_id"]; got != "T5Afk6" {+ t.Fatalf("expected key_id=T5Afk6, got %q", got)+ }+ if got := results[0].SecretParts["key"]; got != validKeyLong {+ t.Fatalf("expected secret key part to be preserved, got %q", got)+ }+}diff --git a/pkg/engine/defaults/defaults.go b/pkg/engine/defaults/defaults.goindex 46db6f158..7f5a58383 100644--- a/pkg/engine/defaults/defaults.go+++ b/pkg/engine/defaults/defaults.go@@ -559,6 +559,7 @@ import ("github.com/trufflesecurity/trufflehog/v3/pkg/detectors/photoroom""github.com/trufflesecurity/trufflehog/v3/pkg/detectors/phraseaccesstoken""github.com/trufflesecurity/trufflehog/v3/pkg/detectors/pinata"+ "github.com/trufflesecurity/trufflehog/v3/pkg/detectors/pinecone""github.com/trufflesecurity/trufflehog/v3/pkg/detectors/pipedream""github.com/trufflesecurity/trufflehog/v3/pkg/detectors/pipedrive""github.com/trufflesecurity/trufflehog/v3/pkg/detectors/pivotaltracker"@@ -1445,6 +1446,7 @@ func buildDetectorList() []detectors.Detector {&photoroom.Scanner{},&phraseaccesstoken.Scanner{},&pinata.Scanner{},+ &pinecone.Scanner{},&pipedream.Scanner{},&pipedrive.Scanner{},&pivotaltracker.Scanner{},diff --git a/pkg/pb/detector_typepb/detector_type.pb.go b/pkg/pb/detector_typepb/detector_type.pb.goindex 9876452be..c4a8365ad 100644--- a/pkg/pb/detector_typepb/detector_type.pb.go+++ b/pkg/pb/detector_typepb/detector_type.pb.go@@ -1102,6 +1102,7 @@ const (DetectorType_JiraDataCenterPAT DetectorType = 1046DetectorType_ConfluenceDataCenter DetectorType = 1047DetectorType_Cloudinary DetectorType = 1048+ DetectorType_Pinecone DetectorType = 1049)// Enum value maps for DetectorType.@@ -2152,6 +2153,7 @@ var (1046: "JiraDataCenterPAT",1047: "ConfluenceDataCenter",1048: "Cloudinary",+ 1049: "Pinecone",}DetectorType_value = map[string]int32{"Alibaba": 0,@@ -3199,6 +3201,7 @@ var ("JiraDataCenterPAT": 1046,"ConfluenceDataCenter": 1047,"Cloudinary": 1048,+ "Pinecone": 1049,})@@ -3234,7 +3237,7 @@ var File_detector_type_proto protoreflect.FileDescriptorvar file_detector_type_proto_rawDesc = []byte{0x0a, 0x13, 0x64, 0x65, 0x74, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2e,0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0d, 0x64, 0x65, 0x74, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f,- 0x74, 0x79, 0x70, 0x65, 0x2a, 0x9d, 0x88, 0x01, 0x0a, 0x0c, 0x44, 0x65, 0x74, 0x65, 0x63, 0x74,+ 0x74, 0x79, 0x70, 0x65, 0x2a, 0xac, 0x88, 0x01, 0x0a, 0x0c, 0x44, 0x65, 0x74, 0x65, 0x63, 0x74,0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x41, 0x6c, 0x69, 0x62, 0x61, 0x62,0x61, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x41, 0x4d, 0x51, 0x50, 0x10, 0x01, 0x12, 0x07, 0x0a,0x03, 0x41, 0x57, 0x53, 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x41, 0x7a, 0x75, 0x72, 0x65, 0x10,@@ -4324,11 +4327,12 @@ var file_detector_type_proto_rawDesc = []byte{0x74, 0x65, 0x72, 0x50, 0x41, 0x54, 0x10, 0x96, 0x08, 0x12, 0x19, 0x0a, 0x14, 0x43, 0x6f, 0x6e,0x66, 0x6c, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, 0x43, 0x65, 0x6e, 0x74, 0x65,0x72, 0x10, 0x97, 0x08, 0x12, 0x0f, 0x0a, 0x0a, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x69, 0x6e, 0x61,- 0x72, 0x79, 0x10, 0x98, 0x08, 0x42, 0x41, 0x5a, 0x3f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,- 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x72, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x73, 0x65, 0x63, 0x75, 0x72,- 0x69, 0x74, 0x79, 0x2f, 0x74, 0x72, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x68, 0x6f, 0x67, 0x2f, 0x76,- 0x33, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x62, 0x2f, 0x64, 0x65, 0x74, 0x65, 0x63, 0x74, 0x6f,- 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,+ 0x72, 0x79, 0x10, 0x98, 0x08, 0x12, 0x0d, 0x0a, 0x08, 0x50, 0x69, 0x6e, 0x65, 0x63, 0x6f, 0x6e,+ 0x65, 0x10, 0x99, 0x08, 0x42, 0x41, 0x5a, 0x3f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,+ 0x6f, 0x6d, 0x2f, 0x74, 0x72, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69,+ 0x74, 0x79, 0x2f, 0x74, 0x72, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x68, 0x6f, 0x67, 0x2f, 0x76, 0x33,+ 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x62, 0x2f, 0x64, 0x65, 0x74, 0x65, 0x63, 0x74, 0x6f, 0x72,+ 0x5f, 0x74, 0x79, 0x70, 0x65, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,}var (diff --git a/proto/detector_type.proto b/proto/detector_type.protoindex 5b0f0f42f..6e7161cd3 100644--- a/proto/detector_type.proto+++ b/proto/detector_type.proto@@ -1050,4 +1050,5 @@ enum DetectorType {JiraDataCenterPAT = 1046;ConfluenceDataCenter = 1047;Cloudinary = 1048;+ Pinecone = 1049;}