GH-500 Questions and Answers

The config-file input is used with the github/codeql-action/init action to specify the path to a custom CodeQL configuration file. This configuration can define additional query packs, custom queries, directories to include or exclude, and other CodeQL analysis settings. GitHub's official workflow documentation shows config-file under the with: section of the CodeQL initialization step. The queries input is used to specify additional query suites or query packs directly, rather than referencing a configuration file. source-root and db-location are not the appropriate init inputs for supplying the configuration-file path. Therefore, when the CodeQL workflow must load settings from a separate YAML configuration file, config-file is the correct parameter.

Query suite definitions in CodeQL are stored using the .qls file extension. A query suite defines a collection of queries to be run during an analysis and allows for grouping them based on categories like language, security relevance, or custom filters.

In contrast:

.ql files are individual queries.

.qll files are libraries used by .ql queries.

.yml is used for workflows, not query suites.

A valid Dependabot configuration requires the top-level version and updates keys. The configuration currently uses version: 2, which identifies the Dependabot configuration syntax. The updates section contains one or more configuration entries describing package ecosystems that Dependabot should monitor. Within each update entry, additional required settings include package-ecosystem, directory or directories, and schedule.interval. The top-level registries key is optional and is used when Dependabot needs authentication information for private registries. assignees is also optional and controls which users are automatically assigned to Dependabot-created pull requests. Therefore, although several other properties may appear in a practical configuration file, only version and updates are mandatory top-level keys among the choices provided.

In a workflow : GitHub Actions workflows are the most common place for CodeQL code scanning. The codeql-analysis.yml defines how the analysis runs and when it triggers.

In an external CI system : GitHub allows you to run CodeQL analysis outside of GitHub Actions. Once complete, the results can be uploaded using the upload-sarif action to make alerts visible in the repository.

You cannot run or trigger analysis from third-party repositories directly, and the Files changed tab in pull requests only shows diff — not analysis results.

Current GitHub documentation requires Write access or higher to list, dismiss, and delete code scanning alerts. The PDF marks Triage, but that is not correct under the current repository-role permissions documented by GitHub. A user with Triage access can view code scanning alerts associated with pull requests, but Triage does not grant the broader permission required to manage the repository's code scanning alert list. Because Write is not one of the supplied choices, Maintain is the lowest listed role that exceeds Write and therefore has the required management capability. Read access does not permit alert management, and “View” is not one of GitHub's standard organization repository roles in this context. Accordingly, based on current official documentation, the technically correct option from the choices provided is B. Maintain.

Requesting a CVE ID for a security advisory in a GitHub repository requires Admin permissions. This level of access is necessary because it involves managing sensitive security information and coordinating with external entities to assign a CVE, which is a formal process that can impact the public perception and security posture of the project.​

The Allow for all organizations policy permits repository administrators throughout organizations owned by the enterprise to enable applicable Advanced Security capabilities on their repositories. GitHub enterprise policy can determine whether repository administrators are allowed to enable GitHub Secret Protection, GitHub Code Security, or legacy GitHub Advanced Security features. Selecting an option limited to chosen organizations would restrict availability rather than permit it enterprise-wide. A prohibition such as Never allow would prevent repository administrators from enabling the feature, while No policy does not explicitly establish the enterprise-wide permission requested. GitHub's current documentation describes this policy as controlling availability across all organizations or specified organizations, with organization owners and security managers retaining broader security-management capabilities. Therefore, B matches the stated requirement to allow repository administrators throughout all enterprise organizations.

Dependency review runs as part of a pull request and shows which dependencies are being added, removed, or changed — and highlights vulnerabilities associated with any added packages.

It works in real-time and is specifically designed for use during pull request workflows.

The dependency graph is an overview, Dependabot alerts notify post-merge, and the Security tab shows the aggregated alert list.

By default, Dependabot creates pull requests without automatically assigning any reviewers, so the correct number is zero. Reviewers can be configured explicitly through Dependabot configuration or assigned through repository mechanisms such as CODEOWNERS. GitHub recommends using appropriate ownership and review processes when particular teams should review dependency updates. This default differs from Dependabot's ability to create pull requests automatically: creating the update does not imply that a reviewer is selected automatically. A repository can customize Dependabot behavior through .github/dependabot.yml, including configuration related to update handling, but in the scenario specified there is no such configuration file. Consequently, no individual reviewer is automatically attached to the Dependabot pull request merely because Dependabot created it.

