Dependency scanning

{{< details >}}

• Tier: Ultimate
• Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated

{{< /details >}}

[!warning] The dependency scanning feature based on the Gemnasium analyzer is deprecated in GitLab 17.9 and is proposed for removal in GitLab 20.0. However, the removal timeline is not finalized, and you can continue using Gemnasium as needed. For more information, see epic 15961.

Dependency scanning integrates into your CI/CD pipelines, and runs automatically to identify security vulnerabilities in your application's dependencies. By scanning branches before they merge, you have immediate visibility of security issues in merge requests. This can help you make informed decisions about potential vulnerabilities before merging your code.

By default, dependency scanning analyzes all dependencies in your code, including runtime, development, and transitive (nested) dependencies. You can optionally exclude development dependencies from scanning.

• <i class="fa-youtube-play" aria-hidden="true"></i> For an overview, see Dependency scanning - Advanced Security Testing<!-- Video published on 2024-04-06 -->
• <i class="fa-youtube-play" aria-hidden="true"></i> For an interactive reading and how-to demo of this dependency scanning documentation, see How to use dependency scanning tutorial hands-on GitLab Application Security part 3<!-- Video published on 2023-09-19 -->
• <i class="fa-youtube-play" aria-hidden="true"></i> For other interactive reading and how-to demos, see Get Started With GitLab Application Security Playlist<!-- Video published on 2023-09-19 -->

For vulnerability scanning of dependencies outside a pipeline, see continuous vulnerability scanning.

Turn on dependency scanning

Follow these steps to turn on dependency scanning in your project.

To enable the analyzer, either:

• Enable Auto DevOps, which includes dependency scanning.
• Use a preconfigured merge request.
• Create a scan execution policy that enforces dependency scanning.
• Edit the .gitlab-ci.yml file manually.
• Use CI/CD components

Use a preconfigured merge request

This method automatically prepares a merge request that includes the dependency scanning template in the .gitlab-ci.yml file. You then merge the merge request to enable dependency scanning.

[!note] This method works best with no existing .gitlab-ci.yml file, or with a minimal configuration file. If you have a complex GitLab configuration file it might not be parsed successfully, and an error might occur. In that case, use the manual method instead.

Prerequisites:

• The Maintainer or Owner role for the project.
• The test stage is required in the .gitlab-ci.yml file.
• For self-managed runners, GitLab Runner with the docker or kubernetes executor.
• For hosted runners on GitLab.com, this configuration is enabled by default.

To turn on dependency scanning:

1. In the top bar, select Search or go to and find your project.
2. Select Secure > Security configuration.
3. In the Dependency Scanning row, select Configure with a merge request.
4. Select Create merge request.
5. Review the merge request, then select Merge.

Pipelines now include a dependency scanning job.

Edit the .gitlab-ci.yml file manually

This method requires you to manually edit the existing .gitlab-ci.yml file. Use this method if your GitLab CI/CD configuration file is complex.

Prerequisites:

• The Maintainer or Owner role for the project.
• The test stage is required in the .gitlab-ci.yml file.
• For self-managed runners, GitLab Runner with the docker or kubernetes executor.
• For hosted runners on GitLab.com, this configuration is enabled by default.

To turn on dependency scanning:

1. In the top bar, select Search or go to and find your project.

2. Select Build > Pipeline editor.

3. If no .gitlab-ci.yml file exists, select Configure pipeline, then delete the example content.

4. Copy and paste the following to the bottom of the .gitlab-ci.yml file. If an include line already exists, add only the template line below it.

   yamlCopy

   include:
     - template: Jobs/Dependency-Scanning.gitlab-ci.yml
   

5. Select the Validate tab, then select Validate pipeline.

   The message Simulation completed successfully confirms the file is valid.

6. Select the Edit tab.

7. Complete the fields. Do not use the default branch for the Branch field.

8. Select the Start a new merge request with these changes checkbox, then select Commit changes.

9. Complete the fields according to your standard workflow, then select Create merge request.

10. Review and edit the merge request according to your standard workflow, then select Merge.

Pipelines now include a dependency scanning job.

Use CI/CD components

{{< history >}}

• Introduced in GitLab 17.0. This feature is an experiment.
• The dependency scanning CI/CD component only supports Android projects.

{{< /history >}}

Use CI/CD components to perform dependency scanning of your application. For instructions, see the respective component's README file.

Available CI/CD components

