The Open Source Security Foundation (OpenSSF) Scorecard is essential for performing automated security checks in open-source projects. However, its standard checks might not address all organizations’ specific security policies and compliance requirements. To overcome this limitation, developers can extend the Scorecard with custom checks by integrating it as a dependency in a Go binary. This method enables organizations to apply their distinctive security standards directly within their development workflows.

Integrating Scorecard as a Dependency

Organizations looking to create custom checks can incorporate the Scorecard as a dependency in their Go projects. They achieve this by importing the Scorecard modules into their Go binary, enabling them to utilize Scorecard’s libraries and functions to craft and execute custom checks.

graph LR
A[Start] --> B[Import Scorecard]
B --> C[Define Custom Checks]
C --> D[Register Checks]
D --> E[Execute Checks]
E --> F{End}

Example: Custom Check for Gradle Wrapper Integrity

To illustrate the importance and application of a custom check, let’s delve into the process of verifying the integrity of the Gradle wrapper JAR file in a repository. This is a critical check because the Gradle wrapper is a key component in many Java-based projects, acting as a script that facilitates the consistent execution of the build.

The Gradle wrapper serves an essential purpose: it automatically downloads the correct version of Gradle, ensuring that the build process is consistent and reliable across different environments. However, this also introduces a potential security risk. If the wrapper is tampered with, it could lead to the execution of malicious code or the introduction of vulnerabilities in the project.

Here’s where the custom check for the integrity of the Gradle wrapper JAR comes into play. By verifying the integrity of the Gradle wrapper, we can ensure that it has not been altered or compromised. This is crucial for maintaining the security and reliability of the build process.

You can see the implementation of this check in the checkGradleWrapperJar function at in main.go.

This example demonstrates how to implement a custom check using Scorecard as a dependency. The function works by iterating through the repository’s files, specifically targeting .jar files. It then calculates the SHA checksum of each file and compares it against a list of known, safe checksums for the Gradle wrapper JAR file. If a checksum doesn’t match, it indicates a potential compromise, and the score for this check is reduced accordingly.

This custom check is vital for projects that rely on Gradle, as it ensures the integrity and security of a critical component of the build process. By integrating such a check into the Scorecard, organizations can automatically and continuously verify the safety of their build tools, significantly reducing the risk of introducing security vulnerabilities through compromised build processes.

Implementation Steps

  1. Import Scorecard Libraries: The Go binary includes imports from the package, which provides the necessary functions and types to interact with the Scorecard framework.

  2. Define Custom Checks: Custom checks, such as checkGradleWrapperJar, are defined within the Go binary. These checks use Scorecard’s types and functions to perform specific security validations.

  3. Register Checks: You register the custom checks with Scorecard’s check runner, which permits their execution as part of the Scorecard suite.

  4. Execute Checks: When you run the Go binary, it initializes the Scorecard checks, incorporating the custom ones, and executes them against the target repository.

Benefits of Using Scorecard as a Dependency

  • Seamless Integration: By using Scorecard as a dependency, you can seamlessly integrate custom checks into the existing Scorecard framework.
  • Consistency: Custom checks benefit from the same output format and scoring system used by standard Scorecard checks, ensuring consistency in reporting.
  • Customization: Organizations can tailor the security checks to their specific needs, going beyond the default checks provided by Scorecard.


Incorporating OpenSSF Scorecard as a dependency in a Go binary is a strategic approach to extending its capabilities with custom checks. This method provides a flexible and powerful way to enhance the security of open-source projects by enforcing specific security policies and compliance standards.

The example of the Gradle wrapper integrity check illustrates just one of the many possibilities that custom checks offer, empowering organizations to maintain a robust security posture tailored to their unique requirements. As the digital landscape continues to evolve, the ability to adapt and address specific security challenges becomes paramount. Thus, custom checks with OpenSSF Scorecard represent a proactive and efficient solution, ensuring that organizations can keep pace with the ever-changing security demands of open-source software development.

Engage with Us

We would love to hear from you! If you’ve implemented custom checks in your projects, please share your experiences and insights in the comments below. Your contributions will help enrich our collective understanding and effectiveness in open-source security. Also, if you have any questions or specific challenges you’d like to discuss regarding integrating custom checks with the OpenSSF Scorecard, feel free to start a conversation. Let’s collaborate to foster a more secure and robust open-source community.