jenkins

Repository on GitHub, which provides public git repositories with URLs.

Repository on GitHub, which uses git. git can track the changes, who made them, and when they were made.

Repository on GitHub, which uses git. git is distributed.

https://github.com/jenkinsci/jenkins/tags

https://jenkins.io/changelog/ , https://jenkins.io/changelog-stable/

All security releases provide links to Security advisories in the changelog. Example: https://jenkins.io/changelog/#v2.197

Jenkins Issue Tracker: https://issues.jenkins-ci.org/ . Project = JENKINS, component = core , query . Some sub-components like Docker packaging also use GitHub Issues as a second way to report issues: https://github.com/jenkinsci/docker/issues .

Jenkins Issue Tracker: https://issues.jenkins.io/ . Project = JENKINS, component = core , query . Some sub-components like Docker packaging also use GitHub Issues as a second way to report issues: https://github.com/jenkinsci/docker/issues

In the Jenkins project we invest in providing better response times in the issue tracker. See the Jenkins issue triage process for information about the current triage process and recommendations.

As of Jul 21, 2020:

• 488 defects were reported to the Jenkins core components in the last 12 months
• 271 defects (55%) have been resolved
• 186 issues (38%) received an initial response and/or explicit confirmation
• 31 defects did not get a response

We plan to introduce a Jenkins Bug Triage team to improve the response times and to ensure that all issues get processed (discussion in the developer mailing list).

At the moment we do not regular triage of the enhancement requests, but we meet the criteria with the informal process. As of Jul 21, 2020, 203 issues were reported in the last 2-12 months (inclusinve), 105 of them (or 52%) have been already resolved or closed. The majority of other requests submitted users and non-core contributors got initial response. Issue query

Jenkins Issue Tracker: https://issues.jenkins-ci.org/

https://jenkins.io/security/#reporting-vulnerabilities

https://jenkins.io/security/#reporting-vulnerabilities

Vulnerability report are monitored by the Jenkins Security Team. This team monitors all incoming requests which are submitted according to the vulnerability reporting guidelines. For Jenkins core the security team handles the reports on its own, and the response time is usually less than 24 hours.

https://ci.jenkins.io/ , https://github.com/jenkinsci/jenkins/blob/master/CONTRIBUTING.md#building-and-debugging

We use Maven: https://github.com/jenkinsci/jenkins/blob/master/CONTRIBUTING.md#building-and-debugging

Jenkins project includes unit and functional tests inside the main repository. In addition, there is a Jenkins Acceptance Test Harness test suite

Jenkins Core unit and integration test suites can be invoked using the standard Maven Surefire Plugin. JavaScript unit tests can be launched via YARN. See Jenkins Core - Testing Changes for more information.

Acceptance Test Harness tests can be invoked using the standard Maven Surefire Plugin, the test repository is located in jenkinsci/acceptance-test-harness/

We use Jenkins-on-Jenkins: https://ci.jenkins.io/

It is a part of our Pull Request Template requirements

See the pull request history. Examples for major improvements

It is a part of our Pull Request Template requirements

Our Jenkins core and library Parent POM includes standard static analysis tools like SpotBugs, Animal Sniffer, Maven Enforcer (for dependency and binary API checks), etc. Same applies to the plugin POM.