See https://gitlab.com/explore/catalog/components/dependency-scanning

After completing these steps, you can:

• Learn more about how to understand the results.
• Plan a roll out to more projects.

Understanding the results

Dependency scanning results are available in multiple formats. View them directly in the pipeline UI, in the detailed scanning report, or in the Software Bill of Materials (SBOM) generated during the scan.

Review vulnerabilities in the pipeline

Review vulnerabilities detected in your pipeline and take action before your merge request is merged.

Prerequisites:

• The Developer, Maintainer, or Owner role for the project.

To review dependency scanning results in a pipeline:

1. In the top bar, select Search or go to and find your project.
2. In the left sidebar, select Build > Pipelines.
3. Select the pipeline.
4. Select the Security tab.
5. Select a vulnerability to view its details, including:
   • Status: Indicates whether the vulnerability has been triaged or resolved.
   • Description: Explains the cause of the vulnerability, its potential impact, and recommended remediation steps.
   • Severity: Categorized into six levels based on impact. Learn more about severity levels.
   • CVSS score: Provides a numeric value that maps to severity.
   • EPSS: Shows the likelihood of a vulnerability being exploited in the wild.
   • Has Known Exploit (KEV): Indicates that a given vulnerability has been exploited.
   • Project: Highlights the project where the vulnerability was identified.
   • Report type / Scanner: Explains the output type and scanner used to generate the output.
   • Reachable: Provides an indication whether the vulnerable dependency is used in code.
   • Scanner: Identifies which analyzer detected the vulnerability.
   • Location: Names the file where the vulnerable dependency is located.
   • Links: Evidence of the vulnerability being cataloged in various advisory databases.
   • Identifiers: A list of references used to classify the vulnerability, such as CVE identifiers.

Dependency scanning report

Dependency scanning outputs a report containing details of all vulnerabilities. The report is processed internally and the results are shown in the UI. The report is also output as an artifact of the dependency scanning job, named gl-dependency-scanning-report.json, and is always generated at the root of the project.

For more details of the dependency scanning report, see the Dependency scanning report schema.

CycloneDX Software Bill of Materials

Dependency scanning outputs a CycloneDX Software Bill of Materials (SBOM) for each supported lockfile or build file it detects.

The CycloneDX SBOMs are:

• Named gl-sbom-<package-type>-<package-manager>.cdx.json.
• Available as job artifacts of the dependency scanning job.
• Saved in the same directory as the detected lockfile or build files.

For example, if your project has the following structure:

.
├── ruby-project/
│   └── Gemfile.lock
├── ruby-project-2/
│   └── Gemfile.lock
├── php-project/
│   └── composer.lock
└── go-project/
    └── go.sum

Then the Gemnasium scanner generates the following CycloneDX SBOMs:

.
├── ruby-project/
│   ├── Gemfile.lock
│   └── gl-sbom-gem-bundler.cdx.json
├── ruby-project-2/
│   ├── Gemfile.lock
│   └── gl-sbom-gem-bundler.cdx.json
├── php-project/
│   ├── composer.lock
│   └── gl-sbom-packagist-composer.cdx.json
└── go-project/
    ├── go.sum
    └── gl-sbom-go-go.cdx.json

Roll out

After you are confident in the dependency scanning results for a single project, you can extend its implementation to additional projects:

• Use enforced scan execution to apply dependency scanning settings across groups.
• If you have unique requirements, dependency scanning with SBOM can be run in offline environments.

Supported languages and package managers

[!note] Dependency scanning does not support runtime installation of compilers and interpreters.

The following languages and dependency managers are supported by dependency scanning:

Footnotes:

1. Java 21 LTS for sbt is limited to version 1.9.7. Support for more sbt versions can be tracked in issue 430335. It is not supported when FIPS mode is enabled.
2. Gradle is not supported when FIPS mode is enabled.
3. pnpm lockfiles do not store bundled dependencies, so the reported dependencies may differ from npm or yarn.
4. Support for projects without a poetry.lock file is tracked in issue 32774.
5. Support for sbt 1.0.x was deprecated in GitLab 16.8 and removed in GitLab 17.0.
6. Support for Maven below 3.8.8 was deprecated in GitLab 16.9 and removed in GitLab 17.0.
7. Support for prior Python versions was deprecated in GitLab 16.9 and removed in GitLab 17.0.
8. Excludes both pip and setuptools from the report as they are required by the installer.
9. Only SBOM, without advisories. See issue 468764.
10. No license detection. See epic 17037.
11. If a lockfile contains multiple entries for the same package with different environment markers (for example, numpy==2.2.6 for Python <3.11 and numpy==2.4.1 for Python ≥3.11), only the first entry is parsed and reported.

