Use a configuration file

Last updated: Nov 10, 2026


The most flexible way to run the Fluid Attacks scanners is with a YAML configuration file.

This simple example shows the recommended configuration of the SAST CLI:

namespace: myapp
output:
  file_path: ./Fluid-Attacks-Results.csv
  format: CSV
working_dir: .
language: EN
sast:
  include:
    - .
  exclude:
    - glob(**/node_modules/**)
    - glob(**/test/**)

Common configuration file keys

Some common keys apply to all the Fluid Attacks scanners. This section tells you what each key in the configuration file means.

All the keys are optional. Thus, you can configure the scans as necessary. If some keys are not in the configuration file, the tool continues to operate correctly.

namespace

namespace gives a name to the analysis, usually the name of the repository that the scanner analyzes. For example:

namespace: my_app

working_dir

working_dir gives the path to the repository that you want to analyze. If you configure paths in the apk, sast, or sca keys, write these paths relative to this directory. For example:

working_dir: /absolute/path/to/directory

commit

Use commit to include the current commit SHA of the repository that you want to analyze. Use it only if this SHA is necessary in the SARIF results file. For example:

commit: e59607b9de3ef4c13d292705fg3da1ff0c67eb38

language

language sets the language of the vulnerability report. The correct values are EN (English) and ES (Spanish). If you do not set it, the default value is EN. For example:

language: ES

output

output sets the location and the format of the scan results. By default, the terminal shows the vulnerability reports. You can use these options:

  • file_path: Sets the location of the output file
  • format: Sets the output format. The values are CSV (comma-separated values), SARIF (Static Analysis Results Interchange Format), or ALL (gives CSV and SARIF at the same time)

For example:

output:
  file_path: relative/path/to/file
  format: CSV

checks

checks sets the weaknesses that the scanner tries to find. To select them, read the documentation of weaknesses in the classification of Fluid Attacks. This documentation has detailed descriptions. If you do not use this key, the scanner checks the target for all vulnerabilities. Fluid Attacks usually recommends that you do not use this key, to get full scans.

This example checks for F050 (Guessed weak credentials) and F279 (Root detection control bypass):

checks:
  - F050
  - F279

tracing_opt_out

Set tracing_opt_out to true to stop the scanner from sending anonymized telemetry to the servers of Fluid Attacks. The default value is false.

tracing_opt_out: true

strict

strict configures the scan to run in strict mode. In this mode, the execution fails (breaks the build) if the scanner finds one or more vulnerabilities (with an exit code 1). A strictness_threshold or the policy of your group can make the scan fail only on vulnerabilities at or above a severity. Use this mode when you run the scanner as a CI/CD job. To use strict mode, add this key:

strict: true

strictness_threshold

The SAST, SCA, and DAST scanners support strictness_threshold. It sets a minimum severity to break the pipeline. If you configure it, the scan exits with code 1 when it finds a vulnerability at or above the level that you set. In an authenticated SAST or SCA scan, the lower of this threshold and the minimum CVSS score of your group applies. The correct values are none, low, medium, high, and critical.

strictness_threshold: high

For example, strictness_threshold: high breaks the pipeline only when the scanner finds a high or critical vulnerability. The scanner also reports the low and medium vulnerabilities, but they do not stop the execution, unless the minimum CVSS score of your group is lower.

Specify paths in the include/exclude subsections

In the sast, sca and apk keys, include and exclude read each path as a line of a .gitignore file. The Fluid Attacks platform also reads paths as .gitignore lines when it removes out-of-scope files from the repositories that it downloads. Thus, the same rule selects the same files in include and in exclude, and in the scanner and in the platform. The paths are relative to the working directory. If you do not set the working_dir key, the working directory is the directory where you started the scanner.

You can specify your paths in these ways:

  • With the path of a file or a directory, for example:
namespace: namespace
working_dir: /test/directory
sast:
  include:
    - src/main/java/org/test/Test.java
    - src/main/java/org/test/utils/
  • With patterns, for example:
namespace: namespace
working_dir: /test/directory
sast:
  include:
    - .
  exclude:
    - docs
    - "*.min.js"
    - src/**/test*.py
    - "!src/test_keep.py"

The rules of a .gitignore file apply:

  • A pattern without a slash, like docs or *.min.js, matches at any depth. A pattern with a slash in the middle or at the start, like src/*.py or /docs, is relative to the working directory.
  • A trailing slash, like docs/, matches only directories and all their content.
  • * and ? do not cross a slash. ** does: src/**/test*.py matches src/test_a.py and src/a/b/test_a.py, and **/*.py matches Python files at any depth, including the root of the working directory.
  • [abc] and [a-z] match one character of the set. Escape a bracket with a backslash to match it literally, as in file\[1\].txt. The scanner takes a path that exists in the working directory, like app/[id]/, as a literal path, not as a pattern.
  • A line that starts with ! includes a path again after an earlier rule rejected it. If a rule rejected a full directory, you cannot include a path below it again.
  • The scanner ignores a line that is not a correct pattern and shows a warning. The other lines continue to apply.
  • . selects everything in the working directory. It is the recommended value of include. The scanner does not analyze .git and node_modules.

The scanner continues to accept the glob(...) form. It reads glob(**/*.py) as **/*.py. Use the plain pattern in new configurations.

Fluid Attacks recommends that you scan all the paths of working_dir. To do this, use . in the include option:

sast:
  include:
    - .

Then, read the section of each scanner to know the other keys that it supports:

Authenticate

When you authenticate, Fluid Attacks records the scan in your group. All the Fluid Attacks scanners authenticate each run with a Group token. You can give a short-lived token with OpenID Connect (use --group, and no secret is necessary). You can also give a long-lived INTEGRATES_API_TOKEN secret.

For the configuration, read Authentication.

On this page