diff --git a/internal/commands/telemetry.go b/internal/commands/telemetry.go index b858454a..19e1386b 100644 --- a/internal/commands/telemetry.go +++ b/internal/commands/telemetry.go @@ -1,11 +1,14 @@ package commands import ( + "strings" + "github.com/MakeNowJust/heredoc" "github.com/checkmarx/ast-cli/internal/params" "github.com/checkmarx/ast-cli/internal/wrappers" "github.com/pkg/errors" "github.com/spf13/cobra" + "github.com/spf13/viper" ) func NewTelemetryCommand(telemetryWrapper wrappers.TelemetryWrapper) *cobra.Command { @@ -27,7 +30,7 @@ func telemetryAISubCommand(telemetryAIWrapper wrappers.TelemetryWrapper) *cobra. Long: "Collects telemetry data for user interactions related to AI features.", Example: heredoc.Doc( ` - $ cx telemetry ai --ai-provider --problem-severity --type --sub-type --agent --engine + $ cx telemetry ai --ai-provider --problem-severity --type --sub-type --agent --engine --event-attributes "apiVersion=v2;vulnerabilityId=CVE-2021-44228;remediationMode=DevAssist" `, ), @@ -42,11 +45,47 @@ func telemetryAISubCommand(telemetryAIWrapper wrappers.TelemetryWrapper) *cobra. telemetryAICmd.PersistentFlags().String(params.AgentFlag, "", "Agent") telemetryAICmd.PersistentFlags().String(params.ScanTypeFlag, "", "Scan Type") telemetryAICmd.PersistentFlags().String(params.StatusFlag, "", "Status") + telemetryAICmd.PersistentFlags().String(params.StatusResultFlag, "", "Status Result") telemetryAICmd.PersistentFlags().Int(params.TotalCountFlag, 0, "Total Count") + telemetryAICmd.PersistentFlags().String(params.AgentVersionFlag, "", "Agent Version") + telemetryAICmd.PersistentFlags().String(params.CxPluginVersionFlag, "", "CX Plugin Version") + telemetryAICmd.PersistentFlags().String(params.PluginTypeFlag, "", "Plugin Type") + telemetryAICmd.PersistentFlags().String(params.RepoURLFlag, "", "Repository URL") + telemetryAICmd.PersistentFlags().String(params.EventAttributesFlag, "", "Event Attributes in key=value;key=value format (e.g., apiVersion=v2;vulnerabilityId=CVE-2021-44228;remediationMode=DevAssist)") + telemetryAICmd.PersistentFlags().String(params.ApiVersionFlag, "", "API Version") return telemetryAICmd } +func parseEventAttributes(eventAttributesStr string) *wrappers.EventAttributes { + if eventAttributesStr == "" { + return nil + } + + attrs := make(wrappers.EventAttributes) + pairs := strings.Split(eventAttributesStr, ";") + + for _, pair := range pairs { + kv := strings.SplitN(pair, "=", 2) + if len(kv) != 2 { + continue + } + + key := strings.TrimSpace(kv[0]) + value := strings.TrimSpace(kv[1]) + + if key != "" { + attrs[key] = value + } + } + + if len(attrs) == 0 { + return nil + } + + return &attrs +} + func runTelemetryAI(telemetryWrapper wrappers.TelemetryWrapper) func(*cobra.Command, []string) error { return func(cmd *cobra.Command, _ []string) error { aiProvider, _ := cmd.Flags().GetString("ai-provider") @@ -57,19 +96,47 @@ func runTelemetryAI(telemetryWrapper wrappers.TelemetryWrapper) func(*cobra.Comm engine, _ := cmd.Flags().GetString("engine") scanType, _ := cmd.Flags().GetString("scan-type") status, _ := cmd.Flags().GetString("status") - totalCount, _ := cmd.Flags().GetInt("total-count") + totalCount, _ := cmd.Flags().GetInt(params.TotalCountFlag) + statusResult, _ := cmd.Flags().GetString(params.StatusResultFlag) + agentVersion, _ := cmd.Flags().GetString(params.AgentVersionFlag) + cxPluginVersion, _ := cmd.Flags().GetString(params.CxPluginVersionFlag) + pluginType, _ := cmd.Flags().GetString(params.PluginTypeFlag) + repoURL, _ := cmd.Flags().GetString(params.RepoURLFlag) + eventAttributesStr, _ := cmd.Flags().GetString(params.EventAttributesFlag) + apiVersion, _ := cmd.Flags().GetString(params.ApiVersionFlag) + uniqueID := wrappers.GetUniqueID() + machineUniqueId := wrappers.GetMachineID() + + var sessionID string + if eventType == "authentication" && status == "success" { + sessionID = wrappers.GetSessionID() + } else { + sessionID = viper.GetString(params.SessionIDConfigKey) + } + + eventAttrs := parseEventAttributes(eventAttributesStr) + err := telemetryWrapper.SendAIDataToLog(&wrappers.DataForAITelemetry{ AIProvider: aiProvider, ProblemSeverity: problemSeverity, Type: eventType, SubType: subType, Agent: agent, + AgentVersion: agentVersion, + CxPluginVersion: cxPluginVersion, + PluginType: pluginType, Engine: engine, ScanType: scanType, Status: status, + StatusResult: statusResult, + APIVersion: apiVersion, TotalCount: totalCount, + RepoURL: repoURL, UniqueID: uniqueID, + SessionID: sessionID, + MachineUniqueId: machineUniqueId, + EventAttributes: eventAttrs, }) if err != nil { diff --git a/internal/params/envs.go b/internal/params/envs.go index 42982dd7..75b25671 100644 --- a/internal/params/envs.go +++ b/internal/params/envs.go @@ -86,6 +86,7 @@ const ( ConfigFilePathEnv = "CX_CONFIG_FILE_PATH" RealtimeScannerPathEnv = "CX_REALTIME_SCANNER_PATH" UniqueIDEnv = "CX_UNIQUE_ID" + SessionIDEnv = "CX_SESSION_ID" StartMultiPartUploadPathEnv = "CX_START_MULTIPART_UPLOAD_PATH" MultipartPresignedPathEnv = "CX_MULTIPART_PRESIGNED_URL_PATH" CompleteMultipartUploadPathEnv = "CX_COMPLETE_MULTIPART_UPLOAD_PATH" diff --git a/internal/params/flags.go b/internal/params/flags.go index 5b322ff3..1d462641 100644 --- a/internal/params/flags.go +++ b/internal/params/flags.go @@ -16,8 +16,15 @@ const ( SubTypeFlag = "sub-type" EngineFlag = "engine" StatusFlag = "status" + StatusResultFlag = "status-result" scanTypeFlag = "scan-type" TotalCountFlag = "total-count" + AgentVersionFlag = "agent-version" + CxPluginVersionFlag = "cx-plugin-version" + PluginTypeFlag = "plugin-type" + RepoURLFlag = "repo-url" + EventAttributesFlag = "event-attributes" + ApiVersionFlag = "api-version" OriginFlag = "origin" AgentFlagUsage = "Scan origin name" ApplicationName = "application-name" @@ -167,7 +174,6 @@ const ( URLFlagUsage = "API base URL" QueryIDFlag = "query-id" SSHKeyFlag = "ssh-key" - RepoURLFlag = "repo-url" SSHValue = "ssh-value" KicsContainerNameKey = "kics-container-name" KicsPlatformsFlag = "kics-platforms" diff --git a/internal/params/keys.go b/internal/params/keys.go index 480ee49d..10424f67 100644 --- a/internal/params/keys.go +++ b/internal/params/keys.go @@ -84,6 +84,7 @@ var ( ConfigFilePathKey = strings.ToLower(ConfigFilePathEnv) RealtimeScannerPathKey = strings.ToLower(RealtimeScannerPathEnv) UniqueIDConfigKey = strings.ToLower(UniqueIDEnv) + SessionIDConfigKey = strings.ToLower(SessionIDEnv) StartMultiPartUploadPathKey = strings.ToLower(StartMultiPartUploadPathEnv) MultipartPresignedPathKey = strings.ToLower(MultipartPresignedPathEnv) CompleteMultiPartUploadPathKey = strings.ToLower(CompleteMultipartUploadPathEnv) diff --git a/internal/wrappers/jwt-helper.go b/internal/wrappers/jwt-helper.go index 566a8830..b20c8a56 100644 --- a/internal/wrappers/jwt-helper.go +++ b/internal/wrappers/jwt-helper.go @@ -1,7 +1,11 @@ package wrappers import ( + "bytes" + "os" + "os/exec" "os/user" + "runtime" "strconv" "strings" @@ -222,10 +226,14 @@ func GetUniqueID() string { // Check if unique id is already set uniqueID = viper.GetString(commonParams.UniqueIDConfigKey) - if uniqueID != "" { + if uniqueID != "" && isValidUniqueIDFormat(uniqueID) { return uniqueID } + if uniqueID != "" { + logger.PrintIfVerbose("Existing unique ID invalid format, regenerating") + } + // Generate new unique id currentUser, err := user.Current() if err != nil { @@ -247,3 +255,104 @@ func GetUniqueID() string { } return uniqueID } + +func isValidUniqueIDFormat(uniqueID string) bool { + parts := strings.Split(uniqueID, "_") + if len(parts) != 2 { + return false + } + + guid := parts[0] + storedUsername := parts[1] + + if len(guid) != 36 { + return false + } + + if _, err := uuid.Parse(guid); err != nil { + return false + } + + if storedUsername == "" { + return false + } + + currentUser, err := user.Current() + if err != nil { + return false + } + currentUsername := currentUser.Username + currentUsername = strings.TrimSpace(currentUsername) + if strings.Contains(currentUsername, "\\") { + currentUsername = strings.Split(currentUsername, "\\")[1] + } + + if storedUsername != currentUsername { + return false + } + + return true +} + +func GetSessionID() string { + sessionID := uuid.New().String() + viper.Set(commonParams.SessionIDConfigKey, sessionID) + configFilePath, err := configuration.GetConfigFilePath() + if err != nil { + logger.PrintIfVerbose("Failed to get config file path: " + err.Error()) + return sessionID + } + + err = configuration.SafeWriteSingleConfigKeyString(configFilePath, commonParams.SessionIDConfigKey, sessionID) + if err != nil { + logger.PrintIfVerbose("Failed to write session ID config: " + err.Error()) + } + return sessionID +} + +func GetMachineID() string { + switch runtime.GOOS { + case "windows": + return getWindowsMachineID() + case "darwin": + return getMacOSMachineID() + case "linux": + return getLinuxMachineID() + default: + return "" + } +} + + +func getMacOSMachineID() string { + buf := &bytes.Buffer{} + cmd := exec.Command("ioreg", "-rd1", "-c", "IOPlatformExpertDevice") + cmd.Stdout = buf + err := cmd.Run() + if err != nil { + logger.PrintIfVerbose("Failed to run ioreg: " + err.Error()) + return "" + } + for _, line := range strings.Split(buf.String(), "\n") { + if strings.Contains(line, "IOPlatformUUID") { + parts := strings.SplitAfter(line, `" = "`) + if len(parts) == 2 { + machineID := strings.TrimRight(parts[1], `"`) + return strings.TrimSpace(machineID) + } + } + } + return "" +} + +func getLinuxMachineID() string { + machineID, err := os.ReadFile("/var/lib/dbus/machine-id") + if err == nil { + return strings.TrimSpace(string(machineID)) + } + machineID, err = os.ReadFile("/etc/machine-id") + if err == nil { + return strings.TrimSpace(string(machineID)) + } + return "" +} diff --git a/internal/wrappers/jwt-helper_test.go b/internal/wrappers/jwt-helper_test.go index 9356921e..5750f787 100644 --- a/internal/wrappers/jwt-helper_test.go +++ b/internal/wrappers/jwt-helper_test.go @@ -116,6 +116,82 @@ func TestGetUniqueID(t *testing.T) { }) } +func TestIsValidUniqueIDFormat(t *testing.T) { + tests := []struct { + name string + uniqueID string + valid bool + }{ + { + name: "valid format with UUID and username", + uniqueID: "550e8400-e29b-41d4-a716-446655440000_testuser", + valid: true, + }, + { + name: "invalid - no underscore", + uniqueID: "550e8400-e29b-41d4-a716-446655440000testuser", + valid: false, + }, + { + name: "invalid - empty username", + uniqueID: "550e8400-e29b-41d4-a716-446655440000_", + valid: false, + }, + { + name: "invalid - malformed UUID", + uniqueID: "550e8400-e29b-41d4-invalid-446655440000_testuser", + valid: false, + }, + { + name: "invalid - multiple underscores", + uniqueID: "550e8400-e29b-41d4-a716-446655440000_test_user", + valid: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := isValidUniqueIDFormat(tt.uniqueID) + assert.Equal(t, tt.valid, result, "validation result should match expected") + }) + } +} + +func TestGetSessionID(t *testing.T) { + // Save original value and restore after test + originalID := viper.GetString(commonParams.SessionIDConfigKey) + defer viper.Set(commonParams.SessionIDConfigKey, originalID) + + t.Run("generates new session ID when none exists", func(t *testing.T) { + viper.Set(commonParams.SessionIDConfigKey, "") + + result := GetSessionID() + + assert.Assert(t, result != "", "Should generate new session ID") + assert.Assert(t, len(result) == 36, "Should be valid UUID format (36 chars)") + assert.Assert(t, strings.Count(result, "-") == 4, "Should have 4 dashes in UUID") + }) + + t.Run("returns existing valid session ID from config", func(t *testing.T) { + validID := "550e8400-e29b-41d4-a716-446655440000" + viper.Set(commonParams.SessionIDConfigKey, validID) + + result := GetSessionID() + + assert.Equal(t, validID, result, "Should return existing valid session ID") + }) + + t.Run("regenerates invalid session ID", func(t *testing.T) { + invalidID := "550e8400-e29b-41d4-invalid-446655440000" + viper.Set(commonParams.SessionIDConfigKey, invalidID) + + result := GetSessionID() + + assert.Assert(t, result != invalidID, "Should regenerate when ID is invalid") + assert.Assert(t, len(result) == 36, "Should generate valid UUID format") + }) +} + func TestBuildLicenseDetailsFromJWT(t *testing.T) { tests := []struct { name string @@ -203,3 +279,56 @@ func TestBuildLicenseDetailsFromJWT(t *testing.T) { }) } } +func TestGetMachineID(t *testing.T) { + t.Run("returns non-empty machine ID", func(t *testing.T) { + result := GetMachineID() + + // GetMachineID may return empty on unsupported platforms, but should not crash + if result != "" { + assert.Assert(t, len(result) > 0, "Should return a machine ID") + } + }) +} + +func TestGetWindowsMachineID(t *testing.T) { + t.Run("registry key access", func(t *testing.T) { + // Basic test - verify function exists and can be called + // Actual registry access only works on Windows + result := getWindowsMachineID() + + // Should return string (empty if not on Windows or registry unavailable) + assert.Assert(t, result == "" || len(result) > 0, "Should return valid string") + }) +} + +func TestGetMacOSMachineID(t *testing.T) { + t.Run("ioreg command execution", func(t *testing.T) { + // Basic test - verify function exists and can be called + // Actual ioreg execution only works on macOS + result := getMacOSMachineID() + + // Should return string (empty if not on macOS or ioreg unavailable) + assert.Assert(t, result == "" || len(result) > 0, "Should return valid string") + }) +} + +func TestGetLinuxMachineID(t *testing.T) { + t.Run("file read from standard Linux paths", func(t *testing.T) { + // Basic test - verify function exists and can be called + // Actual file reads only work on Linux with proper permissions + result := getLinuxMachineID() + + // Should return string (empty if not on Linux or files unavailable) + assert.Assert(t, result == "" || len(result) > 0, "Should return valid string") + }) + + t.Run("prioritizes /var/lib/dbus/machine-id over /etc/machine-id", func(t *testing.T) { + // This test verifies the order is correct per third-party library logic + // On actual Linux systems, both paths usually contain the same ID + result1 := getLinuxMachineID() + result2 := getLinuxMachineID() + + // Results should be consistent between calls + assert.Equal(t, result1, result2, "Should return consistent machine ID") + }) +} diff --git a/internal/wrappers/machineID_unix.go b/internal/wrappers/machineID_unix.go new file mode 100644 index 00000000..3f08e10e --- /dev/null +++ b/internal/wrappers/machineID_unix.go @@ -0,0 +1,8 @@ +//go:build !windows +// +build !windows + +package wrappers + +func getWindowsMachineID() string { + return "" +} diff --git a/internal/wrappers/machineID_windows.go b/internal/wrappers/machineID_windows.go new file mode 100644 index 00000000..b81f59d5 --- /dev/null +++ b/internal/wrappers/machineID_windows.go @@ -0,0 +1,25 @@ +//go:build windows +// +build windows + +package wrappers + +import ( + "github.com/checkmarx/ast-cli/internal/logger" + "golang.org/x/sys/windows/registry" +) + +func getWindowsMachineID() string { + k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Cryptography`, registry.QUERY_VALUE|registry.WOW64_64KEY) + if err != nil { + logger.PrintIfVerbose("Failed to open registry key: " + err.Error()) + return "" + } + defer k.Close() + + machineID, _, err := k.GetStringValue("MachineGuid") + if err != nil { + logger.PrintIfVerbose("Failed to read MachineGuid from registry: " + err.Error()) + return "" + } + return machineID +} diff --git a/internal/wrappers/telemetry.go b/internal/wrappers/telemetry.go index 39ec639b..ef1a485a 100644 --- a/internal/wrappers/telemetry.go +++ b/internal/wrappers/telemetry.go @@ -1,17 +1,28 @@ package wrappers +type EventAttributes map[string]string + type DataForAITelemetry struct { - AIProvider string `json:"aiProvider"` - ProblemSeverity string `json:"problemSeverity"` - Type string `json:"type"` - SubType string `json:"subType"` - Agent string `json:"agent"` - Engine string `json:"engine"` - ScanType string `json:"scanType"` - Status string `json:"status"` - TotalCount int `json:"totalCount"` - UniqueID string `json:"uniqueId"` - AiAgentSessionId string `json:"aiAgentSessionId,omitempty"` + AIProvider string `json:"aiProvider"` + ProblemSeverity string `json:"problemSeverity"` + Type string `json:"type"` + SubType string `json:"subType"` + Agent string `json:"agent"` + AgentVersion string `json:"agentVersion"` + CxPluginVersion string `json:"cxPluginVersion"` + PluginType string `json:"pluginType"` + Engine string `json:"engine"` + ScanType string `json:"scanType"` + Status string `json:"status"` + StatusResult string `json:"statusResult"` + APIVersion string `json:"apiVersion,omitempty"` + TotalCount int `json:"totalCount"` + RepoURL string `json:"repoUrl"` + UniqueID string `json:"uniqueId"` + SessionID string `json:"sessionId"` + MachineUniqueId string `json:"machineUniqueId"` + EventAttributes *EventAttributes `json:"eventAttributes"` + AiAgentSessionId string `json:"aiAgentSessionId"` } type TelemetryWrapper interface {