Supported development dependencies

Detection of development dependencies is supported for the following languages and package managers:

Running jobs in merge request pipelines

See Use security scanning tools with merge request pipelines

Customizing analyzer behavior

To customize dependency scanning, use CI/CD variables.

[!warning] Test all customization of GitLab analyzers in a merge request before merging these changes to the default branch. Failure to do so can give unexpected results, including a large number of false positives.

Overriding dependency scanning jobs

To override a job definition (for example, to change properties like variables or dependencies), declare a new job with the same name as the one to override. Place this new job after the template inclusion and specify any additional keys under it.

For example, this disables automatic remediation of vulnerable dependencies for the gemnasium analyzer:

include:
  - template: Jobs/Dependency-Scanning.gitlab-ci.yml

gemnasium-dependency_scanning:
  variables:
    DS_REMEDIATE: "false"

To override the dependencies: [] attribute, add an override job as described previously, targeting this attribute:

include:
  - template: Jobs/Dependency-Scanning.gitlab-ci.yml

gemnasium-dependency_scanning:
  dependencies: ["build"]

Available CI/CD variables

You can use CI/CD variables to customize dependency scanning behavior.

Global analyzer settings

The following variables allow configuration of global dependency scanning settings.

Analyzer-specific settings

The following variables configure the behavior of specific dependency scanning analyzers.

Other variables

The previous tables are not an exhaustive list of all variables that can be used. They contain all specific GitLab and analyzer variables that are supported and tested. Many other variables, such as environment variables, can be passed in and work correctly. This list is large and not fully documented.

For example, to pass the non-GitLab environment variable HTTPS_PROXY to all dependency scanning jobs, set it as a CI/CD variable in your .gitlab-ci.yml file like this:

variables:
  HTTPS_PROXY: "https://squid-proxy:3128"

[!note] Gradle projects require an additional variable set up to use a proxy.

Alternatively it may be used in specific jobs, like dependency scanning:

dependency_scanning:
  variables:
    HTTPS_PROXY: $HTTPS_PROXY

Because all variables have not been tested, you may find that some work and others do not. If you need one that does not work, submitting a feature request or contribute to the code to enable it to be used.

Custom TLS certificate authority

Dependency scanning allows for use of custom TLS certificates for SSL/TLS connections instead of the default shipped with the analyzer container image.

Support for custom certificate authorities was introduced in the following versions.

Use a custom TLS certificate authority

Prerequisites:

• The Maintainer or Owner role for the project.

To use a custom TLS certificate authority:

• Assign the text representation of the X.509 PEM public-key certificate to the CI/CD variable ADDITIONAL_CA_CERT_BUNDLE.

For example, to configure the certificate in the .gitlab-ci.yml file:

variables:
  ADDITIONAL_CA_CERT_BUNDLE: |
      -----BEGIN CERTIFICATE-----
      MIIGqTCCBJGgAwIBAgIQI7AVxxVwg2kch4d56XNdDjANBgkqhkiG9w0BAQsFADCB
      ...
      jWgmPqF3vUbZE0EyScetPJquRFRKIesyJuBFMAs=
      -----END CERTIFICATE-----

Authenticate with a private Maven repository

To allow the dependency analyzer to authenticate with a private Maven repository, you must configure credentials in the CI/CD pipeline. Without authentication, the dependency analyzer cannot access private dependencies, and the scan will fail.

[!warning] Do not add the credentials to your .gitlab-ci.yml file.

Prerequisites:

• The Maintainer or Owner role for the project.

To allow the dependency analyzer to authenticate with a private Maven repository:

1. Create a project CI/CD variable named MAVEN_CLI_OPTS, and set its value to include your credentials.

   For example, assuming a settings file named mysettings.xml, username of myuser, and password of verysecret, you would set the MAVEN_CLI_OPTS CI/CD variable to the following:

   --settings mysettings.xml -Drepository.password=verysecret -Drepository.user=myuser

2. Create the mysettings.xml Maven settings file with your server configuration. The filename must match the value you specified in the --settings option in step 1.

   xmlCopy

   <!-- mysettings.xml -->
   <settings>
       ...
       <servers>
           <server>
               <id>private_server</id>
               <username>${repository.user}</username>
               <password>${repository.password}</password>
           </server>
       </servers>
   </settings>
   

