From 288727f9e7958c552e6020be8f4b22298a17ad3e Mon Sep 17 00:00:00 2001 From: Sumit Morchhale Date: Thu, 12 Nov 2026 14:45:28 +0530 Subject: [PATCH 1/2] Merge staging branch into main(AST-0000) (#1614) * Honour the VS Code Checkmarx Self-Healing setting in Copilot agent hooks (AST-180812) (#1603) * AST-180812 - Detect VS Code Copilot CLI sessions from GITHUB_COPILOT_INTEGRATION_ID (#1604) * Feature/ast 180812 vscode copilot cli host (#1607) * Update brotli dependency to v1.2.7 (AST-189161) (#1610) * Update github.com/andybalholm/brotli from v1.2.0 to v1.2.7 (AST-189161) Indirect dependency pulled in via anchore/syft -> anchore/archiver. No API removals; archiver only uses NewWriterLevel/NewReader, which are unchanged. Co-Authored-By: Claude Fable 5.1 * Update Docker base image checkmarx/bash:5.3 to latest digest (AST-189161) Bumps the SHA256-pinned base image to the 5.3-r14 build pushed on 2026-11-04. Co-Authored-By: Claude Fable 5.1 * Replace .trivyignore entries with current binary findings (AST-189161) Ignore GO-2026-5932 (x/crypto/openpgp via helm provenance), CVE-2026-78661 and CVE-2026-97045 (x/net/html via syft Maven cataloger). Remove the previous Wolfi base-image and syft/docker entries, which no longer apply. Co-Authored-By: Claude Fable 5.1 * Restore syft and docker entries in .trivyignore (AST-189161) CVE-2026-33481 (syft temp cleanup) and CVE-2026-33997 (moby plugin privilege bypass) are still reported against the binary. Neither has an adoptable fix: syft >= 1.42.3 reintroduces the binary-size regression reverted in AST-188320 and docker/docker has no 29.x release on its module path. Justifications and reachability analysis are recorded in the file. Co-Authored-By: Claude Fable 5.1 * Bump golang.org/x/net to v0.62.0 and trim .trivyignore (AST-189161) Bump the indirect golang.org/x/net dependency to v0.62.0, which fixes CVE-2026-78661 and CVE-2026-97045, so their ignore entries are dropped. Keep only the ignores that cannot be fixed directly: GO-2026-5932 (x/crypto openpgp, via helm), CVE-2026-33481 (syft) and CVE-2026-33997 (docker). Co-Authored-By: Claude Sonnet 5.5 --------- Co-authored-by: Claude Fable 5.1 Co-authored-by: atishj99 * revret exclude git config changes (#1609) Co-authored-by: Aniket Shinde * Use self-repository syntax for reusable workflow in nightly-parallel (AST-189161) Replace `uses: ./.github/workflows/ci-tests.yml` with the `$/` form to satisfy the zizmor `self-repository` audit (added in zizmor v1.30.0). Co-Authored-By: Claude Sonnet 5.5 * Handle missing feature flags(AST-188568) (#1613) * Handle missing feature flags gracefully (code 100 response) When the API returns a 404 with error code 100 and message "flag with the given name is not found", return a disabled flag model instead of nil to prevent nil pointer dereference panics in calling code. Missing flags are treated as enabled (default) to ensure safe feature flag fallback behavior. Fixes panic: runtime error: invalid memory address or nil pointer dereference when GetSpecificFlag is called and the flag doesn't exist on the server. * Refactor: use existing WebError struct instead of inline type Replace inline error response struct with the existing WebError struct from ast.go for consistency with the rest of the codebase. This improves maintainability and follows the established pattern in wrappers like bfl-http.go and codebashing-http.go. * handle remove ff * Remove INCREASE_FILE_UPLOAD_LIMIT flag - now always enabled for large files Removed the INCREASE_FILE_UPLOAD_LIMIT feature flag that controlled multipart uploads. The flag is now permanently enabled - files > 5GB always use multipart upload, smaller files use single upload. This simplifies the code by removing the flag check and associated tests. Changes: - Removed flag constant from feature-flags.go - Updated scan.go to always check file size (no flag check) - Consolidated 5 tests to 3 tests (removed redundant flag-based tests) - Behavior unchanged: multipart for >5GB, single for <=5GB No regression - functionality preserved, code simplified. * removed status code handling * updated docker image --------- Co-authored-by: Anurag Dalke <120229307+cx-anurag-dalke@users.noreply.github.com> * Undo merge conflict resolution commit This removes the problematic merge commit a1df4b17 that resolved the Dockerfile conflict. Going back to the clean state before that merge attempt. All code is preserved - reverting to e3250aa5 state. Co-Authored-By: Claude Haiku 4.5 * Ignore glibc CVE-2026-84243 and Go stdlib CVE-2026-97054 in Trivy Both are newly disclosed. glibc comes from the checkmarx/bash base image (fix in 2.44-r16, no rebuilt image yet); stdlib is fixed in Go 1.26.11. Remove once the base image is rebuilt and the Go toolchain is bumped. Co-Authored-By: Claude Sonnet 5.5 --------- Co-authored-by: Rahul Pidde <206018639+cx-rahul-pidde@users.noreply.github.com> Co-authored-by: Anurag Dalke Co-authored-by: Claude Fable 5.1 Co-authored-by: atishj99 Co-authored-by: Aniket Shinde Co-authored-by: Anurag Dalke <120229307+cx-anurag-dalke@users.noreply.github.com> --- .trivyignore | 19 +++++++++++++++ Dockerfile | 8 +++---- internal/commands/scan.go | 3 +-- internal/commands/scan_test.go | 37 +++--------------------------- internal/wrappers/feature-flags.go | 1 - 5 files changed, 27 insertions(+), 41 deletions(-) diff --git a/.trivyignore b/.trivyignore index cd0e4ebc..ced74e1b 100644 --- a/.trivyignore +++ b/.trivyignore @@ -33,3 +33,22 @@ CVE-2026-33997 # Impact: CLI does not perform OpenPGP signing/verification. # Status: Risk accepted GO-2026-5932 + +# ============================================================================ +# NEWLY DISCLOSED - Waiting on upstream fix +# ============================================================================ + +# CVE-2026-84243: glibc arbitrary code execution via directory traversal in LANGUAGE env var +# Severity: MEDIUM +# Component: glibc, glibc-2.44-locale-posix, ld-linux, libcrypt1 (checkmarx/bash base image) +# Current Version: 2.44-r14 (fixed in 2.44-r16) +# Reason: OS package inside the checkmarx/bash base image; no newer image is published yet. +# Status: Temporary ignore - remove once the base image is rebuilt with glibc >= 2.44-r16 +CVE-2026-84243 + +# CVE-2026-97054: Go stdlib net/http HTTP/1 MaxBytesReader limit handling +# Severity: UNKNOWN +# Component: stdlib (Go v1.26.10) +# Reason: Fixed in Go 1.26.11 / 1.27.4. +# Status: Temporary ignore - remove once go.mod / CI toolchain is bumped to Go >= 1.26.11 +CVE-2026-97054 diff --git a/Dockerfile b/Dockerfile index 2c4c92c7..3b0ef2e8 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,8 +1,8 @@ -FROM checkmarx/bash:5.3-r14-e52a196c3a914c@sha256:e52a196c3a914c6496c72465ad4a8f7efd1ff8ad988b328cbb92018652c23c7d +FROM checkmarx/bash:5.3-r14-fad83378373438@sha256:fad833783734389f27b9d8ab3b5e9dda6eb44fdf1892145c70058cb774da817d USER nonroot -COPY cx /app/bin/cx - -ENTRYPOINT ["/app/bin/cx"] +COPY cx /app/bin/cx + +ENTRYPOINT ["/app/bin/cx"] HEALTHCHECK NONE diff --git a/internal/commands/scan.go b/internal/commands/scan.go index 37931d16..816e3dc7 100644 --- a/internal/commands/scan.go +++ b/internal/commands/scan.go @@ -2565,8 +2565,7 @@ func uploadZip(uploadsWrapper wrappers.UploadsWrapper, zipFilePath string, unzip } logger.PrintIfVerbose(fmt.Sprintf("Zip size before upload: %.2fMB\n", float64(fileInfo.Size())/mbBytes)) - flagResponse, _ := featureFlagsWrapper.GetSpecificFlag(wrappers.IncreaseFileUploadLimit) - if flagResponse.Status && fileInfo.Size() > MaxSizeBytes { + if fileInfo.Size() > MaxSizeBytes { logger.PrintIfVerbose("Uploading source code in multiple parts.") preSignedURL, zipFilePathErr = uploadsWrapper.UploadFileInMultipart(zipFilePath, featureFlagsWrapper) } else { diff --git a/internal/commands/scan_test.go b/internal/commands/scan_test.go index 76037be0..fadd433a 100644 --- a/internal/commands/scan_test.go +++ b/internal/commands/scan_test.go @@ -4913,12 +4913,11 @@ func TestEnforceLocalResolutionForTarFiles_Integration(t *testing.T) { } } -func TestUploadZip_AsMultipartUpload_when_FF_Enable_ZIP_Exceeds_5GB(t *testing.T) { +func TestUploadZip_AsMultipartUpload_when_ZIP_Exceeds_5GB(t *testing.T) { // Simulate a file size > 5GB by setting MaxSizeBytes to less than actual size MaxSizeBytes = 1 defer func() { MaxSizeBytes = 5 * 1024 * 1024 * 1024 }() // Reset after test uploadWrapper := mock.UploadsMockWrapper{} - mock.Flag = wrappers.FeatureFlagResponseModel{Name: wrappers.IncreaseFileUploadLimit, Status: true} featureFlagsWrapper := &mock.FeatureFlagsMockWrapper{} url, zipPath, err := uploadZip(&uploadWrapper, "data/sources.zip", false, true, featureFlagsWrapper) assert.NilError(t, err) @@ -4926,37 +4925,8 @@ func TestUploadZip_AsMultipartUpload_when_FF_Enable_ZIP_Exceeds_5GB(t *testing.T assert.Equal(t, url, "multiPart/path/to/nowhere") } -func TestUploadZip_AsMultipartUpload_when_FF_Disable_ZIP_Exceeds_5GB(t *testing.T) { - fileInfo, err := os.Stat("data/sources.zip") - if err != nil { - t.Fatalf("Failed to close zip file: %v", err) - } - // Simulate a file size > 5GB by setting MaxSizeBytes to less than actual size - MaxSizeBytes = fileInfo.Size() - 1 - defer func() { MaxSizeBytes = 5 * 1024 * 1024 * 1024 }() // Reset after test - - uploadWrapper := mock.UploadsMockWrapper{} - mock.Flag = wrappers.FeatureFlagResponseModel{Name: wrappers.IncreaseFileUploadLimit, Status: false} - featureFlagsWrapper := &mock.FeatureFlagsMockWrapper{} - url, zipPath, err := uploadZip(&uploadWrapper, "data/sources.zip", false, true, featureFlagsWrapper) - assert.NilError(t, err) - assert.Equal(t, zipPath, "") - assert.Equal(t, url, "singlePart/path/to/nowhere") -} - -func TestUploadZip_AsMultipartUpload_when_FF_Enable_ZIP_LessThan_5GB(t *testing.T) { - uploadWrapper := mock.UploadsMockWrapper{} - mock.Flag = wrappers.FeatureFlagResponseModel{Name: wrappers.IncreaseFileUploadLimit, Status: true} - featureFlagsWrapper := &mock.FeatureFlagsMockWrapper{} - url, zipPath, err := uploadZip(&uploadWrapper, "data/sources.zip", false, true, featureFlagsWrapper) - assert.NilError(t, err) - assert.Equal(t, zipPath, "") - assert.Equal(t, url, "singlePart/path/to/nowhere") -} - -func TestUploadZip_AsMultipartUpload_when_FF_Disable_ZIP_LessThan_5GB(t *testing.T) { +func TestUploadZip_AsSingleUpload_when_ZIP_LessThan_5GB(t *testing.T) { uploadWrapper := mock.UploadsMockWrapper{} - mock.Flag = wrappers.FeatureFlagResponseModel{Name: wrappers.IncreaseFileUploadLimit, Status: false} featureFlagsWrapper := &mock.FeatureFlagsMockWrapper{} url, zipPath, err := uploadZip(&uploadWrapper, "data/sources.zip", false, true, featureFlagsWrapper) assert.NilError(t, err) @@ -4964,7 +4934,7 @@ func TestUploadZip_AsMultipartUpload_when_FF_Disable_ZIP_LessThan_5GB(t *testing assert.Equal(t, url, "singlePart/path/to/nowhere") } -func TestUploadZip_AsMultipartUpload_when_FF_Enable_ZIP_Exceeds_5GB_Error(t *testing.T) { +func TestUploadZip_AsMultipartUpload_when_ZIP_Exceeds_5GB_Error(t *testing.T) { // Create a temporary zip file dir := t.TempDir() zipPathTemp := filepath.Join(dir, "failureCaseLarge.zip") @@ -4998,7 +4968,6 @@ func TestUploadZip_AsMultipartUpload_when_FF_Enable_ZIP_Exceeds_5GB_Error(t *tes defer func() { MaxSizeBytes = 5 * 1024 * 1024 * 1024 }() // uploadWrapper := mock.UploadsMockWrapper{} - mock.Flag = wrappers.FeatureFlagResponseModel{Name: wrappers.IncreaseFileUploadLimit, Status: true} featureFlagsWrapper := &mock.FeatureFlagsMockWrapper{} _, zipPath, err := uploadZip(&uploadWrapper, zipPathTemp, false, true, featureFlagsWrapper) assert.Assert(t, err != nil) diff --git a/internal/wrappers/feature-flags.go b/internal/wrappers/feature-flags.go index c4008f64..6831f277 100644 --- a/internal/wrappers/feature-flags.go +++ b/internal/wrappers/feature-flags.go @@ -19,7 +19,6 @@ const SscsCommitHistoryEnabled = "SSCS_COMMIT_HISTORY_ENABLED" const DirectAssociationEnabled = "DIRECT_APP_ASSOCIATION_ENABLED" const DaMigrationEnabled = "DA_MIGRATION_ENABLED" const maxRetries = 3 -const IncreaseFileUploadLimit = "INCREASE_FILE_UPLOAD_LIMIT" const ScaDeltaScanEnabled = "SCA_DELTASCAN_ENABLED" // RepostoreCustomerContributorsCsvEnabled is the feature flag for generating contributors.csv and metadata.json. From 64a19b2a5120897d8bc049442b8a1c1ff2de3561 Mon Sep 17 00:00:00 2001 From: Anurag Dalke <120229307+cx-anurag-dalke@users.noreply.github.com> Date: Thu, 19 Nov 2026 17:35:48 +0530 Subject: [PATCH 2/2] Add --severity-filter flag to realtime scan commands (AST-193900) Adds an optional, comma-separated --severity-filter flag to the five Dev Assist realtime commands: asca, oss-realtime, iac-realtime, containers-realtime and secrets-realtime. Accepted values are critical, high, medium, low and info (case insensitive). When the flag is omitted or empty, all severities are returned, so existing callers are unaffected. Invalid tokens fail fast with a RealtimeEngineError that lists the accepted values. Filtering is applied client side in the command layer after the service returns; service signatures are unchanged. For oss-realtime and containers-realtime the filter trims each package/image's vulnerability list and leaves malicious entries untouched, so consumers still receive one entry per manifest item. Includes unit tests for the shared parser and each engine's filter, plus integration tests for the new flag. Co-Authored-By: Claude Fable 5.1 --- internal/commands/asca/asca-engine.go | 10 + .../commands/asca/severity-filter_test.go | 43 ++++ .../commands/containers-realtime-engine.go | 9 + internal/commands/iac-realtime-engine.go | 9 + internal/commands/oss-realtime-engine.go | 9 + internal/commands/scan.go | 14 +- internal/commands/secrets-realtime.go | 9 + internal/commands/severity-filter_test.go | 225 ++++++++++++++++++ internal/params/flags.go | 2 + .../services/asca-severity-filter_test.go | 41 ++++ internal/services/asca.go | 15 ++ .../containersrealtime/containers-realtime.go | 33 ++- .../severity-filter_test.go | 64 +++++ .../iacrealtime/iac-realtime.go | 15 ++ .../iacrealtime/severity-filter_test.go | 41 ++++ .../ossrealtime/oss-realtime.go | 30 +++ .../ossrealtime/severity-filter_test.go | 77 ++++++ .../secretsrealtime/secrets-realtime.go | 15 ++ .../secretsrealtime/severity-filter_test.go | 39 +++ internal/services/realtimeengine/severity.go | 67 ++++++ .../services/realtimeengine/severity_test.go | 61 +++++ test/integration/severity-filter_test.go | 149 ++++++++++++ 22 files changed, 975 insertions(+), 2 deletions(-) create mode 100644 internal/commands/asca/severity-filter_test.go create mode 100644 internal/commands/severity-filter_test.go create mode 100644 internal/services/asca-severity-filter_test.go create mode 100644 internal/services/realtimeengine/containersrealtime/severity-filter_test.go create mode 100644 internal/services/realtimeengine/iacrealtime/severity-filter_test.go create mode 100644 internal/services/realtimeengine/ossrealtime/severity-filter_test.go create mode 100644 internal/services/realtimeengine/secretsrealtime/severity-filter_test.go create mode 100644 internal/services/realtimeengine/severity.go create mode 100644 internal/services/realtimeengine/severity_test.go create mode 100644 test/integration/severity-filter_test.go diff --git a/internal/commands/asca/asca-engine.go b/internal/commands/asca/asca-engine.go index cad19fd7..3781cc75 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 00000000..2b4a47d2 --- /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 dddce085..5310e5ea 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 cf253471..9a28d85f 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 31d49d9e..e4f4e80e 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 816e3dc7..df8ea83b 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 d309197f..df98cbcd 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 00000000..21b5d374 --- /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 5b322ff3..680fde3f 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 00000000..398d167c --- /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 9bb61b74..5635f87f 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 afdc026e..48bdbfae 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 00000000..7812a274 --- /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 a0290b92..2e9e860b 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 00000000..e9624dbf --- /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 5cd10397..892c0ebe 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 00000000..45c23604 --- /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 406261ca..51b1d306 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 00000000..f22acd13 --- /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 00000000..4c80efe4 --- /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 00000000..977267fb --- /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 00000000..012bf5db --- /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) + } +}