CodeQL query metadata uses the @kind property to identify the type of result a query produces. For a standard or simple alert, the appropriate metadata value is @kind problem. A path-problem query produces an alert accompanied by a sequence of code locations, which is typically used for data-flow or taint-tracking results. @kind diagnostic is intended primarily for extractor troubleshooting information, while @kind metric is used for summary or measurement-oriented results and normally works with corresponding summary metadata. Correctly defining the query kind allows CodeQL and GitHub code scanning to interpret and display query results appropriately. Because the question asks specifically for a simple alert rather than a path-based, diagnostic, or metric result, @kind problem is correct.

GitHub automatically closes a code scanning alert when the vulnerable code is fixed in the same branch where the alert was generated , usually via a commit inside a pull request . Simply clicking or triaging an alert does not resolve it. The alert is re-evaluated after each push to the branch, and if the issue no longer exists, it is marked as resolved.

Code scanning is a static analysis feature that examines your source code to identify security vulnerabilities and coding errors . It runs either on every push, pull request, or a scheduled time depending on the workflow configuration.

It does not automatically contact maintainers, scan full Git history, or block pushes unless explicitly configured to do so.

Validity checks — where GitHub verifies if a secret is still active — are available for partner patterns only. These are secrets issued by GitHub's trusted partners (like AWS, Slack, etc.) and have APIs for GitHub to validate token activity status.

Custom patterns and high entropy patterns do not support automated validity checks.

Validity checks , also called secret validation , allow GitHub to check if a detected secret is still active . If verified as live, the alert is marked as "valid" , allowing security teams to prioritize the most critical leaks.

Push protection blocks secrets but does not check their validity. Custom patterns are user-defined and do not include live checks.

CodeQL security queries are associated with Common Weakness Enumeration (CWE) classifications. CWE provides standardized categories for classes of software weaknesses, such as improper input validation, path traversal, or SQL injection. GitHub CodeQL query metadata and alert tags can contain CWE identifiers, and GitHub allows code scanning alerts to be filtered by CWE tags. CVEs identify specific publicly disclosed vulnerabilities rather than general weakness categories in source-code analysis. A GHSA identifies a GitHub Security Advisory, while VEX communicates whether a product is affected by a known vulnerability. For CodeQL findings, CWE is therefore the relevant classification system used to describe the type of weakness represented by an alert. GitHub's code scanning API also exposes CodeQL rules containing external/cwe/... tags.

Dependabot alert and advisory details can include a CVE identifier, a GHSA identifier, and associated CWE classifications. CVE provides the standardized identifier for a publicly known vulnerability. GitHub assigns a unique GHSA ID to advisories in the GitHub Advisory Database, while CWE identifies the underlying category or class of software weakness associated with the vulnerability. GitHub's Dependabot alert interface exposes these values when they are available. EPSS is also now surfaced by GitHub and can be used to prioritize alerts, but EPSS is a probability-based exploit-risk score, not one of the three vulnerability identifiers/classifications being tested by this question. SAST describes a security-analysis methodology rather than an advisory classification. Therefore, the intended selections are CVE, GHSA, and CWE: C, D, and E.

The best way to prioritize secret scanning alerts is to filter by active secrets — these are secrets GitHub has confirmed are still valid and could be exploited. This allows security teams to focus on high-risk exposures that require immediate attention.

Sorting by time or filtering by custom patterns won’t help with risk prioritization directly.

When integrating CodeQL outside of GitHub Actions (e.g., in Jenkins, CircleCI):

Install the CLI : Needed to run CodeQL commands.

Analyze code : Perform the CodeQL analysis on your project with the CLI.

Upload scan results : Export the results in SARIF format and use GitHub’s API to upload them to your repo’s security tab.

You don’t need to write custom queries unless extending functionality. “Processing alerts” happens after GitHub receives the results.

When defining a custom pattern for secret scanning, two key fields are required:

Name of the pattern : A unique label to identify the pattern

Secret format : A regular expression that defines what the secret looks like (e.g., token format)

You can optionally specify additional match requirements (like required context keywords), but they’re not mandatory. Listing repositories is also not part of the required fields during pattern creation.

Before CodeQL can execute security queries, the source code must first be represented in a CodeQL database. Database creation extracts structured, relational information from the source code and, where applicable, observes or performs the build process required for the language being analyzed. Once the database exists, CodeQL can execute queries against it. The resulting query output is then interpreted using query metadata and can ultimately be converted to a format such as SARIF for presentation as code scanning alerts. Therefore, running queries, interpreting results, and converting results are later phases of analysis. GitHub's CodeQL documentation explicitly identifies creation of the CodeQL database as a prerequisite for analyzing source code with CodeQL queries, making preparation/database creation the correct first step.

You must enable secret scanning before defining custom patterns. Secret scanning provides the foundational capability for detecting exposed credentials, and custom patterns build upon that by allowing organizations to specify their own regex-based patterns for secrets unique to their environment.