FIPS-enabled images

GitLab also offers FIPS-enabled Red Hat UBI versions of the Gemnasium images. When FIPS mode is enabled in the GitLab instance, Gemnasium scanning jobs automatically use the FIPS-enabled images. To manually switch to FIPS-enabled images, set the variable DS_IMAGE_SUFFIX to "-fips".

Dependency scanning for Gradle projects and auto-remediation for Yarn projects are not supported in FIPS mode.

FIPS-enabled images are based on RedHat's UBI micro. They don't have package managers such as dnf or microdnf so it's not possible to install system packages at runtime.

Offline environment

{{< details >}}

• Tier: Ultimate
• Offering: GitLab Self-Managed

{{< /details >}}

For instances in an environment with limited, restricted, or intermittent access to external resources through the internet, some adjustments are required for dependency scanning jobs to run successfully. For more information, see Offline environments.

Prerequisites:

• Administrator access.
• A GitLab Runner with the docker or kubernetes executor
• Local copies of the dependency scanning analyzer images
• Access to the GitLab advisory database
• Access to the Package Metadata Database

Local copies of analyzer images

To use dependency scanning with all supported languages and frameworks:

1. Import the following default dependency scanning analyzer images from registry.gitlab.com into your local Docker container registry:

   plaintextCopy

   registry.gitlab.com/security-products/gemnasium:6
   registry.gitlab.com/security-products/gemnasium:6-fips
   registry.gitlab.com/security-products/gemnasium-maven:6
   registry.gitlab.com/security-products/gemnasium-maven:6-fips
   registry.gitlab.com/security-products/gemnasium-python:6
   registry.gitlab.com/security-products/gemnasium-python:6-fips
   

   The process for importing Docker images into a local offline Docker registry depends on your network security policy. Consult your IT staff to find an accepted and approved process by which external resources can be imported or temporarily accessed. These scanners are periodically updated with new definitions, and you may want to download them regularly.

2. Configure GitLab CI/CD to use the local analyzers.

   Set the value of the CI/CD variable SECURE_ANALYZERS_PREFIX to your local Docker registry - in this example, docker-registry.example.com.

   yamlCopy

   include:
     - template: Jobs/Dependency-Scanning.gitlab-ci.yml
   
   variables:
     SECURE_ANALYZERS_PREFIX: "docker-registry.example.com/analyzers"
   

Access to the GitLab advisory database

The GitLab advisory database is the source of vulnerability data used by the gemnasium, gemnasium-maven, and gemnasium-python analyzers. The Docker images of these analyzers include a clone of the database. The clone is synchronized with the database before starting a scan, to ensure the analyzers have the latest vulnerability data.

In an offline environment, the default host of the GitLab advisory database can't be accessed. Instead, you must host the database somewhere that it is accessible to the GitLab runners. You must also update the database manually at your own schedule.

Available options for hosting the database are:

• Use a clone of the GitLab advisory database.
• Use a copy of the GitLab advisory database.

Use a clone of the GitLab advisory database

Using a clone of the GitLab advisory database is recommended because it is the most efficient method.

To host a clone of the GitLab advisory database:

1. Clone the GitLab advisory database to a host that is accessible by HTTP from the GitLab runners.
2. In your .gitlab-ci.yml file, set the value of the CI/CD variable GEMNASIUM_DB_REMOTE_URL to the URL of the Git repository.

For example:

variables:
  GEMNASIUM_DB_REMOTE_URL: https://users-own-copy.example.com/gemnasium-db.git

Use a copy of the GitLab advisory database

Using a copy of the GitLab advisory database requires you to host an archive file which is downloaded by the analyzers.

To use a copy of the GitLab advisory database:

1. Download an archive of the GitLab advisory database to a host that is accessible by HTTP from the GitLab runners. The archive is located at https://gitlab.com/gitlab-org/security-products/gemnasium-db/-/archive/master/gemnasium-db-master.tar.gz.

