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