Building 70 Projects ranging from beginner to advanced so anyone can — learn from, build upon, use as a reference, or even copy directly. Owned by my cybersecurity company đŸ‘‡
Go aicertificationcloud-engineeringcybercybersecuritycybersecurity-analystcybersecurity-certificationcybersecurity-certificationscybersecurity-educationcybersecurity-jobscybersecurity-portfoliocybersecurity-projectscybersecurity-toolsgrchackinglearningpentestingproject-repositoryprojetcspython
feat(canary): token HTTP handlers (API + trigger routes)
CarterPerez-dev0a456f97aeb6
diff --git a/PROJECTS/beginner/canary-token-generator/backend/internal/token/handler.go b/PROJECTS/beginner/canary-token-generator/backend/internal/token/handler.gonew file mode 100644index 00000000..a248fa79--- /dev/null+++ b/PROJECTS/beginner/canary-token-generator/backend/internal/token/handler.go@@ -0,0 +1,323 @@+// ©AngelaMos | 2026+// handler.go++package token++import (+ "context"+ "encoding/base64"+ "encoding/json"+ "errors"+ "log/slog"+ "net/http"+ "strings"++ "github.com/go-chi/chi/v5"++ "github.com/CarterPerez-dev/cybersecurity-projects/canary-token-generator/backend/internal/event"+ "github.com/CarterPerez-dev/cybersecurity-projects/canary-token-generator/backend/internal/middleware"+)++const (+ urlParamTokenID = "id"++ headerContentType = "Content-Type"+ headerLocation = "Location"+ contentTypeJSON = "application/json"++ errorCodeValidation = "VALIDATION_ERROR"+ errorCodeBadJSON = "BAD_JSON"+ errorCodeInternalError = "INTERNAL_ERROR"+ errorCodeUnknownType = "UNKNOWN_TYPE"+ errorCodeGenerateFailed = "GENERATE_FAILED"++ respMessageValidation = "request validation failed"+ respMessageBadJSON = "invalid JSON body"+ respMessageInternalError = "internal server error"+ respMessageGenerateFailed = "artifact generation failed"+ respMessageUnknownType = "unknown token type"++ kubeconfigPathPrefix = "/k/"++ createTokenBodyMaxBytes = 64 * 1024+ fingerprintBodyMaxBytes = 64 * 1024+)++type EventRecorder interface {+ Record(ctx context.Context, t *Token, evt *event.Event) error+}++type FingerprintRecorder interface {+ AttachFingerprint(+ ctx context.Context,+ tokenID, sourceIP string,+ fingerprint json.RawMessage,+ ) error+}++type Handler struct {+ svc *Service+ events EventRecorder+ fingerprintRecorder FingerprintRecorder+ logger *slog.Logger+}++func NewHandler(+ svc *Service,+ events EventRecorder,+ fingerprint FingerprintRecorder,+ logger *slog.Logger,+) *Handler {+ if logger == nil {+ logger = slog.Default()+ }+ return &Handler{+ svc: svc,+ events: events,+ fingerprintRecorder: fingerprint,+ logger: logger,+ }+}++func (h *Handler) RegisterAPIRoutes(r chi.Router) {+ r.Get("/tokens/types", h.GetTypes)+ r.Post("/tokens", h.CreateToken)+}++func (h *Handler) RegisterTriggerRoutes(r chi.Router) {+ r.Get("/c/{"+urlParamTokenID+"}", h.HandleTrigger)+ r.Post("/c/{"+urlParamTokenID+"}/fingerprint", h.HandleFingerprint)+ r.HandleFunc("/k/{"+urlParamTokenID+"}", h.HandleTrigger)+ r.HandleFunc("/k/{"+urlParamTokenID+"}/*", h.HandleTrigger)+}++func (h *Handler) GetTypes(w http.ResponseWriter, _ *http.Request) {+ h.writeJSON(w, http.StatusOK, envelopeData(TypeDescriptors()))+}++func (h *Handler) CreateToken(w http.ResponseWriter, r *http.Request) {+ limited := http.MaxBytesReader(w, r.Body, createTokenBodyMaxBytes)+ var req CreateRequest+ if err := json.NewDecoder(limited).Decode(&req); err != nil {+ h.writeJSON(w, http.StatusBadRequest, envelopeError(+ errorCodeBadJSON, respMessageBadJSON,+ ))+ return+ }++ fp := middleware.ExtractFingerprint(r)+ ip := middleware.RealIP(r)++ tok, art, err := h.svc.Create(r.Context(), req, fp, ip)+ if err != nil {+ h.writeCreateError(w, r, err)+ return+ }++ resp := tok.ToResponse(+ h.svc.TriggerURL(tok.ID),+ h.svc.ManageURL(tok.ManageID),+ )+ h.writeJSON(w, http.StatusCreated, envelopeData(map[string]any{+ "token": resp,+ "artifact": artifactToJSON(art),+ }))+}++func (h *Handler) HandleTrigger(w http.ResponseWriter, r *http.Request) {+ id := chi.URLParam(r, urlParamTokenID)+ if id == "" {+ http.NotFound(w, r)+ return+ }++ tok, err := h.svc.GetByID(r.Context(), id)+ if err != nil {+ h.logger.WarnContext(r.Context(), "trigger lookup failed",+ "token_id", id, "error", err)+ }+ if tok != nil && !tok.Enabled {+ tok = nil+ }++ gen, ok := h.resolveGenerator(tok, r)+ if !ok {+ http.NotFound(w, r)+ return+ }++ evt, resp, gErr := gen.Trigger(r.Context(), tok, r)+ if gErr != nil {+ h.logger.WarnContext(r.Context(), "trigger generator failed",+ "error", gErr, "token_id", id)+ http.Error(w, respMessageInternalError, http.StatusInternalServerError)+ return+ }+ if resp == nil {+ http.NotFound(w, r)+ return+ }++ if tok != nil && evt != nil && h.events != nil {+ if recErr := h.events.Record(r.Context(), tok, evt); recErr != nil {+ h.logger.WarnContext(r.Context(), "record event failed",+ "error", recErr, "token_id", id)+ }+ }++ h.writeTriggerResponse(w, r, resp)+}++func (h *Handler) HandleFingerprint(w http.ResponseWriter, r *http.Request) {+ id := chi.URLParam(r, urlParamTokenID)+ if id == "" || h.fingerprintRecorder == nil {+ w.WriteHeader(http.StatusNoContent)+ return+ }++ limited := http.MaxBytesReader(w, r.Body, fingerprintBodyMaxBytes)+ var raw json.RawMessage+ if err := json.NewDecoder(limited).Decode(&raw); err != nil {+ w.WriteHeader(http.StatusNoContent)+ return+ }++ if recErr := h.fingerprintRecorder.AttachFingerprint(+ r.Context(),+ id,+ middleware.RealIP(r),+ raw,+ ); recErr != nil {+ h.logger.WarnContext(r.Context(), "attach fingerprint failed",+ "token_id", id, "error", recErr)+ }+ w.WriteHeader(http.StatusNoContent)+}++func (h *Handler) resolveGenerator(+ tok *Token,+ r *http.Request,+) (Generator, bool) {+ if tok != nil {+ return h.svc.Generator(tok.Type)+ }+ if strings.HasPrefix(r.URL.Path, kubeconfigPathPrefix) {+ return h.svc.Generator(TypeKubeconfig)+ }+ return h.svc.Generator(TypeWebbug)+}++func (h *Handler) writeCreateError(+ w http.ResponseWriter,+ r *http.Request,+ err error,+) {+ switch {+ case errors.Is(err, ErrUnknownGeneratorType):+ h.writeJSON(w, http.StatusBadRequest, envelopeError(+ errorCodeUnknownType, respMessageUnknownType,+ ))+ case errors.Is(err, ErrInvalidDestinationURL),+ errors.Is(err, ErrInvalidIncludeKeys):+ h.writeJSON(w, http.StatusBadRequest, envelopeError(+ errorCodeValidation, err.Error(),+ ))+ case errors.Is(err, ErrGenerateFailed):+ h.logger.ErrorContext(r.Context(), "create token: generator",+ "error", err)+ h.writeJSON(w, http.StatusInternalServerError, envelopeError(+ errorCodeGenerateFailed, respMessageGenerateFailed,+ ))+ case strings.Contains(err.Error(), "validate request"):+ h.writeJSON(w, http.StatusBadRequest, envelopeError(+ errorCodeValidation, respMessageValidation,+ ))+ default:+ h.logger.ErrorContext(r.Context(), "create token", "error", err)+ h.writeJSON(w, http.StatusInternalServerError, envelopeError(+ errorCodeInternalError, respMessageInternalError,+ ))+ }+}++func (h *Handler) writeJSON(+ w http.ResponseWriter,+ status int,+ body any,+) {+ w.Header().Set(headerContentType, contentTypeJSON)+ w.WriteHeader(status)+ if err := json.NewEncoder(w).Encode(body); err != nil {+ h.logger.Warn("write json response", "error", err)+ }+}++func (h *Handler) writeTriggerResponse(+ w http.ResponseWriter,+ r *http.Request,+ resp *TriggerResponse,+) {+ for k, v := range resp.ExtraHeaders {+ w.Header().Set(k, v)+ }+ if resp.ContentType != "" {+ w.Header().Set(headerContentType, resp.ContentType)+ }+ if resp.RedirectURL != "" {+ w.Header().Set(headerLocation, resp.RedirectURL)+ w.WriteHeader(resp.StatusCode)+ return+ }+ w.WriteHeader(resp.StatusCode)+ if len(resp.Body) > 0 {+ if _, err := w.Write(resp.Body); err != nil {+ h.logger.WarnContext(r.Context(), "write trigger body",+ "error", err)+ }+ }+}++func envelopeData(data any) map[string]any {+ return map[string]any{"success": true, "data": data}+}++func envelopeError(code, message string) map[string]any {+ return map[string]any{+ "success": false,+ "error": map[string]any{+ "code": code,+ "message": message,+ },+ }+}++type ArtifactJSON struct {+ Kind string `json:"kind"`+ URL string `json:"url,omitempty"`+ DestinationURL string `json:"destination_url,omitempty"`+ Filename string `json:"filename,omitempty"`+ ContentType string `json:"content_type,omitempty"`+ ContentB64 string `json:"content_b64,omitempty"`+ Content string `json:"content,omitempty"`+ ConnectionString string `json:"connection_string,omitempty"`+}++func artifactToJSON(a Artifact) ArtifactJSON {+ out := ArtifactJSON{Kind: string(a.Kind)}+ switch a.Kind {+ case KindURL:+ out.URL = a.URL+ out.DestinationURL = a.DestinationURL+ case KindFile:+ out.Filename = a.Filename+ out.ContentType = a.ContentType+ out.ContentB64 = base64.StdEncoding.EncodeToString(a.Content)+ case KindText:+ out.Filename = a.Filename+ out.ContentType = a.ContentType+ out.Content = string(a.Content)+ case KindConnectionString:+ out.ConnectionString = a.ConnectionString+ }+ return out+}diff --git a/PROJECTS/beginner/canary-token-generator/backend/internal/token/handler_test.go b/PROJECTS/beginner/canary-token-generator/backend/internal/token/handler_test.gonew file mode 100644index 00000000..3f6c3ab3--- /dev/null+++ b/PROJECTS/beginner/canary-token-generator/backend/internal/token/handler_test.go@@ -0,0 +1,371 @@+// ©AngelaMos | 2026+// handler_test.go++package token_test++import (+ "context"+ "encoding/json"+ "io"+ "log/slog"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"++ "github.com/go-chi/chi/v5"+ "github.com/stretchr/testify/require"++ "github.com/CarterPerez-dev/cybersecurity-projects/canary-token-generator/backend/internal/event"+ "github.com/CarterPerez-dev/cybersecurity-projects/canary-token-generator/backend/internal/token"+ "github.com/CarterPerez-dev/cybersecurity-projects/canary-token-generator/backend/internal/token/generators"+)++type triggerGen struct {+ tokenType token.Type+ artifact generators.Artifact+ resp *generators.TriggerResponse+ evt *event.Event+}++func (g *triggerGen) Type() token.Type { return g.tokenType }++func (g *triggerGen) Generate(+ _ context.Context,+ _ *token.Token,+ _ string,+) (generators.Artifact, error) {+ return g.artifact, nil+}++func (g *triggerGen) Trigger(+ _ context.Context,+ _ *token.Token,+ _ *http.Request,+) (*event.Event, *generators.TriggerResponse, error) {+ return g.evt, g.resp, nil+}++type recordingEvents struct {+ events []*event.Event+}++func (r *recordingEvents) Record(+ _ context.Context,+ _ *token.Token,+ e *event.Event,+) error {+ r.events = append(r.events, e)+ return nil+}++func quietHandlerLogger() *slog.Logger {+ return slog.New(slog.NewTextHandler(io.Discard, nil))+}++func newWebbugHandler(+ t *testing.T,+ gen token.Generator,+) (*token.Handler, *fakeRepo, *recordingEvents) {+ t.Helper()+ repo := newFakeRepo()+ rec := &recordingEvents{}+ svc := token.NewService(+ repo,+ token.MapRegistry{token.TypeWebbug: gen},+ token.ServiceConfig{+ BaseURL: "https://canary.example.com",+ ManageURL: "https://canary.example.com",+ },+ )+ return token.NewHandler(svc, rec, nil, quietHandlerLogger()), repo, rec+}++func TestGetTypes_Returns7Types(t *testing.T) {+ svc := token.NewService(newFakeRepo(), token.MapRegistry{},+ token.ServiceConfig{BaseURL: "https://x.test"})+ h := token.NewHandler(svc, nil, nil, quietHandlerLogger())++ r := chi.NewRouter()+ h.RegisterAPIRoutes(r)++ w := httptest.NewRecorder()+ r.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/tokens/types", nil))++ require.Equal(t, http.StatusOK, w.Code)+ var body struct {+ Success bool `json:"success"`+ Data []token.TypeDescriptor `json:"data"`+ }+ require.NoError(t, json.NewDecoder(w.Body).Decode(&body))+ require.True(t, body.Success)+ require.Len(t, body.Data, 7)+}++func TestCreateToken_HappyPath(t *testing.T) {+ gen := &triggerGen{+ tokenType: token.TypeWebbug,+ artifact: generators.Artifact{+ Kind: generators.KindURL, URL: "https://canary.example.com/c/x",+ },+ }+ h, _, _ := newWebbugHandler(t, gen)++ r := chi.NewRouter()+ h.RegisterAPIRoutes(r)++ body := strings.NewReader(`{+ "type":"webbug","memo":"m","alert_channel":"webhook",+ "webhook_url":"https://example.com/h","cf_turnstile_response":"t",+ "metadata":{}+ }`)+ req := httptest.NewRequest(http.MethodPost, "/tokens", body)+ req.Header.Set("Content-Type", "application/json")+ w := httptest.NewRecorder()+ r.ServeHTTP(w, req)++ require.Equal(t, http.StatusCreated, w.Code)++ var resp struct {+ Success bool `json:"success"`+ Data struct {+ Token token.Response `json:"token"`+ Artifact token.ArtifactJSON `json:"artifact"`+ } `json:"data"`+ }+ require.NoError(t, json.NewDecoder(w.Body).Decode(&resp))+ require.True(t, resp.Success)+ require.Equal(t, token.TypeWebbug, resp.Data.Token.Type)+ require.NotEmpty(t, resp.Data.Token.ID)+ require.Contains(t, resp.Data.Token.TriggerURL, "/c/")+ require.Contains(t, resp.Data.Token.ManageURL, "/m/")+ require.Equal(t, "url", resp.Data.Artifact.Kind)+}++func TestCreateToken_BadJSON(t *testing.T) {+ gen := &triggerGen{tokenType: token.TypeWebbug}+ h, _, _ := newWebbugHandler(t, gen)++ r := chi.NewRouter()+ h.RegisterAPIRoutes(r)++ req := httptest.NewRequest(+ http.MethodPost,+ "/tokens",+ strings.NewReader(`{not json`),+ )+ req.Header.Set("Content-Type", "application/json")+ w := httptest.NewRecorder()+ r.ServeHTTP(w, req)++ require.Equal(t, http.StatusBadRequest, w.Code)+ require.Contains(t, w.Body.String(), "BAD_JSON")+}++func TestCreateToken_ValidationFailure(t *testing.T) {+ gen := &triggerGen{tokenType: token.TypeWebbug}+ h, _, _ := newWebbugHandler(t, gen)++ r := chi.NewRouter()+ h.RegisterAPIRoutes(r)++ body := strings.NewReader(+ `{"type":"webbug","memo":"m","cf_turnstile_response":"t"}`,+ )+ req := httptest.NewRequest(http.MethodPost, "/tokens", body)+ w := httptest.NewRecorder()+ r.ServeHTTP(w, req)++ require.Equal(t, http.StatusBadRequest, w.Code)+ require.Contains(t, w.Body.String(), "VALIDATION_ERROR")+}++func TestHandleTrigger_KnownTokenReturnsResponseAndRecordsEvent(t *testing.T) {+ gen := &triggerGen{+ tokenType: token.TypeWebbug,+ artifact: generators.Artifact{Kind: generators.KindURL},+ resp: &generators.TriggerResponse{+ StatusCode: 200,+ ContentType: "image/gif",+ Body: []byte{0x47, 0x49, 0x46, 0x38},+ },+ evt: &event.Event{SourceIP: "1.2.3.4"},+ }+ h, repo, rec := newWebbugHandler(t, gen)++ tok := &token.Token{+ ID: "abcdef012345", ManageID: "m", Type: token.TypeWebbug,+ AlertChannel: token.ChannelWebhook, Enabled: true,+ Metadata: json.RawMessage(`{}`),+ }+ require.NoError(t, repo.Insert(context.Background(), tok))++ r := chi.NewRouter()+ h.RegisterTriggerRoutes(r)++ w := httptest.NewRecorder()+ req := httptest.NewRequest(http.MethodGet, "/c/abcdef012345", nil)+ r.ServeHTTP(w, req)++ require.Equal(t, http.StatusOK, w.Code)+ require.Equal(t, "image/gif", w.Header().Get("Content-Type"))+ require.Equal(t, []byte{0x47, 0x49, 0x46, 0x38}, w.Body.Bytes())+ require.Len(t, rec.events, 1)+}++func TestHandleTrigger_UnknownTokenStillReturnsArtifactShape(t *testing.T) {+ gen := &triggerGen{+ tokenType: token.TypeWebbug,+ resp: &generators.TriggerResponse{+ StatusCode: 200,+ ContentType: "image/gif",+ Body: []byte{0x47, 0x49, 0x46},+ },+ }+ h, _, rec := newWebbugHandler(t, gen)++ r := chi.NewRouter()+ h.RegisterTriggerRoutes(r)++ w := httptest.NewRecorder()+ r.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/c/nonexistent1", nil))++ require.Equal(t, http.StatusOK, w.Code,+ "unknown tokens still return artifact shape (defense in depth)")+ require.Empty(t, rec.events, "no event recorded for unknown token")+}++func TestHandleTrigger_DisabledTokenIsTreatedAsUnknown(t *testing.T) {+ gen := &triggerGen{+ tokenType: token.TypeWebbug,+ resp: &generators.TriggerResponse{+ StatusCode: 200,+ ContentType: "image/gif",+ Body: []byte{0x47},+ },+ evt: &event.Event{SourceIP: "1.2.3.4"},+ }+ h, repo, rec := newWebbugHandler(t, gen)++ tok := &token.Token{+ ID: "disabled1234", ManageID: "m", Type: token.TypeWebbug,+ AlertChannel: token.ChannelWebhook, Enabled: false,+ Metadata: json.RawMessage(`{}`),+ }+ require.NoError(t, repo.Insert(context.Background(), tok))++ r := chi.NewRouter()+ h.RegisterTriggerRoutes(r)++ w := httptest.NewRecorder()+ r.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/c/disabled1234", nil))++ require.Equal(t, http.StatusOK, w.Code)+ require.Empty(t, rec.events, "disabled token must not record events")+}++func TestHandleFingerprint_Returns204WithNoRecorder(t *testing.T) {+ gen := &triggerGen{tokenType: token.TypeWebbug}+ h, _, _ := newWebbugHandler(t, gen)++ r := chi.NewRouter()+ h.RegisterTriggerRoutes(r)++ w := httptest.NewRecorder()+ r.ServeHTTP(w, httptest.NewRequest(http.MethodPost,+ "/c/anything/fingerprint", strings.NewReader(`{"x":1}`)))++ require.Equal(t, http.StatusNoContent, w.Code)+}++func TestArtifactToJSON_Kinds(t *testing.T) {+ cases := []struct {+ name string+ in generators.Artifact+ want token.ArtifactJSON+ }{+ {+ "url",+ generators.Artifact{+ Kind: generators.KindURL,+ URL: "u",+ DestinationURL: "d",+ },+ token.ArtifactJSON{Kind: "url", URL: "u", DestinationURL: "d"},+ },+ {+ "file",+ generators.Artifact{+ Kind: generators.KindFile,+ Filename: "f.docx",+ ContentType: "x",+ Content: []byte("hi"),+ },+ token.ArtifactJSON{+ Kind: "file",+ Filename: "f.docx",+ ContentType: "x",+ ContentB64: "aGk=",+ },+ },+ {+ "text",+ generators.Artifact{+ Kind: generators.KindText,+ Filename: ".env",+ ContentType: "text/plain",+ Content: []byte("KEY=v"),+ },+ token.ArtifactJSON{+ Kind: "text",+ Filename: ".env",+ ContentType: "text/plain",+ Content: "KEY=v",+ },+ },+ {+ "conn",+ generators.Artifact{+ Kind: generators.KindConnectionString,+ ConnectionString: "mysql://x",+ },+ token.ArtifactJSON{+ Kind: "connection_string",+ ConnectionString: "mysql://x",+ },+ },+ }+ for _, c := range cases {+ c := c+ t.Run(c.name, func(t *testing.T) {+ require.Equal(t, c.want, exposeArtifactToJSON(c.in))+ })+ }+}++func exposeArtifactToJSON(a generators.Artifact) token.ArtifactJSON {+ gen := &triggerGen{tokenType: token.TypeWebbug, artifact: a}+ repo := newFakeRepo()+ svc := token.NewService(repo, token.MapRegistry{token.TypeWebbug: gen},+ token.ServiceConfig{BaseURL: "https://x"})+ h := token.NewHandler(svc, nil, nil, quietHandlerLogger())++ r := chi.NewRouter()+ h.RegisterAPIRoutes(r)++ body := strings.NewReader(+ `{"type":"webbug","alert_channel":"webhook","webhook_url":"https://x/h","cf_turnstile_response":"t","metadata":{}}`,+ )+ w := httptest.NewRecorder()+ r.ServeHTTP(w, httptest.NewRequest(http.MethodPost, "/tokens", body))++ var resp struct {+ Data struct {+ Artifact token.ArtifactJSON `json:"artifact"`+ } `json:"data"`+ }+ if jsonErr := json.NewDecoder(w.Body).Decode(&resp); jsonErr != nil {+ panic(jsonErr)+ }+ return resp.Data.Artifact+}diff --git a/PROJECTS/beginner/canary-token-generator/backend/internal/token/types.go b/PROJECTS/beginner/canary-token-generator/backend/internal/token/types.gonew file mode 100644index 00000000..55d09bd5--- /dev/null+++ b/PROJECTS/beginner/canary-token-generator/backend/internal/token/types.go@@ -0,0 +1,58 @@+// ©AngelaMos | 2026+// types.go++package token++type TypeDescriptor struct {+ Type Type `json:"type"`+ Name string `json:"name"`+ Description string `json:"description"`+ ArtifactKind string `json:"artifact_kind"`+}++func TypeDescriptors() []TypeDescriptor {+ return []TypeDescriptor{+ {+ Type: TypeWebbug,+ Name: "Web Bug Pixel",+ Description: "1x1 transparent GIF that fires when fetched. Embed in HTML emails or web pages.",+ ArtifactKind: string(KindURL),+ },+ {+ Type: TypeSlowRedirect,+ Name: "Slow Redirect",+ Description: "Browser-fingerprinting page that redirects to a destination URL after collecting client metadata.",+ ArtifactKind: string(KindURL),+ },+ {+ Type: TypeDocx,+ Name: "Microsoft Word Document",+ Description: "DOCX with an embedded INCLUDEPICTURE field that calls home when the document opens.",+ ArtifactKind: string(KindFile),+ },+ {+ Type: TypePDF,+ Name: "PDF Document",+ Description: "PDF with an /AA open-action URI that fires in Adobe Acrobat Reader.",+ ArtifactKind: string(KindFile),+ },+ {+ Type: TypeKubeconfig,+ Name: "Kubernetes Config",+ Description: "kubeconfig pointing kubectl at a fake K8s API server that records every request.",+ ArtifactKind: string(KindText),+ },+ {+ Type: TypeEnvfile,+ Name: ".env File",+ Description: "Plausible production .env with shuffled bait credentials and an embedded canary URL.",+ ArtifactKind: string(KindText),+ },+ {+ Type: TypeMySQL,+ Name: "MySQL Connection String",+ Description: "Fake MySQL endpoint that records any authentication attempt.",+ ArtifactKind: string(KindConnectionString),+ },+ }+}