2. Update your .gitlab-ci.yml file.

   • Set CI/CD variable GEMNASIUM_DB_LOCAL_PATH to use the local copy of the database.
   • Set CI/CD variable GEMNASIUM_DB_UPDATE_DISABLED to disable the database update.
   • Download and extract the advisory database before the scan begins.
   yamlCopy

   variables:
     GEMNASIUM_DB_LOCAL_PATH: ./gemnasium-db-local
     GEMNASIUM_DB_UPDATE_DISABLED: "true"
   
   dependency_scanning:
     before_script:
       - wget https://local.example.com/gemnasium_db.tar.gz
       - mkdir -p $GEMNASIUM_DB_LOCAL_PATH
       - tar -xzvf gemnasium_db.tar.gz --strip-components=1 -C $GEMNASIUM_DB_LOCAL_PATH
   

Use a proxy with Gradle projects

The Gradle wrapper script does not read the HTTP(S)_PROXY environment variables. For more details, see Gradle issue 11065.

Prerequisites:

• The Maintainer or Owner role for the project.

To make the Gradle wrapper script use a proxy:

• Specify the proxy options by using the GRADLE_CLI_OPTS CI/CD variable:

  yamlCopy

  variables:
    GRADLE_CLI_OPTS: "-Dhttps.proxyHost=squid-proxy -Dhttps.proxyPort=3128 -Dhttp.proxyHost=squid-proxy -Dhttp.proxyPort=3128 -Dhttp.nonProxyHosts=localhost"
  

Use a proxy with Maven projects

Maven does not read the HTTP(S)_PROXY environment variable. You must instead use a Maven settings file.

Prerequisites:

• The Maintainer or Owner role for the project.

To configure the Maven dependency scanner to use a proxy:

1. Create a mysettings.xml file in the project's repository. Configure the Maven proxy settings in that file.

   For details on how to specify the proxy configuration, see the Maven documentation.

2. Define the MAVEN_CLI_OPTS CI/CD variable in your project's .gitlab-ci.yml file to reference the settings file mysettings.xml.

   yamlCopy

   variables:
     MAVEN_CLI_OPTS: "--settings mysettings.xml"
   

Specific settings for languages and package managers

See the following sections for configuring specific languages and package managers.

Python (pip)

If you need to install Python packages before the analyzer runs, you should use pip install --user in the before_script of the scanning job. The --user flag causes project dependencies to be installed in the user directory. If you do not pass the --user option, packages are installed globally, and they are not scanned and don't show up when listing project dependencies.

Python (setuptools)

If you need to install Python packages before the analyzer runs, you should use python setup.py install --user in the before_script of the scanning job. The --user flag causes project dependencies to be installed in the user directory. If you do not pass the --user option, packages are installed globally, and they are not scanned and don't show up when listing project dependencies.

When using self-signed certificates for your private PyPi repository, no extra job configuration (aside from the previous .gitlab-ci.yml template) is needed. However, you must update your setup.py to ensure that it can reach your private repository. Here is an example configuration:

1. Update setup.py to create a dependency_links attribute pointing at your private repository for each dependency in the install_requires list:

   pythonCopy

   install_requires=['pyparsing>=2.0.3'],
   dependency_links=['https://pypi.example.com/simple/pyparsing'],
   

2. Fetch the certificate from your repository URL and add it to the project:

   shellCopy

   printf "\n" | openssl s_client -connect pypi.example.com:443 -servername pypi.example.com | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' > internal.crt
   

3. Point setup.py at the newly downloaded certificate:

   pythonCopy

   import setuptools.ssl_support
   setuptools.ssl_support.cert_paths = ['internal.crt']
   

Python (Pipenv)

If running in a limited network connectivity environment, you must configure the PIPENV_PYPI_MIRROR variable to use a private PyPi mirror. This mirror must contain both default and development dependencies.

variables:
  PIPENV_PYPI_MIRROR: https://pypi.example.com/simple

Alternatively, if it's not possible to use a private registry, you can load the required packages into the Pipenv virtual environment cache. For this option, the project must check in the Pipfile.lock into the repository, and load both default and development packages into the cache. See the example python-pipenv project for an example of how this can be done.

Dependency detection

Dependency scanning automatically detects the languages used in the repository. All analyzers matching the detected languages are run. There is usually no need to customize the selection of analyzers. Do not specify the analyzers so you automatically use the full selection for best coverage, and avoid the need to make adjustments when there are deprecations or removals. However, you can override the selection using the variable DS_EXCLUDED_ANALYZERS.

The language detection relies on CI job rules to detect supported dependency file

For Java and Python, when a supported dependency file is detected, dependency scanning attempts to build the project and execute some Java or Python commands to get the list of dependencies. For all other projects, the lockfile is parsed to obtain the list of dependencies without needing to build the project first.

