You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tooling.apache.org by ar...@apache.org on 2026/07/15 09:48:56 UTC
(tooling-trusted-releases) 01/01: #1400 - Initial stab at SBOM check
This is an automated email from the ASF dual-hosted git repository.
alitheg pushed a commit to branch sbom_check
in repository https://gitbox.apache.org/repos/asf/tooling-trusted-releases.git
commit 3e0b633c273726371183ab4a9cae7209bb3e6733
Author: Alastair McFarlane <ar...@apache.org>
AuthorDate: Wed Jul 15 10:48:33 2026 +0100
#1400 - Initial stab at SBOM check
---
atr/models/sql.py | 3 ++
atr/tasks/__init__.py | 128 +++++++++++++++++++++++++++++++++--------------
atr/tasks/checks/sbom.py | 84 +++++++++++++++++++++++++++++++
atr/util.py | 2 +-
4 files changed, 179 insertions(+), 38 deletions(-)
diff --git a/atr/models/sql.py b/atr/models/sql.py
index afeda45f..1ac1e0db 100644
--- a/atr/models/sql.py
+++ b/atr/models/sql.py
@@ -235,6 +235,7 @@ class TaskType(enum.StrEnum):
COMPARE_SOURCE_TREES = "compare_source_trees"
DISTRIBUTION_STATUS = "distribution_status"
DISTRIBUTION_WORKFLOW = "distribution_workflow"
+ HAS_SBOM = "has_sbom"
HASHING_CHECK = "hashing_check"
KEYS_IMPORT_FILE = "keys_import_file"
LICENSE_FILES = "license_files"
@@ -276,6 +277,8 @@ class TaskType(enum.StrEnum):
return "Distribution status"
case TaskType.DISTRIBUTION_WORKFLOW:
return "Distribution workflow"
+ case TaskType.HAS_SBOM:
+ return "SBOM check"
case TaskType.HASHING_CHECK:
return "Hashing check"
case TaskType.KEYS_IMPORT_FILE:
diff --git a/atr/tasks/__init__.py b/atr/tasks/__init__.py
index f2e6ab95..f248c07c 100644
--- a/atr/tasks/__init__.py
+++ b/atr/tasks/__init__.py
@@ -43,6 +43,7 @@ import atr.tasks.checks.license as license
import atr.tasks.checks.parity as parity
import atr.tasks.checks.paths as paths
import atr.tasks.checks.rat as rat
+import atr.tasks.checks.sbom as sbom_check
import atr.tasks.checks.signature as signature
import atr.tasks.checks.targz as targz
import atr.tasks.checks.zipformat as zipformat
@@ -353,6 +354,8 @@ def resolve(task_type: sql.TaskType) -> Callable[..., Awaitable[results.Results
return distribution.status_check
case sql.TaskType.DISTRIBUTION_WORKFLOW:
return gha.trigger_workflow
+ case sql.TaskType.HAS_SBOM:
+ return sbom_check.check
case sql.TaskType.HASHING_CHECK:
return hashing.check
case sql.TaskType.KEYS_IMPORT_FILE:
@@ -669,6 +672,30 @@ async def _add_task(data: db.Session, task: sql.Task) -> None:
raise
+async def _archive_comparison_task(
+ asf_uid: str, release: sql.Release, revision_number: safe.RevisionNumber, path: safe.RelPath
+) -> sql.Task | None:
+ if util.archive_format_stem(path.as_path().name) is None:
+ return None
+ path_str = str(path)
+ return await queued(
+ asf_uid,
+ sql.TaskType.ARCHIVE_COMPARISON,
+ release,
+ revision_number,
+ path_str,
+ check_cache_key=await checks.resolve_cache_key(
+ resolve(sql.TaskType.ARCHIVE_COMPARISON),
+ parity.CHECK_VERSION,
+ parity.INPUT_POLICY_KEYS,
+ release,
+ revision_number,
+ await checks.resolve_extra_args(parity.INPUT_EXTRA_ARGS, release, path_str),
+ file=path_str,
+ ),
+ )
+
+
async def _clear_existing_scheduled(
data: db.Session,
task_type: sql.TaskType,
@@ -692,6 +719,36 @@ async def _clear_existing_scheduled(
)
+async def _cyclonedx_score_task(
+ asf_uid: str,
+ release: sql.Release,
+ revision_number: safe.RevisionNumber,
+ path: safe.RelPath,
+ project_key: safe.ProjectKey,
+ release_version: safe.VersionKey,
+ previous_version: sql.Release | None,
+) -> sql.Task | None:
+ # TODO: Should we check .json files for their content?
+ # Ideally we would not have to do that
+ if not analysis.is_cyclonedx_json(path.as_path().name):
+ return None
+ return await queued(
+ asf_uid,
+ sql.TaskType.SBOM_TOOL_SCORE,
+ release,
+ revision_number,
+ str(path),
+ extra_args={
+ "project_key": str(project_key),
+ "version_key": str(release_version),
+ "revision_number": str(revision_number),
+ "previous_release_version": previous_version.version if previous_version else None,
+ "file_path": str(path),
+ "asf_uid": asf_uid,
+ },
+ )
+
+
async def _draft_file_checks(
asf_uid: str,
caller_data: db.Session | None,
@@ -714,45 +771,42 @@ async def _draft_file_checks(
if task:
task.revision_number = str(revision_number)
await _add_task(data, task)
- if util.archive_format_stem(path.as_path().name) is not None:
- archive_comparison_task = await queued(
- asf_uid,
- sql.TaskType.ARCHIVE_COMPARISON,
- release,
- revision_number,
- path_str,
- check_cache_key=await checks.resolve_cache_key(
- resolve(sql.TaskType.ARCHIVE_COMPARISON),
- parity.CHECK_VERSION,
- parity.INPUT_POLICY_KEYS,
- release,
- revision_number,
- await checks.resolve_extra_args(parity.INPUT_EXTRA_ARGS, release, path_str),
- file=path_str,
- ),
- )
- if archive_comparison_task:
- await _add_task(data, archive_comparison_task)
- # TODO: Should we check .json files for their content?
- # Ideally we would not have to do that
- if analysis.is_cyclonedx_json(path.as_path().name):
- cdx_task = await queued(
- asf_uid,
- sql.TaskType.SBOM_TOOL_SCORE,
+ # Each path may qualify for a handful of standalone checks - archive parity, an
+ # SBOM presence check, and CycloneDX scoring. The helpers guard their own
+ # applicability and hand back a task only when one is warranted.
+ for maybe_task in (
+ await _archive_comparison_task(asf_uid, release, revision_number, path),
+ await _has_sbom_task(asf_uid, release, revision_number, path),
+ await _cyclonedx_score_task(
+ asf_uid, release, revision_number, path, project_key, release_version, previous_version
+ ),
+ ):
+ if maybe_task:
+ await _add_task(data, maybe_task)
+
+
+async def _has_sbom_task(
+ asf_uid: str, release: sql.Release, revision_number: safe.RevisionNumber, path: safe.RelPath
+) -> sql.Task | None:
+ if not analysis.is_artifact(path.as_path()):
+ return None
+ path_str = str(path)
+ return await queued(
+ asf_uid,
+ sql.TaskType.HAS_SBOM,
+ release,
+ revision_number,
+ path_str,
+ check_cache_key=await checks.resolve_cache_key(
+ resolve(sql.TaskType.HAS_SBOM),
+ sbom_check.CHECK_VERSION,
+ parity.INPUT_POLICY_KEYS,
release,
revision_number,
- path_str,
- extra_args={
- "project_key": str(project_key),
- "version_key": str(release_version),
- "revision_number": str(revision_number),
- "previous_release_version": previous_version.version if previous_version else None,
- "file_path": path_str,
- "asf_uid": asf_uid,
- },
- )
- if cdx_task:
- await _add_task(data, cdx_task)
+ await checks.resolve_extra_args(sbom_check.INPUT_EXTRA_ARGS, release, path_str),
+ file=path_str,
+ ),
+ )
TASK_FUNCTIONS: Final[dict[str, Callable[..., Coroutine[Any, Any, list[sql.Task | None]]]]] = {
diff --git a/atr/tasks/checks/sbom.py b/atr/tasks/checks/sbom.py
new file mode 100644
index 00000000..b4c29f70
--- /dev/null
+++ b/atr/tasks/checks/sbom.py
@@ -0,0 +1,84 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from typing import Any, Final
+
+import aiofiles.os
+
+import atr.analysis as analysis
+import atr.log as log
+import atr.models.results as results
+import atr.tasks.checks as checks
+
+# Release policy fields which this check relies on - used for result caching
+INPUT_POLICY_KEYS: Final[list[str]] = []
+INPUT_EXTRA_ARGS: Final[list[str]] = []
+CHECK_VERSION: Final[str] = "1"
+
+
+async def check(args: checks.FunctionArguments) -> results.Results | None:
+ """Check an SBOM exists for an artifact."""
+ recorder = await args.recorder(CHECK_VERSION)
+ if not (primary_abs_path := await recorder.abs_path()):
+ return None
+
+ log.info(f"Checking SBOM exists for {primary_abs_path}")
+
+ try:
+ result_data = await _check_core_logic(artifact_path=str(primary_abs_path))
+ except Exception as e:
+ await recorder.exception("Error during SBOM check execution", {"error": str(e)})
+ return None
+
+ match result_data:
+ case {"error": error} if error:
+ await recorder.suggestion(error, result_data)
+ case _ if result_data.get("found"):
+ await recorder.note("SBOM located successfully", result_data)
+ case _:
+ await recorder.exception("SBOM location failed for unknown reasons", result_data)
+
+ return None
+
+
+async def _check_core_logic(artifact_path: str) -> dict[str, Any]:
+ """Verify an SBOM exists for the specified artifact."""
+
+ sbom_expected_paths = [artifact_path + suffix for suffix in analysis.SBOM_SUFFIXES]
+ log.info(f"Attempting to find one of: '{','.join(sbom_expected_paths)}'")
+
+ return await _check_core_logic_find_sboms(
+ sbom_expected_paths=sbom_expected_paths,
+ artifact_path=artifact_path,
+ )
+
+
+async def _check_core_logic_find_sboms(sbom_expected_paths: list[str], artifact_path: str) -> dict[str, Any]:
+
+ for sbom in sbom_expected_paths:
+ if await aiofiles.os.path.exists(sbom):
+ return {
+ "found": True,
+ "sbom_path": sbom,
+ "status": "SBOM present",
+ }
+
+ return {
+ "found": False,
+ "error": "Could not locate a matching SBOM",
+ "error_kind": "missing_sbom",
+ }
diff --git a/atr/util.py b/atr/util.py
index 97abc568..8dc53508 100644
--- a/atr/util.py
+++ b/atr/util.py
@@ -444,7 +444,7 @@ async def check_propagation(
def checker_display_name(checker: str) -> str:
- return checker.removeprefix("atr.tasks.checks.").replace("_", " ").replace(".", " ").title()
+ return checker.removeprefix("atr.tasks.checks.").replace("_", " ").replace(".", " ").title().replace("Sbom", "SBOM")
def chmod_directories(path: os.PathLike, permissions: int = DIRECTORY_PERMISSIONS) -> None:
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@tooling.apache.org
For additional commands, e-mail: commits-help@tooling.apache.org