Without enabling secret scanning, GitHub will not process or apply custom patterns.

In a query suite (a .qls file), the **query** key is used to specify the paths to one or more .ql files that should be included in the suite.

Example:

- query: path/to/query.ql

qls is the file format.

qlpack is used for packaging queries, not in suite syntax.

When dealing with a data flow issue in a code scanning alert, clicking on "Show paths" provides a detailed view of the data's journey through the code. This includes the source of the data, the path it takes, and where it ends up (the sink). This information is crucial for understanding how untrusted data might reach sensitive parts of your application and helps in identifying where to implement proper validation or sanitization.​

GitHub allows organization owners and repository administrators to grant additional people or teams access to repository security alerts, including Dependabot alerts, but the recipients must already have write access to that repository. Users with write, maintain, or admin access can normally view relevant repository security alerts, while additional alert-access assignments are also constrained by repository access. A team that merely has Read access to another repository does not satisfy this requirement. Similarly, an outside collaborator with only Read access or an enterprise member who has not been assigned access to the repository cannot be granted the alert access described by the question. Therefore, members of a team that has Write access to the affected repository meet GitHub's permission requirement.

A security policy is defined by a SECURITY.md file in the root of your repository or .github/ directory. This file informs contributors and security researchers about how to responsibly report vulnerabilities. It improves your project’s transparency and ensures timely communication and mitigation of any reported issues.

Adding this file also enables a “Report a vulnerability” button in the repository’s Security tab.

The first step when you receive a secret scanning alert is to revoke the secret if it is still valid. This ensures the secret can no longer be used maliciously. Only after revoking it should you proceed to remove it from the code history and apply other mitigation steps.

Simply deleting the secret from the code does not remove the risk if it hasn’t been revoked — especially since it may already be exposed in commit history.

At organization scope, enabling Dependabot alerts broadly applies the feature to the organization's eligible repositories, rather than limiting it solely to private repositories or repositories licensed for the broader GitHub Advanced Security product. Dependabot alerts support public, private, and internal repositories, subject to repository eligibility and applicable organization or enterprise configuration. GitHub's current documentation describes organization-level management as enabling Dependabot alerts across all eligible repositories through security configurations. The feature is distinct from licensed GitHub Code Security or Secret Protection capabilities, so the setting is not restricted merely to repositories where those products are enabled. Consequently, All repositories is the intended answer in the supplied choices, with the practical qualification that GitHub applies the configuration to repositories that are eligible for the feature.

The Security tab in a GitHub repository provides a central location for viewing security-related information, especially when GitHub Advanced Security is enabled. The following can be accessed:

Number of alerts related to:

Code scanning

Secret scanning

Dependency (Dependabot) alerts

Summary and visibility into open, closed, and dismissed security issues.

It does not show 2FA options, access control settings, or configuration panels for GHAS itself. Those belong to account or organization-level settings.

The dependency graph in a repository is built by parsing manifest and lock files (like package.json, pom.xml, requirements.txt). It helps GitHub detect dependencies and cross-reference them with known vulnerability databases for alerting.

It is specific to each repository and does not show org-wide or cross-repo summaries.

Comprehensive and Detailed Explanation:

Dependency review is triggered by specific events in GitHub workflows:​

pull_request: When a pull request is opened, synchronized, or reopened, GitHub can analyze the changes in dependencies and provide a dependency review.​

workflow_dispatch: This manual trigger allows users to initiate workflows, including those that perform dependency reviews.​

The trigger and commit options are not recognized GitHub Actions events and would not initiate a dependency review.​

When a CodeQL workflow uses a language matrix, the matrix explicitly defines which programming languages the workflow analyzes. GitHub states that CodeQL will analyze only the languages included in that matrix; adding or removing matrix entries therefore directly changes the languages scanned. The matrix also allows separate language-analysis jobs to run in parallel, so it does not inherently make analysis sequential. The languages input of the CodeQL init action commonly receives the current matrix.language value, but that describes how the matrix value is passed into CodeQL rather than the principal impact asked for here. The matrix also does not represent dependency exclusions. Consequently, the operational effect being tested is that CodeQL analysis is restricted to the languages explicitly included in the workflow's matrix.

A code scanning alert provides information that helps a developer identify and understand the security problem detected by the analysis tool. GitHub specifically displays the line of code that triggered the alert, together with properties such as severity, security severity, the nature of the problem, and when the issue was introduced. CodeQL-generated alerts may additionally contain remediation guidance and data-flow information. Secret values are handled through secret scanning rather than being shown as the defining detail of a code scanning alert. GitHub also does not list all users with repository Read access within an individual alert, and a CWE submission date is not the primary alert-location information. The source-code location is therefore the correct answer.