All direct and transitive dependencies are analyzed, without a limit to the depth of transitive dependencies.

Analyzers

Dependency scanning supports the following official Gemnasium-based analyzers:

• gemnasium
• gemnasium-maven
• gemnasium-python

The analyzers are published as Docker images, which dependency scanning uses to launch dedicated containers for each analysis. You can also integrate a custom security scanner.

Each analyzer is updated as new versions of Gemnasium are released.

How analyzers obtain dependency information

GitLab analyzers obtain dependency information using one of the following two methods:

1. Parsing lockfiles directly.
2. Running a package manager or build tool to generate a dependency information file which is then parsed.

Obtaining dependency information by parsing lockfiles

The following package managers use lockfiles that GitLab analyzers are capable of parsing directly:

Footnotes:

1. Support for NuGet version 2 lockfiles was introduced in GitLab 16.2.

2. Support for Yarn version 4 was introduced in GitLab 16.11.

   The following features are not supported for Yarn Berry:

   • Workspaces
   • yarn patch

   Yarn files that contain a patch, a workspace, or both, are still processed, but these features are ignored.

Obtaining dependency information by running a package manager to generate a parsable file

To support the following package managers, the GitLab analyzers proceed in two steps:

1. Execute the package manager or a specific task, to export the dependency information.
2. Parse the exported dependency information.

Footnotes:

1. This test uses the default version of maven specified by the .tool-versions file.
2. Different versions of Java require different versions of Gradle. The versions of Gradle listed in the previous table are pre-installed in the analyzer image. The version of Gradle used by the analyzer depends on whether your project uses a gradlew (Gradle wrapper) file or not:

   • If your project does not use a gradlew file, then the analyzer automatically switches to one of the pre-installed Gradle versions, based on the version of Java specified by the DS_JAVA_VERSION variable (default version is 17).

     For Java versions 8 and 11, Gradle 6.7.1 is automatically selected, Java 17 uses Gradle 7.6.4, and Java 21 uses Gradle 8.8.

   • If your project does use a gradlew file, then the version of Gradle pre-installed in the analyzer image is ignored, and the version specified in your gradlew file is used instead.

3. This test confirms that if a Pipfile.lock file is found, it is used by Gemnasium to scan the exact package versions listed in this file.
4. Because of the implementation of go build, the Go build process requires network access, a pre-loaded mod cache using go mod download, or vendored dependencies. For more information, refer to the Go documentation on compiling packages and dependencies.

How analyzers are triggered

GitLab relies on rules:exists to start the relevant analyzers for the languages detected by the presence of the supported files in the repository. A maximum of two directory levels from the repository's root is searched. For example, the gemnasium-dependency_scanning job is enabled if a repository contains either Gemfile, api/Gemfile, or api/client/Gemfile, but not if the only supported dependency file is api/v1/client/Gemfile.

How multiple files are processed

[!note] If you've run into problems while scanning multiple files, contribute a comment to this issue.

Python

GitLab only executes one installation in the directory where either a requirements file or a lockfile has been detected. Dependencies are only analyzed by gemnasium-python for the first file that is detected. Files are searched for in the following order:

1. requirements.txt, requirements.pip, or requires.txt for projects using Pip.
2. Pipfile or Pipfile.lock for projects using Pipenv.
3. poetry.lock for projects using Poetry.
4. setup.py for project using Setuptools.

The search begins with the root directory and then continues with subdirectories if no builds are found in the root directory. Consequently a Poetry lockfile in the root directory would be detected before a Pipenv file in a subdirectory.

Java and Scala

GitLab only executes one build in the directory where a build file has been detected. For large projects that include multiple Gradle, Maven, or sbt builds, or any combination of these, gemnasium-maven only analyzes dependencies for the first build file that is detected. Build files are searched for in the following order:

1. pom.xml for single or multi-module Maven projects.
2. build.gradle or build.gradle.kts for single or multi-project Gradle builds.
3. build.sbt for single or multi-project sbt builds.

The search begins with the root directory and then continues with subdirectories if no builds are found in the root directory. Consequently an sbt build file in the root directory would be detected before a Gradle build file in a subdirectory. For multi-module Maven projects, and multi-project Gradle and sbt builds, sub-module and sub-project files are analyzed if they are declared in the parent build file.

JavaScript