Jenkins core, modules and libraries address all high-severity warnings and acknowledge a number of medium-severity warnings which is within the "1 warning per 100 lines" requirement. There is ongoing project to cleanup the Jenkins core warnings entirely ([JENKINS-36716])(https://issues.jenkins-ci.org/browse/JENKINS-36716).

Jenkins uses high and medium thresholds for static analysis warnings. ([JENKINS-36716])(https://issues.jenkins.io/browse/JENKINS-36716) intends to implement and maintain higher code quality standards.
The Jenkins project does not accept pull requests with Spotless, Spotbugs, Checkstyle, ESLint or Stylelint warnings.

The Jenkins project has a Security Team which includes several Jenkins core maintainers with experience working on security issues. Some of these contributors work professionally as security engineers and regularly implement and review software designs to ensure high security standards.

The Jenkins project has a Security Team which includes several Jenkins developers who have experience with working on security issues and provide documentation for other Jenkins developers how to address common vulnerabilities. Jenkins core maintainers and the release team are also represented on the Security team.

The Jenkins project uses standard open-source implementations of cryptographic protocols and algorithms (e.g. implemented by JVM, Bouncy Castle, MINA SSH, and other open-source libraries like eddsa for its Ed25519 implementation). There are also standard APIs offered to the plugin developers (e.g. for storing secrets).

The Jenkins core and its modules do not implement cryptography on their own in recent versions. They depend on open-source libraries which provide cryptography functions. There are historical cryptography APIs offered in Jenkins, but their internal implementations have been replaced by open-source cryptography libraries used in the project.

Additional notes about previous releases that are no longer supported:

• Jenkins Remoting layer used to implement encryption on its own in the JNLP3 protocol. This protocol was deprecated in Dec 2017 (Remoting 3.15) and then completely removed from the codebase in Dec 2019 (Remoting 3.40)
• The Jenkins core used to include cryptography implementations, e.g. a Jenkins-specific fork of the abandoned Trilead SSH library. It was removed from Jenkins 2.186 in July 2019 and is only included as detached plugin for backward compatibility with plugins depending on it, but not used by Jenkins itself.

Jenkins core is fully FLOSS, as well as its dependencies.

The Jenkins core generally does not manage the key lengths in the codebase. We use the default values provided by the recent versions of cryptography libraries. One of the exceptions is a CryptoConfidentialKey used in hudson.util.Secret and a few other locations. These occurrences use AES 128 by default, and it is compliant with the length requirement for symmetric keys.

We do NOT use broken cryptography algorithms for security mechanisms inside the Jenkins core or modules. In some cases MD5 is used to produce unique keys for Jenkins objects which are not used in a security context. Such objects have soft uniqueness requirements, and potential collisions do not compromise the Jenkins security or sensitive data.

Jenkins core generally does not rely on SHA-1 for security purposes. The only security-related use of SHA-1 in the Jenkins core is related to the validation of downloaded plugins and Jenkins .war files from update sites. This is only used as a fallback if the update site does not provide SHA-256 or SHA-512 checksums, and a warning is logged. Official Jenkins update sites have provided these better checksums since April 2018, so this only matters for third-party unofficial update sites, and only if downloads are not delivered via HTTPS.

CBC mode is not used by the Jenkins core, and the algorithm is removed from the SSHD Module which implements the SSH server side logic in Jenkins.

Note: In some cases we use AES encryption with default settings provided by JVM, without explicit padding and mode specification. This results in ECB usage in some circumstances in the case of the default JVM configuration. ECB is not optimal due to data correlation analysis weakness, but it is not considered as a serious weakness for short data objects. Jenkins users have an option to change the JVM defaults to enforce strong cryptography and other default AES modes.

In the majority of use-cases we use the default forward secrecy provided by 3rd-party open-source libraries (e.g. for establishing SSH connections). Same for HTTPS, the entire implementation is supplied by external libraries or projects (e.g. Eclipse Jetty bundled in the Jenkins core and used as a default web container).

The only exception is the Jenkins Remoting library that includes an implementation of the JNLP4-connect protocol for networking between the Jenkins server and agents. This protocol uses the standard TLS encryption layer provided by JVM (default version). As of Jenkins 2.235.1 LTS Jenkins supports Java 8 (TLS 1.2 by default, no TLS 1.3 implementation in OpenJDK) and Java 11 (TLS 1.2 or 1.3 are provided). TLS 1.2 does not enforce perfect forward secrecy by default, but users of Jenkins can enforce TLS 1.3 and forward secrecy with OpenJDK 11 or with other JVMs for Java 8/11. Jenkins admins can also elect to block the JNLP4-connect protocol over TCP, and to use the WebSocket connection over HTTP/HTTPS, in which case the encryption is delegated to the web server and reverse proxies.

In Jenkins we provide a private security realm which stores password hashes in the local filesystem database. This implementation uses BCrypt, and hence it is compatible with the requirements. It is also possible to use external authentication services (e.g. LDAP) which do not store user passwords in Jenkins. Jenkins Security Realm documentation

In the Jenkins core and modules we use the standard secure random number generator provided by the JVM. There are no custom implementations within the codebase.

The Jenkins project uses HTTPS for the entire infrastructure and delivery mechanisms with the exception of Update Center Mirrors (tracked as INFRA-266). Mirrors are used to deliver Jenkins core, native packages and plugin binaries.

• For the Jenkins WAR file distributions, checksums for current releases can be retrieved from the https://jenkins.io/download/ page. Additionally, the war files are signed and can be checked using jarsigner.
• All official Jenkins native packages and installers are signed by the project, and this signature can be verified upon delivery by using a package manager.
• To ensure that the delivered plugins are not tampered, the Jenkins project provides SHA-256 checksums which are accessible over HTTPS from the Update Center JSON file which is retrieved over HTTPS in the default configuration. In addition to that, the JSON file itself is signed using SHA-512. Jenkins verifies the checksums upon download of plugins in the update center client logic.

Jenkins users can also set up a pure HTTPS delivery for all Jenkins artifacts by deploying their own update center by using the update center generator provided by the Jenkins project. This generator downloads all artifacts and metadata from the Jenkins Maven repository over HTTPS.

In addition to plugins and distributions, Jenkins update sites also list downloadable tools supplied by plugins (e.g. Maven, Gradle, AdoptOpenJDK). These tools are downloaded from external locations which may not implement the secure delivery chain as we depend on other projects serving files securely (tracked as JENKINS-55659). Such tool downloads are opt-in, none of the tools are enabled and installed by default. The Jenkins project does not provide guarantees for external tool downloads.

Jenkins cryptographic hashes are retrieved over HTTPS from the Jenkins Maven repository. Checksums are also accessible over HTTPS from the Update Center JSON file which is retrieved over HTTPS by default (since 2017) and additionally, a signature for itself in a canonical form is included and verified by Jenkins.

There are no such vulnerabilities in the Jenkins Core and modules. While we strive to keep library dependencies updated, some dependencies included in the Jenkins core have known vulnerabilities. In such cases, we determine whether these vulnerabilities are exploitable in Jenkins, and if so, address them. Otherwise we do not consider these to be vulnerabilities in Jenkins.

There are some unpatched vulnerabilities in plugins as listed in security advisories, but plugins are not in the scope for this certification. In the case of high severity issues the plugins are usually delisted from the Jenkins update centers. In all cases, warnings are presented to administrators of Jenkins instances that have plugins with publicly known vulnerabilities installed.

Critical vulnerabilities in the Jenkins core are handled by the Jenkins Security Team. This team reviews all incoming reports and prioritizes and fixes them. Critical vulnerabilities are prioritized as a top priority, and additional subject-matter experts may be involved if needed. For example, in 2015 the Jenkins project was able to analyze and fix the public class deserialization attack disclosure earlier than all other affected projects/vendors. In addition to that, we published a mitigation guide within less than 24 hours after the announcement.

The Jenkins core repository or other public repositories do not include any credentials in plain text.

We use SpotBugs, Animal Sniffer, Maven Enforcer Plugin as a part of the build/release pipelines

Jenkins project is being regularly scanned by various static analysis tools, including tools like Snyk or Anchore. GitHub Security is also used for dependency scanning and reporting. Also, Jenkins users regularly run static code analysis tools against the codebase/distributions and then report the results. In addition to that, there is ongoing discussion about including FindSecBugs detectors into standard Pipelines.

In the Jenkins core there were several security issues reported by dependency scanning tools. They were timely analyzed and fixed if the vulnerability was confirmed. So far we did not get any confirmed medium/high severity vulnerabilities reported by a static code analysis tool.

Jenkins plugins are not in the scope for this certification

We use SpotBugs, Animal Sniffer, Maven Enforcer Plugin as a part of the build/release pipelines

Jenkins project does not include code written using a memory-unsafe language. We use some 3rd-party dependencies which include native code, e.g. Windows Process Management Library written in C. This library is provided by a third party, and it is not in the scope for this certification.

Jenkins project does not use dynamic analysis tools as a part of the CI/CD pipeline. On the other hand, Jenkins instances produce run-time events (logs, metrics, etc.) which are exposed to monitoring tools and can be used for dynamic analysis

We do not use dynamic analysis tools as a part of our CI/CD pipeline