diff --git a/internal/commands/asca/asca-engine.go b/internal/commands/asca/asca-engine.go index cad19fd74..3781cc759 100644 --- a/internal/commands/asca/asca-engine.go +++ b/internal/commands/asca/asca-engine.go @@ -6,6 +6,7 @@ import ( "github.com/checkmarx/ast-cli/internal/commands/util/printer" commonParams "github.com/checkmarx/ast-cli/internal/params" "github.com/checkmarx/ast-cli/internal/services" + "github.com/checkmarx/ast-cli/internal/services/realtimeengine" "github.com/checkmarx/ast-cli/internal/wrappers" "github.com/checkmarx/ast-cli/internal/wrappers/grpcs" "github.com/checkmarx/ast-cli/internal/wrappers/utils" @@ -30,6 +31,12 @@ func RunScanASCACommand(jwtWrapper wrappers.JWTWrapper) func(cmd *cobra.Command, return err } + severityFilterFlag, _ := cmd.Flags().GetString(commonParams.SeverityFilterFlag) + severityFilter, err := realtimeengine.ParseSeverityFilter(severityFilterFlag) + if err != nil { + return err + } + vorpal := strings.TrimSpace(viper.GetString(commonParams.ASCALocationKey)) if vorpal != "" { vorpalLocation = vorpal @@ -55,6 +62,9 @@ func RunScanASCACommand(jwtWrapper wrappers.JWTWrapper) func(cmd *cobra.Command, if err != nil { return err } + if scanResult != nil && scanResult.Error == nil { + scanResult.ScanDetails = services.FilterScanDetailsBySeverity(scanResult.ScanDetails, severityFilter) + } err = printer.Print(cmd.OutOrStdout(), scanResult, printer.FormatJSON) if err != nil { return err diff --git a/internal/commands/asca/severity-filter_test.go b/internal/commands/asca/severity-filter_test.go new file mode 100644 index 000000000..2b4a47d29 --- /dev/null +++ b/internal/commands/asca/severity-filter_test.go @@ -0,0 +1,43 @@ +package asca + +import ( + "strings" + "testing" + + "github.com/checkmarx/ast-cli/internal/commands/util/printer" + commonParams "github.com/checkmarx/ast-cli/internal/params" + "github.com/checkmarx/ast-cli/internal/wrappers/mock" + "github.com/spf13/cobra" +) + +func TestRunScanASCACommand_InvalidSeverityFilter_FailsBeforeScan(t *testing.T) { + cmd := &cobra.Command{} + cmd.Flags().String(commonParams.SourcesFlag, "data/python-vul-file.py", "") + cmd.Flags().Bool(commonParams.ASCALatestVersion, false, "") + cmd.Flags().String(commonParams.FormatFlag, printer.FormatJSON, "") + cmd.Flags().String(commonParams.SeverityFilterFlag, "critical,hgh", "") + + err := RunScanASCACommand(&mock.JWTMockWrapper{})(cmd, []string{}) + if err == nil { + t.Fatal("expected an error for an invalid severity-filter value") + } + if !strings.Contains(err.Error(), "invalid severity-filter value(s): hgh") { + t.Fatalf("unexpected error message: %v", err) + } + if !strings.Contains(err.Error(), "critical, high, medium, low, info") { + t.Fatalf("error should list accepted values: %v", err) + } +} + +func TestRunScanASCACommand_EmptySeverityFilter_TreatedAsNoFilter(t *testing.T) { + cmd := &cobra.Command{} + cmd.Flags().String(commonParams.SourcesFlag, "", "") + cmd.Flags().Bool(commonParams.ASCALatestVersion, false, "") + cmd.Flags().String(commonParams.FormatFlag, printer.FormatJSON, "") + cmd.Flags().String(commonParams.SeverityFilterFlag, " ", "") + + err := RunScanASCACommand(&mock.JWTMockWrapper{})(cmd, []string{}) + if err != nil { + t.Fatalf("whitespace-only severity-filter must not error, got: %v", err) + } +} diff --git a/internal/commands/containers-realtime-engine.go b/internal/commands/containers-realtime-engine.go index dddce085b..5310e5ea7 100644 --- a/internal/commands/containers-realtime-engine.go +++ b/internal/commands/containers-realtime-engine.go @@ -4,6 +4,7 @@ import ( "github.com/checkmarx/ast-cli/internal/commands/util/printer" errorconstants "github.com/checkmarx/ast-cli/internal/constants/errors" commonParams "github.com/checkmarx/ast-cli/internal/params" + "github.com/checkmarx/ast-cli/internal/services/realtimeengine" "github.com/checkmarx/ast-cli/internal/services/realtimeengine/containersrealtime" "github.com/checkmarx/ast-cli/internal/wrappers" "github.com/spf13/cobra" @@ -22,6 +23,12 @@ func RunScanContainersRealtimeCommand( ignoredFilePathFlag, _ := cmd.Flags().GetString(commonParams.IgnoredFilePathFlag) + severityFilterFlag, _ := cmd.Flags().GetString(commonParams.SeverityFilterFlag) + severityFilter, err := realtimeengine.ParseSeverityFilter(severityFilterFlag) + if err != nil { + return err + } + containersRealtimeService := containersrealtime.NewContainersRealtimeService(jwtWrapper, featureFlagWrapper, realtimeScannerWrapper) images, err := containersRealtimeService.RunContainersRealtimeScan(fileSourceFlag, ignoredFilePathFlag) @@ -29,6 +36,8 @@ func RunScanContainersRealtimeCommand( return err } + images.Images = containersrealtime.FilterImagesBySeverity(images.Images, severityFilter) + err = printer.Print(cmd.OutOrStdout(), images, printer.FormatJSON) if err != nil { return errorconstants.NewRealtimeEngineError("failed to return images").Error() diff --git a/internal/commands/iac-realtime-engine.go b/internal/commands/iac-realtime-engine.go index cf253471e..9a28d85f2 100644 --- a/internal/commands/iac-realtime-engine.go +++ b/internal/commands/iac-realtime-engine.go @@ -4,6 +4,7 @@ import ( "github.com/checkmarx/ast-cli/internal/commands/util/printer" errorconstants "github.com/checkmarx/ast-cli/internal/constants/errors" commonParams "github.com/checkmarx/ast-cli/internal/params" + "github.com/checkmarx/ast-cli/internal/services/realtimeengine" "github.com/checkmarx/ast-cli/internal/services/realtimeengine/iacrealtime" "github.com/checkmarx/ast-cli/internal/wrappers" "github.com/spf13/cobra" @@ -22,6 +23,12 @@ func RunScanIacRealtimeCommand( ignoredFilePathFlag, _ := cmd.Flags().GetString(commonParams.IgnoredFilePathFlag) engine, _ := cmd.Flags().GetString(commonParams.EngineFlag) + severityFilterFlag, _ := cmd.Flags().GetString(commonParams.SeverityFilterFlag) + severityFilter, err := realtimeengine.ParseSeverityFilter(severityFilterFlag) + if err != nil { + return err + } + iacRealtimeService := iacrealtime.NewIacRealtimeService(jwtWrapper, featureFlagWrapper, iacrealtime.NewContainerManager()) results, err := iacRealtimeService.RunIacRealtimeScan(fileSourceFlag, engine, ignoredFilePathFlag) @@ -29,6 +36,8 @@ func RunScanIacRealtimeCommand( return err } + results = iacrealtime.FilterResultsBySeverity(results, severityFilter) + err = printer.Print(cmd.OutOrStdout(), results, printer.FormatJSON) if err != nil { return errorconstants.NewRealtimeEngineError("failed to return IaC Realtime vulnerabilities").Error() diff --git a/internal/commands/oss-realtime-engine.go b/internal/commands/oss-realtime-engine.go index 31d49d9e7..e4f4e80ea 100644 --- a/internal/commands/oss-realtime-engine.go +++ b/internal/commands/oss-realtime-engine.go @@ -4,6 +4,7 @@ import ( "github.com/checkmarx/ast-cli/internal/commands/util/printer" errorconstants "github.com/checkmarx/ast-cli/internal/constants/errors" commonParams "github.com/checkmarx/ast-cli/internal/params" + "github.com/checkmarx/ast-cli/internal/services/realtimeengine" "github.com/checkmarx/ast-cli/internal/services/realtimeengine/ossrealtime" "github.com/checkmarx/ast-cli/internal/wrappers" "github.com/spf13/cobra" @@ -22,6 +23,12 @@ func RunScanOssRealtimeCommand( ignoredFilePathFlag, _ := cmd.Flags().GetString(commonParams.IgnoredFilePathFlag) + severityFilterFlag, _ := cmd.Flags().GetString(commonParams.SeverityFilterFlag) + severityFilter, err := realtimeengine.ParseSeverityFilter(severityFilterFlag) + if err != nil { + return err + } + ossRealtimeService := ossrealtime.NewOssRealtimeService(jwtWrapper, featureFlagWrapper, realtimeScannerWrapper) packages, err := ossRealtimeService.RunOssRealtimeScan(fileSourceFlag, ignoredFilePathFlag) @@ -29,6 +36,8 @@ func RunScanOssRealtimeCommand( return err } + packages.Packages = ossrealtime.FilterPackagesBySeverity(packages.Packages, severityFilter) + err = printer.Print(cmd.OutOrStdout(), packages, printer.FormatJSON) if err != nil { return errorconstants.NewRealtimeEngineError("failed to return packages").Error() diff --git a/internal/commands/scan.go b/internal/commands/scan.go index 816e3dc75..df8ea83b6 100644 --- a/internal/commands/scan.go +++ b/internal/commands/scan.go @@ -479,7 +479,8 @@ func scanASCASubCommand(jwtWrapper wrappers.JWTWrapper, featureFlagsWrapper wrap Example: heredoc.Doc( ` $ cx scan asca --file-source --asca-latest-version - $ cx scan asca --file-source --ignored-file-path + $ cx scan asca --file-source --ignored-file-path + $ cx scan asca --file-source --severity-filter "critical,high" `, ), Annotations: map[string]string{ @@ -503,6 +504,7 @@ func scanASCASubCommand(jwtWrapper wrappers.JWTWrapper, featureFlagsWrapper wrap ) scanASCACmd.PersistentFlags().String(commonParams.IgnoredFilePathFlag, "", "Path to a JSON file listing ignored ASCA findings") + scanASCACmd.PersistentFlags().String(commonParams.SeverityFilterFlag, "", commonParams.SeverityFilterFlagUsage) scanASCACmd.PersistentFlags().String(commonParams.ASCALocationFlag, "", "Path to custom location where ASCA engine is installed") _ = viper.BindPFlag(commonParams.ASCALocationKey, scanASCACmd.PersistentFlags().Lookup(commonParams.ASCALocationFlag)) @@ -522,6 +524,7 @@ func scanOssRealtimeSubCommand( Example: heredoc.Doc( ` $ cx scan oss-realtime -s --ignored-file-path + $ cx scan oss-realtime -s --severity-filter "critical,high" `, ), Annotations: map[string]string{ @@ -547,6 +550,8 @@ func scanOssRealtimeSubCommand( "Path to a JSON file listing ignored packages", ) + scanOssRealtimeCmd.Flags().String(commonParams.SeverityFilterFlag, "", commonParams.SeverityFilterFlagUsage) + return scanOssRealtimeCmd } @@ -562,6 +567,7 @@ func scanIacRealtimeSubCommand( Example: heredoc.Doc( ` $ cx scan iac-realtime -s --ignored-file-path + $ cx scan iac-realtime -s --severity-filter "critical,high" `, ), Annotations: map[string]string{ @@ -593,6 +599,8 @@ func scanIacRealtimeSubCommand( "Name of the container engine to run IaC-Realtime. (ex. docker, podman)", ) + scanIacRealtimeCmd.Flags().String(commonParams.SeverityFilterFlag, "", commonParams.SeverityFilterFlagUsage) + return scanIacRealtimeCmd } @@ -606,6 +614,7 @@ func scanContainersRealtimeSubCommand(realtimeScannerWrapper wrappers.RealtimeSc ` $ cx scan containers-realtime -s $ cx scan containers-realtime -s --ignored-file-path + $ cx scan containers-realtime -s --severity-filter "critical,high" `, ), Annotations: map[string]string{ @@ -625,6 +634,7 @@ func scanContainersRealtimeSubCommand(realtimeScannerWrapper wrappers.RealtimeSc "The file source should be the path to a single containers file (Dockerfile, docker-compose.yml, or Helm template)", ) scanContainersRealtimeCmd.Flags().String(commonParams.IgnoredFilePathFlag, "", "Path to ignored containers file") + scanContainersRealtimeCmd.Flags().String(commonParams.SeverityFilterFlag, "", commonParams.SeverityFilterFlagUsage) return scanContainersRealtimeCmd } @@ -641,6 +651,7 @@ func scanSecretsRealtimeSubCommand( Example: heredoc.Doc(` $ cx scan secrets-realtime -s $ cx scan secrets-realtime -s --ignored-file-path + $ cx scan secrets-realtime -s --severity-filter "critical,high" `), Annotations: map[string]string{ "command:doc": heredoc.Doc(` @@ -652,6 +663,7 @@ func scanSecretsRealtimeSubCommand( scanSecretsRealtimeCmd.Flags().StringP(commonParams.SourcesFlag, "s", "", "Path to the file to scan") scanSecretsRealtimeCmd.Flags().String(commonParams.IgnoredFilePathFlag, "", "Path to ignored secrets file") + scanSecretsRealtimeCmd.Flags().String(commonParams.SeverityFilterFlag, "", commonParams.SeverityFilterFlagUsage) return scanSecretsRealtimeCmd } diff --git a/internal/commands/secrets-realtime.go b/internal/commands/secrets-realtime.go index d309197f5..df98cbcde 100644 --- a/internal/commands/secrets-realtime.go +++ b/internal/commands/secrets-realtime.go @@ -4,6 +4,7 @@ import ( "github.com/checkmarx/ast-cli/internal/commands/util/printer" errorconstants "github.com/checkmarx/ast-cli/internal/constants/errors" commonParams "github.com/checkmarx/ast-cli/internal/params" + "github.com/checkmarx/ast-cli/internal/services/realtimeengine" "github.com/checkmarx/ast-cli/internal/services/realtimeengine/secretsrealtime" "github.com/checkmarx/ast-cli/internal/wrappers" "github.com/spf13/cobra" @@ -21,6 +22,12 @@ func RunScanSecretsRealtimeCommand( ignoredFilePathFlag, _ := cmd.Flags().GetString(commonParams.IgnoredFilePathFlag) + severityFilterFlag, _ := cmd.Flags().GetString(commonParams.SeverityFilterFlag) + severityFilter, err := realtimeengine.ParseSeverityFilter(severityFilterFlag) + if err != nil { + return err + } + secretsRealtimeService := secretsrealtime.NewSecretsRealtimeService(jwtWrapper, featureFlagWrapper) results, err := secretsRealtimeService.RunSecretsRealtimeScan(fileSourceFlag, ignoredFilePathFlag) @@ -28,6 +35,8 @@ func RunScanSecretsRealtimeCommand( return err } + results = secretsrealtime.FilterResultsBySeverity(results, severityFilter) + err = printer.Print(cmd.OutOrStdout(), results, printer.FormatJSON) if err != nil { return errorconstants.NewRealtimeEngineError(err.Error()).Error() diff --git a/internal/commands/severity-filter_test.go b/internal/commands/severity-filter_test.go new file mode 100644 index 000000000..21b5d3743 --- /dev/null +++ b/internal/commands/severity-filter_test.go @@ -0,0 +1,225 @@ +//go:build !integration + +package commands + +import ( + "bytes" + "encoding/json" + "os" + "path/filepath" + "testing" + + commonParams "github.com/checkmarx/ast-cli/internal/params" + "github.com/checkmarx/ast-cli/internal/services/realtimeengine/containersrealtime" + "github.com/checkmarx/ast-cli/internal/services/realtimeengine/ossrealtime" + "github.com/checkmarx/ast-cli/internal/services/realtimeengine/secretsrealtime" + "github.com/checkmarx/ast-cli/internal/wrappers" + "github.com/checkmarx/ast-cli/internal/wrappers/mock" + "github.com/spf13/cobra" + "github.com/stretchr/testify/assert" +) + +const ( + invalidSeverityFilterValue = "critical,hgh" + invalidSeverityFilterMsg = "invalid severity-filter value(s): hgh" + acceptedSeverityValuesMsg = "critical, high, medium, low, info" +) + +func enableRealtimeFlag() { + clearFlags() + mock.Flag = wrappers.FeatureFlagResponseModel{Name: wrappers.OssRealtimeEnabled, Status: true} +} + +// --------------------------------------------------------------------------- +// oss-realtime +// --------------------------------------------------------------------------- + +func TestOssRealtime_SeverityFilter_ValidValue_Success(t *testing.T) { + enableRealtimeFlag() + execCmdNilAssertion(t, + "scan", "oss-realtime", "-s", "data/manifests/package.json", "--severity-filter", "Critical, High", + ) +} + +func TestOssRealtime_SeverityFilter_EmptyValue_TreatedAsNoFilter(t *testing.T) { + enableRealtimeFlag() + execCmdNilAssertion(t, + "scan", "oss-realtime", "-s", "data/manifests/package.json", "--severity-filter", "", + ) +} + +func TestOssRealtime_SeverityFilter_InvalidValue_Fails(t *testing.T) { + enableRealtimeFlag() + err := execCmdNotNilAssertion(t, + "scan", "oss-realtime", "-s", "data/manifests/package.json", "--severity-filter", invalidSeverityFilterValue, + ) + assert.Contains(t, err.Error(), invalidSeverityFilterMsg) + assert.Contains(t, err.Error(), acceptedSeverityValuesMsg) +} + +func TestOssRealtime_SeverityFilter_OutputOnlyContainsAllowedSeverities(t *testing.T) { + enableRealtimeFlag() + + rt := &mock.RealtimeScannerMockWrapper{ + CustomScanPackages: func(req *wrappers.RealtimeScannerPackageRequest) (*wrappers.RealtimeScannerPackageResponse, error) { + var resp wrappers.RealtimeScannerPackageResponse + for _, p := range req.Packages { + resp.Packages = append(resp.Packages, wrappers.RealtimeScannerResults{ + PackageManager: p.PackageManager, + PackageName: p.PackageName, + Version: p.Version, + Status: "OK", + Vulnerabilities: []wrappers.RealtimeScannerVulnerability{ + {CVE: "CVE-H", Severity: "High"}, + {CVE: "CVE-L", Severity: "Low"}, + }, + }) + } + return &resp, nil + }, + } + + out := bytes.NewBuffer(nil) + cmd := &cobra.Command{} + cmd.SetOut(out) + cmd.Flags().String(commonParams.SourcesFlag, "data/manifests/package.json", "") + cmd.Flags().String(commonParams.IgnoredFilePathFlag, "", "") + cmd.Flags().String(commonParams.SeverityFilterFlag, "high", "") + + err := RunScanOssRealtimeCommand(rt, &mock.JWTMockWrapper{}, &mock.FeatureFlagsMockWrapper{})(cmd, nil) + assert.NoError(t, err) + + var results ossrealtime.OssPackageResults + assert.NoError(t, json.Unmarshal(out.Bytes(), &results)) + assert.NotEmpty(t, results.Packages) + for _, p := range results.Packages { + if p.Status == "Malicious" { + continue + } + for _, v := range p.Vulnerabilities { + assert.Equal(t, "High", v.Severity, "package %s returned a vulnerability outside the filter", p.PackageName) + } + } +} + +// --------------------------------------------------------------------------- +// containers-realtime +// --------------------------------------------------------------------------- + +func TestContainersRealtime_SeverityFilter_ValidValue_Success(t *testing.T) { + enableRealtimeFlag() + execCmdNilAssertion(t, "scan", "containers-realtime", "-s", "data/Dockerfile", "--severity-filter", "critical,high") +} + +func TestContainersRealtime_SeverityFilter_InvalidValue_Fails(t *testing.T) { + enableRealtimeFlag() + err := execCmdNotNilAssertion(t, "scan", "containers-realtime", "-s", "data/Dockerfile", "--severity-filter", invalidSeverityFilterValue) + assert.Contains(t, err.Error(), invalidSeverityFilterMsg) +} + +func TestContainersRealtime_SeverityFilter_OutputOnlyContainsAllowedSeverities(t *testing.T) { + enableRealtimeFlag() + + rt := &mock.RealtimeScannerMockWrapper{ + CustomScanImages: func(req *wrappers.ContainerImageRequest) (*wrappers.ContainerImageResponse, error) { + var resp wrappers.ContainerImageResponse + for _, img := range req.Images { + resp.Images = append(resp.Images, wrappers.ContainerImageResponseItem{ + ImageName: img.ImageName, + ImageTag: img.ImageTag, + Status: "OK", + Vulnerabilities: []wrappers.ContainerImageVulnerability{ + {CVE: "CVE-H", Severity: "High"}, + {CVE: "CVE-L", Severity: "Low"}, + }, + }) + } + return &resp, nil + }, + } + + out := bytes.NewBuffer(nil) + cmd := &cobra.Command{} + cmd.SetOut(out) + cmd.Flags().String(commonParams.SourcesFlag, "data/Dockerfile", "") + cmd.Flags().String(commonParams.IgnoredFilePathFlag, "", "") + cmd.Flags().String(commonParams.SeverityFilterFlag, "low", "") + + err := RunScanContainersRealtimeCommand(rt, &mock.JWTMockWrapper{}, &mock.FeatureFlagsMockWrapper{})(cmd, nil) + assert.NoError(t, err) + + var results containersrealtime.ContainerImageResults + assert.NoError(t, json.Unmarshal(out.Bytes(), &results)) + assert.NotEmpty(t, results.Images) + for _, img := range results.Images { + if img.Status != "OK" { + continue + } + assert.Len(t, img.Vulnerabilities, 1, "image %s should keep exactly the Low vulnerability", img.ImageName) + for _, v := range img.Vulnerabilities { + assert.Equal(t, "Low", v.Severity) + } + } +} + +// --------------------------------------------------------------------------- +// secrets-realtime +// --------------------------------------------------------------------------- + +func TestSecretsRealtime_SeverityFilter_ValidValue_Success(t *testing.T) { + enableRealtimeFlag() + execCmdNilAssertion(t, "scan", "secrets-realtime", "-s", "data/secret-exposed.txt", "--severity-filter", "critical,high") +} + +func TestSecretsRealtime_SeverityFilter_InvalidValue_Fails(t *testing.T) { + enableRealtimeFlag() + err := execCmdNotNilAssertion(t, "scan", "secrets-realtime", "-s", "data/secret-exposed.txt", "--severity-filter", invalidSeverityFilterValue) + assert.Contains(t, err.Error(), invalidSeverityFilterMsg) +} + +func TestSecretsRealtime_SeverityFilter_OutputOnlyContainsAllowedSeverities(t *testing.T) { + enableRealtimeFlag() + out, err := executeRedirectedTestCommand("scan", "secrets-realtime", "-s", "data/secret-exposed.txt", "--severity-filter", "critical") + assert.NoError(t, err) + + var results []secretsrealtime.SecretsRealtimeResult + assert.NoError(t, json.Unmarshal(out.Bytes(), &results)) + for _, r := range results { + assert.Equal(t, "Critical", r.Severity, "secret %s returned outside the filter", r.Title) + } +} + +// --------------------------------------------------------------------------- +// iac-realtime +// --------------------------------------------------------------------------- + +func TestIacRealtime_SeverityFilter_InvalidValue_FailsBeforeEngineStarts(t *testing.T) { + enableRealtimeFlag() + testFile := filepath.Join(t.TempDir(), "test.tf") + assert.NoError(t, os.WriteFile(testFile, []byte("resource \"aws_s3_bucket\" {}"), 0o600)) + + err := execCmdNotNilAssertion(t, "scan", "iac-realtime", "-s", testFile, "--severity-filter", invalidSeverityFilterValue) + // The parse error must win: no container engine error should be reported. + assert.Contains(t, err.Error(), invalidSeverityFilterMsg) +} + +func TestIacRealtime_SeverityFilter_ValidValue_FlagAccepted(t *testing.T) { + enableRealtimeFlag() + testFile := filepath.Join(t.TempDir(), "test.tf") + assert.NoError(t, os.WriteFile(testFile, []byte("resource \"aws_s3_bucket\" {}"), 0o600)) + + cmd := &cobra.Command{} + cmd.SetOut(bytes.NewBuffer(nil)) + cmd.Flags().String(commonParams.SourcesFlag, testFile, "") + cmd.Flags().String(commonParams.IgnoredFilePathFlag, "", "") + cmd.Flags().String(commonParams.EngineFlag, "docker", "") + cmd.Flags().String(commonParams.SeverityFilterFlag, "critical,high", "") + + err := RunScanIacRealtimeCommand(&mock.JWTMockWrapper{}, &mock.FeatureFlagsMockWrapper{})(cmd, nil) + if err != nil { + // A container engine is not guaranteed in the unit-test environment; the only + // failure this test must rule out is the severity-filter parse error. + assert.NotContains(t, err.Error(), "severity-filter") + t.Logf("iac-realtime returned an engine error (acceptable without docker): %v", err) + } +} diff --git a/internal/params/flags.go b/internal/params/flags.go index 5b322ff39..680fde3ff 100644 --- a/internal/params/flags.go +++ b/internal/params/flags.go @@ -33,6 +33,8 @@ const ( RetryDelayUsage = "Time between retries in seconds, use with --" + RetryFlag SourcesFlag = "file-source" IgnoredFilePathFlag = "ignored-file-path" + SeverityFilterFlag = "severity-filter" + SeverityFilterFlagUsage = "Comma-separated list of severities to return (critical, high, medium, low, info). Omit to return all severities." SourcesFlagSh = "s" TenantFlag = "tenant" TenantFlagUsage = "Checkmarx tenant" diff --git a/internal/services/asca-severity-filter_test.go b/internal/services/asca-severity-filter_test.go new file mode 100644 index 000000000..398d167c1 --- /dev/null +++ b/internal/services/asca-severity-filter_test.go @@ -0,0 +1,41 @@ +package services + +import ( + "testing" + + "github.com/checkmarx/ast-cli/internal/services/realtimeengine" + "github.com/checkmarx/ast-cli/internal/wrappers/grpcs" + "github.com/stretchr/testify/assert" +) + +func ascaDetails() []grpcs.ScanDetail { + return []grpcs.ScanDetail{ + {RuleID: 1, RuleName: "Critical rule", Severity: "Critical"}, + {RuleID: 2, RuleName: "High rule", Severity: "High"}, + {RuleID: 3, RuleName: "Medium rule", Severity: "Medium"}, + {RuleID: 4, RuleName: "Low rule", Severity: "Low"}, + } +} + +func TestFilterScanDetailsBySeverity_NilFilter_ReturnsInput(t *testing.T) { + in := ascaDetails() + out := FilterScanDetailsBySeverity(in, nil) + assert.Equal(t, in, out) +} + +func TestFilterScanDetailsBySeverity_CriticalHigh_DropsMediumAndLow(t *testing.T) { + f, err := realtimeengine.ParseSeverityFilter("critical,high") + assert.NoError(t, err) + + out := FilterScanDetailsBySeverity(ascaDetails(), f) + assert.Len(t, out, 2) + assert.Equal(t, "Critical", out[0].Severity) + assert.Equal(t, "High", out[1].Severity) +} + +func TestFilterScanDetailsBySeverity_NoMatch_ReturnsEmptyNonNil(t *testing.T) { + f, _ := realtimeengine.ParseSeverityFilter("info") + out := FilterScanDetailsBySeverity(ascaDetails(), f) + assert.NotNil(t, out) + assert.Len(t, out, 0) +} diff --git a/internal/services/asca.go b/internal/services/asca.go index 9bb61b74c..5635f87f6 100644 --- a/internal/services/asca.go +++ b/internal/services/asca.go @@ -183,6 +183,21 @@ func filterIgnoredAscaFindings(results []grpcs.ScanDetail, ignoreMap map[string] return filtered } +// FilterScanDetailsBySeverity keeps only the ASCA findings whose severity is allowed by f. +// A nil filter returns the input unchanged. +func FilterScanDetailsBySeverity(details []grpcs.ScanDetail, f realtimeengine.SeverityFilter) []grpcs.ScanDetail { + if f == nil { + return details + } + filtered := make([]grpcs.ScanDetail, 0, len(details)) + for i := range details { + if f.Allows(details[i].Severity) { + filtered = append(filtered, details[i]) + } + } + return filtered +} + func buildAscaIgnoreMap(ignored []grpcs.AscaIgnoreFinding) map[string]bool { m := make(map[string]bool) for _, f := range ignored { diff --git a/internal/services/realtimeengine/containersrealtime/containers-realtime.go b/internal/services/realtimeengine/containersrealtime/containers-realtime.go index afdc026ed..48bdbfaee 100644 --- a/internal/services/realtimeengine/containersrealtime/containers-realtime.go +++ b/internal/services/realtimeengine/containersrealtime/containers-realtime.go @@ -17,7 +17,38 @@ import ( "github.com/pkg/errors" ) -const defaultTag = "latest" +const ( + defaultTag = "latest" + + // statusMalicious is the realtime scanner status for a malicious image. + statusMalicious = "Malicious" +) + +// FilterImagesBySeverity trims each image's Vulnerabilities to the severities allowed by f. +// Malicious images carry no severity and are always kept untouched. Every image entry is kept +// in place even when its vulnerability list becomes empty. A nil filter returns the input unchanged. +func FilterImagesBySeverity(images []ContainerImage, f realtimeengine.SeverityFilter) []ContainerImage { + if f == nil { + return images + } + filtered := make([]ContainerImage, 0, len(images)) + for i := range images { + img := images[i] + if strings.EqualFold(img.Status, statusMalicious) { + filtered = append(filtered, img) + continue + } + vulns := make([]Vulnerability, 0, len(img.Vulnerabilities)) + for _, v := range img.Vulnerabilities { + if f.Allows(v.Severity) { + vulns = append(vulns, v) + } + } + img.Vulnerabilities = vulns + filtered = append(filtered, img) + } + return filtered +} // ContainersRealtimeService is the service responsible for performing real-time container scanning. type ContainersRealtimeService struct { diff --git a/internal/services/realtimeengine/containersrealtime/severity-filter_test.go b/internal/services/realtimeengine/containersrealtime/severity-filter_test.go new file mode 100644 index 000000000..7812a274d --- /dev/null +++ b/internal/services/realtimeengine/containersrealtime/severity-filter_test.go @@ -0,0 +1,64 @@ +package containersrealtime + +import ( + "testing" + + "github.com/checkmarx/ast-cli/internal/services/realtimeengine" + "github.com/stretchr/testify/assert" +) + +func containerImages() []ContainerImage { + return []ContainerImage{ + { + ImageName: "evil", ImageTag: "latest", Status: statusMalicious, + Vulnerabilities: []Vulnerability{{CVE: "CVE-1", Severity: "Low"}}, + }, + { + ImageName: "mixed", ImageTag: "1.0", Status: "OK", + Vulnerabilities: []Vulnerability{ + {CVE: "CVE-2", Severity: "Critical"}, + {CVE: "CVE-3", Severity: "High"}, + {CVE: "CVE-4", Severity: "Low"}, + }, + }, + { + ImageName: "low-only", ImageTag: "2.0", Status: "OK", + Vulnerabilities: []Vulnerability{{CVE: "CVE-5", Severity: "Low"}}, + }, + } +} + +func TestFilterImagesBySeverity_NilFilter_ReturnsInput(t *testing.T) { + in := containerImages() + assert.Equal(t, in, FilterImagesBySeverity(in, nil)) +} + +func TestFilterImagesBySeverity_MaliciousKeptUntouched(t *testing.T) { + f, _ := realtimeengine.ParseSeverityFilter("critical") + out := FilterImagesBySeverity(containerImages(), f) + + assert.Equal(t, "evil", out[0].ImageName) + assert.Len(t, out[0].Vulnerabilities, 1) + assert.Equal(t, "Low", out[0].Vulnerabilities[0].Severity) +} + +func TestFilterImagesBySeverity_VulnerabilitiesTrimmedToFilter(t *testing.T) { + f, _ := realtimeengine.ParseSeverityFilter("critical,high") + out := FilterImagesBySeverity(containerImages(), f) + + assert.Len(t, out[1].Vulnerabilities, 2) + assert.Equal(t, "CVE-2", out[1].Vulnerabilities[0].CVE) + assert.Equal(t, "CVE-3", out[1].Vulnerabilities[1].CVE) +} + +func TestFilterImagesBySeverity_EntryKeptWhenListBecomesEmpty(t *testing.T) { + f, _ := realtimeengine.ParseSeverityFilter("critical") + in := containerImages() + out := FilterImagesBySeverity(in, f) + + assert.Len(t, out, len(in)) + assert.Equal(t, "low-only", out[2].ImageName) + assert.NotNil(t, out[2].Vulnerabilities) + assert.Len(t, out[2].Vulnerabilities, 0) + assert.Len(t, in[2].Vulnerabilities, 1, "input slice must not be mutated") +} diff --git a/internal/services/realtimeengine/iacrealtime/iac-realtime.go b/internal/services/realtimeengine/iacrealtime/iac-realtime.go index a0290b92b..2e9e860b7 100644 --- a/internal/services/realtimeengine/iacrealtime/iac-realtime.go +++ b/internal/services/realtimeengine/iacrealtime/iac-realtime.go @@ -76,6 +76,21 @@ func filterIgnoredFindings(results []IacRealtimeResult, ignoreMap map[string]boo return filtered } +// FilterResultsBySeverity keeps only the IaC findings whose severity is allowed by f. +// A nil filter returns the input unchanged. +func FilterResultsBySeverity(results []IacRealtimeResult, f realtimeengine.SeverityFilter) []IacRealtimeResult { + if f == nil { + return results + } + filtered := make([]IacRealtimeResult, 0, len(results)) + for i := range results { + if f.Allows(results[i].Severity) { + filtered = append(filtered, results[i]) + } + } + return filtered +} + func (svc *IacRealtimeService) RunIacRealtimeScan(filePath, engine, ignoredFilePath string) ([]IacRealtimeResult, error) { err := svc.runValidations(filePath) if err != nil { diff --git a/internal/services/realtimeengine/iacrealtime/severity-filter_test.go b/internal/services/realtimeengine/iacrealtime/severity-filter_test.go new file mode 100644 index 000000000..e9624dbfd --- /dev/null +++ b/internal/services/realtimeengine/iacrealtime/severity-filter_test.go @@ -0,0 +1,41 @@ +package iacrealtime + +import ( + "testing" + + "github.com/checkmarx/ast-cli/internal/services/realtimeengine" + "github.com/stretchr/testify/assert" +) + +func iacResults() []IacRealtimeResult { + return []IacRealtimeResult{ + {Title: "crit", Severity: "Critical"}, + {Title: "high", Severity: "High"}, + {Title: "med", Severity: "Medium"}, + {Title: "low", Severity: "Low"}, + {Title: "info", Severity: "Info"}, + {Title: "unknown", Severity: "Unknown"}, + } +} + +func TestFilterResultsBySeverity_NilFilter_ReturnsInput(t *testing.T) { + in := iacResults() + assert.Equal(t, in, FilterResultsBySeverity(in, nil)) +} + +func TestFilterResultsBySeverity_CriticalHigh_DropsOthersIncludingUnknown(t *testing.T) { + f, err := realtimeengine.ParseSeverityFilter("Critical,High") + assert.NoError(t, err) + + out := FilterResultsBySeverity(iacResults(), f) + assert.Len(t, out, 2) + assert.Equal(t, "crit", out[0].Title) + assert.Equal(t, "high", out[1].Title) +} + +func TestFilterResultsBySeverity_Info_KeepsOnlyInfo(t *testing.T) { + f, _ := realtimeengine.ParseSeverityFilter("info") + out := FilterResultsBySeverity(iacResults(), f) + assert.Len(t, out, 1) + assert.Equal(t, "Info", out[0].Severity) +} diff --git a/internal/services/realtimeengine/ossrealtime/oss-realtime.go b/internal/services/realtimeengine/ossrealtime/oss-realtime.go index 5cd10397b..892c0ebe0 100644 --- a/internal/services/realtimeengine/ossrealtime/oss-realtime.go +++ b/internal/services/realtimeengine/ossrealtime/oss-realtime.go @@ -24,6 +24,9 @@ const ( pkgManagerCocoapods = "cocoapods" pkgManagerCarthage = "carthage" pkgManagerSwift = "swift" + + // statusMalicious is the realtime scanner status for a malicious package. + statusMalicious = "Malicious" ) // convertLocations converts models.Location to realtimeengine.Location @@ -113,6 +116,33 @@ func (o *OssRealtimeService) RunOssRealtimeScan(filePath, ignoredFilePath string return response, nil } +// FilterPackagesBySeverity trims each package's Vulnerabilities to the severities allowed by f. +// Malicious packages carry no severity and are always kept untouched. Every package entry is +// kept in place even when its vulnerability list becomes empty, so consumers still receive one +// entry per manifest package. A nil filter returns the input unchanged. +func FilterPackagesBySeverity(packages []OssPackage, f realtimeengine.SeverityFilter) []OssPackage { + if f == nil { + return packages + } + filtered := make([]OssPackage, 0, len(packages)) + for i := range packages { + pkg := packages[i] + if strings.EqualFold(pkg.Status, statusMalicious) { + filtered = append(filtered, pkg) + continue + } + vulns := make([]Vulnerability, 0, len(pkg.Vulnerabilities)) + for _, v := range pkg.Vulnerabilities { + if f.Allows(v.Severity) { + vulns = append(vulns, v) + } + } + pkg.Vulnerabilities = vulns + filtered = append(filtered, pkg) + } + return filtered +} + func buildIgnoreMap(ignored []IgnoredPackage) map[string]bool { m := make(map[string]bool) for _, ign := range ignored { diff --git a/internal/services/realtimeengine/ossrealtime/severity-filter_test.go b/internal/services/realtimeengine/ossrealtime/severity-filter_test.go new file mode 100644 index 000000000..45c236041 --- /dev/null +++ b/internal/services/realtimeengine/ossrealtime/severity-filter_test.go @@ -0,0 +1,77 @@ +package ossrealtime + +import ( + "testing" + + "github.com/checkmarx/ast-cli/internal/services/realtimeengine" + "github.com/stretchr/testify/assert" +) + +func ossPackages() []OssPackage { + return []OssPackage{ + { + PackageName: "evil", Status: statusMalicious, + Vulnerabilities: []Vulnerability{{CVE: "CVE-1", Severity: "Low"}}, + }, + { + PackageName: "mixed", Status: "OK", + Vulnerabilities: []Vulnerability{ + {CVE: "CVE-2", Severity: "Critical"}, + {CVE: "CVE-3", Severity: "High"}, + {CVE: "CVE-4", Severity: "Medium"}, + {CVE: "CVE-5", Severity: "Low"}, + }, + }, + { + PackageName: "low-only", Status: "OK", + Vulnerabilities: []Vulnerability{{CVE: "CVE-6", Severity: "Low"}}, + }, + {PackageName: "clean", Status: "OK"}, + } +} + +func TestFilterPackagesBySeverity_NilFilter_ReturnsInput(t *testing.T) { + in := ossPackages() + assert.Equal(t, in, FilterPackagesBySeverity(in, nil)) +} + +func TestFilterPackagesBySeverity_MaliciousKeptUntouched(t *testing.T) { + f, _ := realtimeengine.ParseSeverityFilter("critical") + out := FilterPackagesBySeverity(ossPackages(), f) + + assert.Equal(t, "evil", out[0].PackageName) + assert.Equal(t, statusMalicious, out[0].Status) + assert.Len(t, out[0].Vulnerabilities, 1, "malicious package vulnerabilities must not be trimmed") + assert.Equal(t, "Low", out[0].Vulnerabilities[0].Severity) +} + +func TestFilterPackagesBySeverity_VulnerabilitiesTrimmedToFilter(t *testing.T) { + f, _ := realtimeengine.ParseSeverityFilter("critical,high") + out := FilterPackagesBySeverity(ossPackages(), f) + + mixed := out[1] + assert.Equal(t, "mixed", mixed.PackageName) + assert.Len(t, mixed.Vulnerabilities, 2) + assert.Equal(t, "CVE-2", mixed.Vulnerabilities[0].CVE) + assert.Equal(t, "CVE-3", mixed.Vulnerabilities[1].CVE) +} + +func TestFilterPackagesBySeverity_EntryKeptWhenListBecomesEmpty(t *testing.T) { + f, _ := realtimeengine.ParseSeverityFilter("critical") + in := ossPackages() + out := FilterPackagesBySeverity(in, f) + + assert.Len(t, out, len(in), "every package entry must be kept") + lowOnly := out[2] + assert.Equal(t, "low-only", lowOnly.PackageName) + assert.Equal(t, "OK", lowOnly.Status) + assert.NotNil(t, lowOnly.Vulnerabilities) + assert.Len(t, lowOnly.Vulnerabilities, 0) +} + +func TestFilterPackagesBySeverity_DoesNotMutateInput(t *testing.T) { + f, _ := realtimeengine.ParseSeverityFilter("critical") + in := ossPackages() + _ = FilterPackagesBySeverity(in, f) + assert.Len(t, in[1].Vulnerabilities, 4, "input slice must not be mutated") +} diff --git a/internal/services/realtimeengine/secretsrealtime/secrets-realtime.go b/internal/services/realtimeengine/secretsrealtime/secrets-realtime.go index 406261caf..51b1d306b 100644 --- a/internal/services/realtimeengine/secretsrealtime/secrets-realtime.go +++ b/internal/services/realtimeengine/secretsrealtime/secrets-realtime.go @@ -53,6 +53,21 @@ func filterIgnoredSecrets(results []SecretsRealtimeResult, ignoreMap map[string] return filtered } +// FilterResultsBySeverity keeps only the secrets whose severity is allowed by f. +// A nil filter returns the input unchanged. +func FilterResultsBySeverity(results []SecretsRealtimeResult, f realtimeengine.SeverityFilter) []SecretsRealtimeResult { + if f == nil { + return results + } + filtered := make([]SecretsRealtimeResult, 0, len(results)) + for i := range results { + if f.Allows(results[i].Severity) { + filtered = append(filtered, results[i]) + } + } + return filtered +} + func buildIgnoreMap(ignored []IgnoredSecret) map[string]bool { m := make(map[string]bool) for _, s := range ignored { diff --git a/internal/services/realtimeengine/secretsrealtime/severity-filter_test.go b/internal/services/realtimeengine/secretsrealtime/severity-filter_test.go new file mode 100644 index 000000000..f22acd138 --- /dev/null +++ b/internal/services/realtimeengine/secretsrealtime/severity-filter_test.go @@ -0,0 +1,39 @@ +package secretsrealtime + +import ( + "testing" + + "github.com/checkmarx/ast-cli/internal/services/realtimeengine" + "github.com/stretchr/testify/assert" +) + +func secretsResults() []SecretsRealtimeResult { + return []SecretsRealtimeResult{ + {Title: "valid-key", Severity: criticalSeverity}, + {Title: "unknown-key", Severity: highSeverity}, + {Title: "revoked-key", Severity: mediumSeverity}, + } +} + +func TestFilterResultsBySeverity_NilFilter_ReturnsInput(t *testing.T) { + in := secretsResults() + assert.Equal(t, in, FilterResultsBySeverity(in, nil)) +} + +func TestFilterResultsBySeverity_Critical_KeepsOnlyCritical(t *testing.T) { + f, err := realtimeengine.ParseSeverityFilter("critical") + assert.NoError(t, err) + + out := FilterResultsBySeverity(secretsResults(), f) + assert.Len(t, out, 1) + assert.Equal(t, "valid-key", out[0].Title) +} + +func TestFilterResultsBySeverity_CriticalHigh_DropsMedium(t *testing.T) { + f, _ := realtimeengine.ParseSeverityFilter("critical,high") + out := FilterResultsBySeverity(secretsResults(), f) + assert.Len(t, out, 2) + for _, r := range out { + assert.NotEqual(t, mediumSeverity, r.Severity) + } +} diff --git a/internal/services/realtimeengine/severity.go b/internal/services/realtimeengine/severity.go new file mode 100644 index 000000000..4c80efe4c --- /dev/null +++ b/internal/services/realtimeengine/severity.go @@ -0,0 +1,67 @@ +package realtimeengine + +import ( + "fmt" + "strings" + + errorconstants "github.com/checkmarx/ast-cli/internal/constants/errors" +) + +// AcceptedSeverities lists the values the --severity-filter flag accepts, in display order. +var AcceptedSeverities = []string{"critical", "high", "medium", "low", "info"} + +// SeverityFilter is the set of lowercase severities a realtime command should return. +// A nil filter means "no filtering": every severity is allowed. +type SeverityFilter map[string]struct{} + +// ParseSeverityFilter parses the raw --severity-filter flag value. +// An empty or whitespace-only value returns a nil filter (allow all). +// Tokens are trimmed, lowercased and blank tokens are skipped, matching the +// other comma-separated flags on `cx scan`. Every unknown token is collected +// into a single RealtimeEngineError that also lists the accepted values. +func ParseSeverityFilter(raw string) (SeverityFilter, error) { + if strings.TrimSpace(raw) == "" { + return nil, nil + } + + accepted := make(map[string]struct{}, len(AcceptedSeverities)) + for _, s := range AcceptedSeverities { + accepted[s] = struct{}{} + } + + filter := make(SeverityFilter) + var invalid []string + for _, token := range strings.Split(raw, ",") { + token = strings.ToLower(strings.TrimSpace(token)) + if token == "" { + continue + } + if _, ok := accepted[token]; !ok { + invalid = append(invalid, token) + continue + } + filter[token] = struct{}{} + } + + if len(invalid) > 0 { + return nil, errorconstants.NewRealtimeEngineError(fmt.Sprintf( + "invalid severity-filter value(s): %s. Accepted values: %s", + strings.Join(invalid, ", "), strings.Join(AcceptedSeverities, ", "), + )).Error() + } + + if len(filter) == 0 { + return nil, nil + } + return filter, nil +} + +// Allows reports whether a finding with the given severity should be returned. +// A nil filter allows everything; comparison is case insensitive. +func (f SeverityFilter) Allows(severity string) bool { + if f == nil { + return true + } + _, ok := f[strings.ToLower(strings.TrimSpace(severity))] + return ok +} diff --git a/internal/services/realtimeengine/severity_test.go b/internal/services/realtimeengine/severity_test.go new file mode 100644 index 000000000..977267fb1 --- /dev/null +++ b/internal/services/realtimeengine/severity_test.go @@ -0,0 +1,61 @@ +package realtimeengine + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestParseSeverityFilter_EmptyOrWhitespace_ReturnsNilFilter(t *testing.T) { + for _, raw := range []string{"", " ", ",", " , ,"} { + f, err := ParseSeverityFilter(raw) + assert.NoError(t, err, "input %q", raw) + assert.Nil(t, f, "input %q", raw) + assert.True(t, f.Allows("High"), "nil filter must allow everything") + } +} + +func TestParseSeverityFilter_MixedCaseSpacesAndTrailingComma_Normalised(t *testing.T) { + f, err := ParseSeverityFilter(" Critical, high ,HIGH,") + assert.NoError(t, err) + assert.Len(t, f, 2) + assert.True(t, f.Allows("critical")) + assert.True(t, f.Allows("CRITICAL")) + assert.True(t, f.Allows(" High ")) + assert.False(t, f.Allows("Medium")) + assert.False(t, f.Allows("Low")) + assert.False(t, f.Allows("")) +} + +func TestParseSeverityFilter_AllAcceptedValues(t *testing.T) { + f, err := ParseSeverityFilter("critical,high,medium,low,info") + assert.NoError(t, err) + assert.Len(t, f, len(AcceptedSeverities)) + for _, s := range AcceptedSeverities { + assert.True(t, f.Allows(s)) + } + assert.False(t, f.Allows("unknown")) +} + +func TestParseSeverityFilter_SingleInvalidToken_ReturnsError(t *testing.T) { + f, err := ParseSeverityFilter("Critical,Hgh") + assert.Error(t, err) + assert.Nil(t, f) + assert.Contains(t, err.Error(), "realtime engine error") + assert.Contains(t, err.Error(), "hgh") + assert.Contains(t, err.Error(), "critical, high, medium, low, info") +} + +func TestParseSeverityFilter_MultipleInvalidTokens_SingleConsolidatedError(t *testing.T) { + _, err := ParseSeverityFilter("foo,high,bar") + assert.Error(t, err) + assert.Contains(t, err.Error(), "foo, bar") +} + +func TestSeverityFilter_Allows_CaseInsensitive(t *testing.T) { + f := SeverityFilter{"high": {}} + assert.True(t, f.Allows("high")) + assert.True(t, f.Allows("High")) + assert.True(t, f.Allows("HIGH")) + assert.False(t, f.Allows("medium")) +} diff --git a/test/integration/severity-filter_test.go b/test/integration/severity-filter_test.go new file mode 100644 index 000000000..012bf5dbe --- /dev/null +++ b/test/integration/severity-filter_test.go @@ -0,0 +1,149 @@ +//go:build integration + +package integration + +import ( + "encoding/json" + "strings" + "testing" + + commonParams "github.com/checkmarx/ast-cli/internal/params" + "github.com/checkmarx/ast-cli/internal/services/realtimeengine/containersrealtime" + "github.com/checkmarx/ast-cli/internal/services/realtimeengine/iacrealtime" + "github.com/checkmarx/ast-cli/internal/services/realtimeengine/ossrealtime" + "github.com/checkmarx/ast-cli/internal/services/realtimeengine/secretsrealtime" + "github.com/checkmarx/ast-cli/internal/wrappers/configuration" + "github.com/checkmarx/ast-cli/internal/wrappers/grpcs" + "github.com/stretchr/testify/assert" +) + +const severityFilterCriticalHigh = "critical,high" + +func isCriticalOrHigh(severity string) bool { + switch strings.ToLower(severity) { + case "critical", "high": + return true + } + return false +} + +func TestOssRealtimeScan_SeverityFilter_OnlyAllowedSeveritiesReturned(t *testing.T) { + configuration.LoadConfiguration() + args := []string{ + "scan", "oss-realtime", + flag(commonParams.SourcesFlag), "data/manifests/package.json", + flag(commonParams.SeverityFilterFlag), severityFilterCriticalHigh, + } + + err, bytes := executeCommand(t, args...) + assert.Nil(t, err, "oss-realtime with --severity-filter should not fail") + + var packages ossrealtime.OssPackageResults + assert.Nil(t, json.Unmarshal(bytes.Bytes(), &packages), "Failed to unmarshal package results") + assert.Greater(t, len(packages.Packages), 0, "Every manifest package must still be returned") + for _, pkg := range packages.Packages { + if strings.EqualFold(pkg.Status, "Malicious") { + continue + } + for _, v := range pkg.Vulnerabilities { + assert.True(t, isCriticalOrHigh(v.Severity), + "package %s returned %s vulnerability outside the filter", pkg.PackageName, v.Severity) + } + } +} + +func TestOssRealtimeScan_SeverityFilter_InvalidValue_ReturnsError(t *testing.T) { + configuration.LoadConfiguration() + args := []string{ + "scan", "oss-realtime", + flag(commonParams.SourcesFlag), "data/manifests/package.json", + flag(commonParams.SeverityFilterFlag), "critical,hgh", + } + + err, _ := executeCommand(t, args...) + assert.NotNil(t, err) + assert.Contains(t, err.Error(), "invalid severity-filter value(s): hgh") +} + +func TestContainersRealtimeScan_SeverityFilter_OnlyAllowedSeveritiesReturned(t *testing.T) { + // The positive Dockerfile case is skipped in this environment until the containers RT API + // is deployed (see containers-realtime_test.go), so this test uses the same empty Dockerfile + // the existing success test relies on: it proves the flag is accepted end to end. + configuration.LoadConfiguration() + args := []string{ + "scan", "containers-realtime", + flag(commonParams.SourcesFlag), "data/empty/Dockerfile", + flag(commonParams.SeverityFilterFlag), severityFilterCriticalHigh, + } + + err, bytes := executeCommand(t, args...) + assert.Nil(t, err, "containers-realtime with --severity-filter should not fail") + + var images containersrealtime.ContainerImageResults + assert.Nil(t, json.Unmarshal(bytes.Bytes(), &images), "Failed to unmarshal image results") + for _, img := range images.Images { + if strings.EqualFold(img.Status, "Malicious") { + continue + } + for _, v := range img.Vulnerabilities { + assert.True(t, isCriticalOrHigh(v.Severity), + "image %s returned %s vulnerability outside the filter", img.ImageName, v.Severity) + } + } +} + +func TestSecretsRealtimeScan_SeverityFilter_OnlyAllowedSeveritiesReturned(t *testing.T) { + args := []string{ + "scan", "secrets-realtime", + flag(commonParams.SourcesFlag), "data/secret-exposed.txt", + flag(commonParams.SeverityFilterFlag), severityFilterCriticalHigh, + } + + err, bytes := executeCommand(t, args...) + assert.Nil(t, err, "secrets-realtime with --severity-filter should not fail") + + var results []secretsrealtime.SecretsRealtimeResult + assert.Nil(t, json.Unmarshal(bytes.Bytes(), &results), "Failed to unmarshal secrets results") + for _, r := range results { + assert.True(t, isCriticalOrHigh(r.Severity), "secret %s returned %s outside the filter", r.Title, r.Severity) + } +} + +func TestIacRealtimeScan_SeverityFilter_OnlyAllowedSeveritiesReturned(t *testing.T) { + configuration.LoadConfiguration() + args := []string{ + "scan", "iac-realtime", + flag(commonParams.SourcesFlag), "data/positive1.tf", + flag(commonParams.EngineFlag), "docker", + flag(commonParams.SeverityFilterFlag), severityFilterCriticalHigh, + } + + err, bytes := executeCommand(t, args...) + assert.Nil(t, err, "iac-realtime with --severity-filter should not fail") + + var results []iacrealtime.IacRealtimeResult + assert.Nil(t, safeJSONUnmarshal(bytes.Bytes(), &results), "Failed to unmarshal IaC results") + for _, r := range results { + assert.True(t, isCriticalOrHigh(r.Severity), "finding %s returned %s outside the filter", r.Title, r.Severity) + } +} + +func TestExecuteASCAScan_SeverityFilter_OnlyAllowedSeveritiesReturned(t *testing.T) { + configuration.LoadConfiguration() + args := []string{ + "scan", "asca", + flag(commonParams.SourcesFlag), "data/python-vul-file.py", + flag(commonParams.AgentFlag), commonParams.DefaultAgent, + flag(commonParams.SeverityFilterFlag), severityFilterCriticalHigh, + } + + err, bytes := executeCommand(t, args...) + assert.Nil(t, err, "asca with --severity-filter should not fail") + + var scanResult grpcs.ScanResult + assert.Nil(t, json.Unmarshal(bytes.Bytes(), &scanResult), "Failed to unmarshal scan result") + assert.Nil(t, scanResult.Error) + for _, d := range scanResult.ScanDetails { + assert.True(t, isCriticalOrHigh(d.Severity), "rule %s returned %s outside the filter", d.RuleName, d.Severity) + } +}