The following analyzers are executed, each of which have different behavior when processing multiple files:

• Gemnasium

  Supports multiple lockfiles

• Retire.js

  Does not support multiple lockfiles. When multiple lockfiles exist, Retire.js analyzes the first lockfile discovered while traversing the directory tree in alphabetical order.

The gemnasium analyzer scans supports JavaScript projects for vendored libraries (that is, those checked into the project but not managed by the package manager).

Go

Multiple files are supported. When a go.mod file is detected, the analyzer attempts to generate a build list using Minimal Version Selection. If this fails, the analyzer instead attempts to parse the dependencies within the go.mod file.

As a requirement, the go.mod file should be cleaned up using the command go mod tidy to ensure proper management of dependencies. The process is repeated for every detected go.mod file.

PHP, C, C++, .NET, C#, Ruby, JavaScript

The analyzer for these languages supports multiple lockfiles.

Support for additional languages

Support for additional languages, dependency managers, and dependency files are tracked in the following issues:

Warnings

Use the most recent version of all containers, and the most recent supported version of all package managers and languages. Using previous versions carries an increased security risk because unsupported versions may no longer benefit from active security reporting and backporting of security fixes.

Gradle projects

Do not override the reports.html.destination or reports.html.outputLocation properties when generating an HTML dependency report for Gradle projects. Doing so prevents dependency scanning from functioning correctly.

Maven Projects

In isolated networks, if the central repository is a private registry (explicitly set with the <mirror> directive), Maven builds may fail to find the gemnasium-maven-plugin dependency. This issue occurs because Maven doesn't search the local repository (/root/.m2) by default and attempts to fetch from the central repository. The result is an error about the missing dependency.

Workaround

To resolve this issue, add a <pluginRepositories> section to your settings.xml file. This allows Maven to find plugins in the local repository.

Before you begin, consider the following:

• This workaround is only for environments where the default Maven central repository is mirrored to a private registry.
• After applying this workaround, Maven searches the local repository for plugins, which may have security implications in some environments. Make sure this aligns with your organization's security policies.

Prerequisites:

• The Maintainer or Owner role for the project.

Follow these steps to modify the settings.xml file:

1. Locate your Maven settings.xml file. This file is typically found in one of these locations:

   • /root/.m2/settings.xml for the root user.
   • ~/.m2/settings.xml for a regular user.
   • ${maven.home}/conf/settings.xml global settings.

2. Check if there's an existing <pluginRepositories> section in the file.

3. If a <pluginRepositories> section already exists, add only the following <pluginRepository> element inside it. Otherwise, add the entire <pluginRepositories> section:

   xmlCopy

     <pluginRepositories>
       <pluginRepository>
           <id>local2</id>
           <name>local repository</name>
           <url>file:///root/.m2/repository/</url>
       </pluginRepository>
     </pluginRepositories>
   

4. Run your Maven build or dependency scanning process again.

Python projects

Extra care needs to be taken when using the PIP_EXTRA_INDEX_URL environment variable due to a possible exploit documented by CVE-2018-20225:

[!warning] An issue was discovered in pip (all versions) because it installs the version with the highest version number, even if the user had intended to obtain a private package from a private index. This only affects use of the PIP_EXTRA_INDEX_URL option, and exploitation requires that the package does not already exist in the public index (and thus the attacker can put the package there with an arbitrary version number).

Version number parsing

In some cases it's not possible to determine if the version of a project dependency is in the affected range of a security advisory.

For example:

• The version is unknown.
• The version is invalid.
• Parsing the version or comparing it to the range fails.
• The version is a branch, like dev-master or 1.5.x.
• The compared versions are ambiguous. For example, 1.0.0-20241502 can't be compared to 1.0.0-2 because one version contains a timestamp while the other does not.

In these cases, the analyzer skips the dependency and outputs a message to the log.

The GitLab analyzers do not make assumptions as they could result in a false positive or false negative. For a discussion, see issue 442027.

Build Swift projects

Swift Package Manager (SPM) is the official tool for managing the distribution of Swift code. It's integrated with the Swift build system to automate the process of downloading, compiling, and linking dependencies.

Follow these best practices when you build a Swift project with SPM.

1. Include a Package.resolved file.

   The Package.resolved file locks your dependencies to specific versions. Always commit this file to your repository to ensure consistency across different environments.

   shellCopy

   git add Package.resolved
   git commit -m "Add Package.resolved to lock dependencies"
   

2. To build your Swift project, use the following commands:

   shellCopy

   # Update dependencies
   swift package update
   
   # Build the project
   swift build
   

3. To configure CI/CD, add these steps to your .gitlab-ci.yml file:

   yamlCopy

   swift-build:
     stage: build
     script:
       - swift package update
       - swift build
   

4. Optional. If you use private Swift package repositories with self-signed certificates, you might need to add the certificate to your project and configure Swift to trust it:

   1. Fetch the certificate:

      shellCopy

      echo | openssl s_client -servername your.repo.url -connect your.repo.url:443 | sed -ne '/-BEGIN CERTIFICATE-/,/-END
      CERTIFICATE-/p' > repo-cert.crt
      

   2. Add these lines to your Swift package manifest (Package.swift):

      swiftCopy

      import Foundation
      
      #if canImport(Security)
      import Security
      #endif
      
      extension Package {
          public static func addCustomCertificate() {
              guard let certPath = Bundle.module.path(forResource: "repo-cert", ofType: "crt") else {
                  fatalError("Certificate not found")
              }
              SecCertificateAddToSystemStore(SecCertificateCreateWithData(nil, try! Data(contentsOf: URL(fileURLWithPath: certPath)) as CFData)!)
          }
      }
      
      // Call this before defining your package
      Package.addCustomCertificate()
      

Always test your build process in a clean environment to ensure your dependencies are correctly specified and resolve automatically.

Build CocoaPods projects

CocoaPods is a popular dependency manager for Swift and Objective-C Cocoa projects. It provides a standard format for managing external libraries in iOS, macOS, watchOS, and tvOS projects.

Follow these best practices when you build projects that use CocoaPods for dependency management.

1. Include a Podfile.lock file.

   The Podfile.lock file is crucial for locking your dependencies to specific versions. Always commit this file to your repository to ensure consistency across different environments.

   shellCopy

   git add Podfile.lock
   git commit -m "Add Podfile.lock to lock CocoaPods dependencies"
   

2. You can build your project with one of the following:

   • The xcodebuild command-line tool:

     shellCopy

     # Install CocoaPods dependencies
     pod install
     
     # Build the project
     xcodebuild -workspace YourWorkspace.xcworkspace -scheme YourScheme build
     

   • The Xcode IDE:

     1. Open your .xcworkspace file in Xcode.
     2. Select your target scheme.
     3. Select Product > Build. You can also press <kbd>⌘</kbd>+<kbd>B</kbd>.

   • fastlane, a tool for automating builds and releases for iOS and Android apps:

     1. Install fastlane:

        shellCopy

        sudo gem install fastlane
        

     2. In your project, configure fastlane:

        shellCopy

        fastlane init
        

     3. Add a lane to your fastfile:

        rubyCopy

        lane :build do
          cocoapods
          gym(scheme: "YourScheme")
        end
        

     4. Run the build:

        shellCopy

        fastlane build
        

   • If your project uses both CocoaPods and Carthage, you can use Carthage to build your dependencies:

     1. Create a Cartfile that includes your CocoaPods dependencies.

     2. Run the following:

        shellCopy

        carthage update --platform iOS
        

3. Configure CI/CD to build the project according to your preferred method.

   For example, using xcodebuild:

   yamlCopy

   cocoapods-build:
     stage: build
     script:
       - pod install
       - xcodebuild -workspace YourWorkspace.xcworkspace -scheme YourScheme build
   

4. Optional. If you use private CocoaPods repositories, you might need to configure your project to access them:

   1. Add the private spec repo:

      shellCopy

      pod repo add REPO_NAME SOURCE_URL
      

   2. In your Podfile, specify the source:

      rubyCopy

      source 'https://github.com/CocoaPods/Specs.git'
      source 'SOURCE_URL'
      

5. Optional. If your private CocoaPods repository uses SSL, ensure the SSL certificate is properly configured:

   • If you use a self-signed certificate, add it to your system's trusted certificates. You can also specify the SSL configuration in your .netrc file:

     netrcCopy

     machine your.private.repo.url
       login your_username
       password your_password
     

6. After you update your Podfile, run pod install to install dependencies and update your workspace.

Remember to always run pod install after updating your Podfile to ensure all dependencies are properly installed and the workspace is updated.

Contributing to the vulnerability database

To find a vulnerability, you can search the GitLab advisory database. You can also submit new vulnerabilities.