generator_container_slsa3.yml

# Copyright 2022 SLSA Authors
#
# Licensed 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.

name: SLSA container image provenance

permissions: {}

env:
  # Generator
  BUILDER_BINARY: slsa-generator-container-linux-amd64 # Name of the binary in the release assets.
  BUILDER_DIR: internal/builders/container # Source directory if we compile the builder.

defaults:
  run:
    shell: bash

on:
  workflow_call:
    secrets:
      registry-username:
        description: "Username to log into the container registry."
      registry-password:
        description: "Password to log in the container registry."
    inputs:
      image:
        description: "The OCI image name. This must not include a tag or digest."
        required: true
        type: string
      digest:
        description: "The OCI image digest. The image digest of the form '<algorithm>:<digest>' (e.g. 'sha256:abcdef...')"
        required: true
        type: string
      registry-username:
        description: "Username to log into the container registry."
        type: string
      compile-generator:
        description: "Build the generator from source. This increases build time by ~2m."
        required: false
        type: boolean
        default: false
      private-repository:
        description: "If true, private repositories can post to the public transparency log."
        required: false
        type: boolean
        default: false
      continue-on-error:
        description: "Prevents a workflow run from failing when a job fails. Set to 'true' to allow a workflow run to pass when a job fails."
        required: false
        type: boolean
        default: false
      gcp-workload-identity-provider:
        description: "The full identifier of the Workload Identity Provider, including the project number, pool name, and provider name.."
        required: false
        type: string
        default: ""
      gcp-service-account:
        description: "Email address or unique identifier of the Google Cloud service account for which to generate credentials."
        required: false
        type: string
        default: ""
    outputs:
      # Note: we use this output because there is no buildt-in `outcome` and `result` is always `success`
      # if `continue-on-error` is set to `true`.
      outcome:
        description: >
          The outcome status of the run ('success' or 'failure').

          Note: this is only set when `continue-on-error` is `true`.
        value: ${{ jobs.final.outputs.outcome }}

jobs:
  # detect-env detects the reusable workflow's repository and ref for use later
  # in the workflow.
  detect-env:
    outputs:
      outcome: ${{ steps.final.outputs.outcome }}
      repository: ${{ steps.detect.outputs.repository }}
      ref: ${{ steps.detect.outputs.ref }}
    runs-on: ubuntu-latest
    permissions:
      id-token: write # Needed to detect the current reusable repository and ref.
    steps:
      - name: Detect the generator ref
        id: detect
        continue-on-error: true
        uses: slsa-framework/slsa-github-generator/.github/actions/detect-workflow@main

      - name: Final outcome
        id: final
        env:
          SUCCESS: ${{ steps.detect.outcome != 'failure' }}
        run: |
          echo "outcome=$([ "$SUCCESS" == "true" ] && echo "success" || echo "failure")" >> $GITHUB_OUTPUT

  # generator builds the generator binary and runs it to generate SLSA
  # provenance.
  #
  # If `compile-generator` is true then the generator is compiled
  # from source at the ref detected by `detect-env`.
  #
  # If `compile-generator` is false, then the generator binary is downloaded
  # with the release at the ref detected by `detect-env`. This must be a tag
  # reference.
  generator:
    outputs:
      outcome: ${{ steps.final.outputs.outcome }}
    runs-on: ubuntu-latest
    needs: [detect-env]
    permissions:
      id-token: write # Needed to get OIDC token for keyless signing, and for GCP Auth.
      actions: read # Needed to read workflow info.
      packages: write # Needed to login and upload attestations to ghcr.io.
    steps:
      - name: Generate builder
        id: generate-builder
        continue-on-error: true
        uses: slsa-framework/slsa-github-generator/.github/actions/generate-builder@main
        with:
          repository: "${{ needs.detect-env.outputs.repository }}"
          ref: "${{ needs.detect-env.outputs.ref }}"
          go-version: "1.20"
          binary: "${{ env.BUILDER_BINARY }}"
          compile-builder: "${{ inputs.compile-generator }}"
          # NOTE: We are using the generic generator.
          directory: "${{ env.BUILDER_DIR }}"
          allow-private-repository: ${{ inputs.private-repository }}

      - id: auth
        name: Authenticate to Google Cloud
        if: inputs.gcp-workload-identity-provider != ''
        uses: google-github-actions/auth@ef5d53e30bbcd8d0836f4288f5e50ff3e086997d # v1.0.0
        with:
          token_format: "access_token"
          workload_identity_provider: ${{ inputs.gcp-workload-identity-provider }}
          service_account: ${{ inputs.gcp-service-account }}

      - id: cosign-install
        uses: sigstore/cosign-installer@9e9de2292db7abb3f51b7f4808d98f0d347a8919 # v3.0.2
        with:
          cosign-release: v2.0.0
        continue-on-error: true

      - name: Login
        id: login
        continue-on-error: true
        env:
          UNTRUSTED_IMAGE: "${{ inputs.image }}"
          UNTRUSTED_INPUT_USERNAME: "${{ inputs.registry-username }}"
          UNTRUSTED_SECRET_USERNAME: "${{ secrets.registry-username }}"
          UNTRUSTED_PASSWORD: "${{ secrets.registry-password }}"
          GCP_ACCESS_TOKEN: "${{ steps.auth.outputs.access_token }}"
        run: |
          set -euo pipefail

          # NOTE: Some docker images are of the form <org>/<name>
          # Here we get the first part and check if it has a '.' or ':'
          # character in it to see if it's a domain name.
          # See: https://stackoverflow.com/questions/37861791/how-are-docker-image-names-parsed#37867949
          untrusted_registry="docker.io"
          # NOTE: Do not fail the script if grep does not match.
          maybe_domain=$(echo "${UNTRUSTED_IMAGE}" | cut -f1 -d "/" | { grep -E "\.|:" || true; })
          if [ "${maybe_domain}" != "" ]; then
            untrusted_registry="${maybe_domain}"
          fi

          if [ "${GCP_ACCESS_TOKEN}" != "" ]; then
            username="oauth2accesstoken"
            password="${GCP_ACCESS_TOKEN}"
          else
            username="${UNTRUSTED_SECRET_USERNAME:-${UNTRUSTED_INPUT_USERNAME}}"
            if [ "${username}" == "" ]; then
                echo "registry-username is required." >&2
                exit 1
            fi
            password="${UNTRUSTED_PASSWORD}"
            if [ "${password}" == "" ]; then
                echo "registry-password is required." >&2
                exit 1
            fi
          fi

          echo "login to ${untrusted_registry}"
          cosign login "${untrusted_registry}" -u "${username}" -p "${password}"

      - name: Create and sign provenance
        id: sign-prov
        continue-on-error: true
        env:
          UNTRUSTED_IMAGE: "${{ inputs.image }}"
          UNTRUSTED_DIGEST: "${{ inputs.digest }}"
          GITHUB_CONTEXT: "${{ toJSON(github) }}"
        run: |
          set -euo pipefail

          # Generate a predicate only.
          predicate_name="predicate.json"
          "$GITHUB_WORKSPACE/$BUILDER_BINARY" generate --predicate="$predicate_name"

          COSIGN_EXPERIMENTAL=1 cosign attest --predicate="$predicate_name" \
            --type slsaprovenance \
            --yes \
            "${UNTRUSTED_IMAGE}@${UNTRUSTED_DIGEST}"

      - name: Final outcome
        id: final
        env:
          SUCCESS: ${{ steps.generate-builder.outcome != 'failure' && steps.cosign-install.outcome != 'failure' && steps.login.outcome != 'failure' && steps.sign-prov.outcome != 'failure' }}
        run: |
          echo "outcome=$([ "$SUCCESS" == "true" ] && echo "success" || echo "failure")" >> $GITHUB_OUTPUT

  # final fails or succeeds based on the value of `inputs.continue-on-error`
  # and the outcome of previous jobs.
  final:
    outputs:
      outcome: ${{ steps.final.outputs.outcome }}
    runs-on: ubuntu-latest
    needs: [detect-env, generator]
    # Note: always run even if needed jobs are skipped.
    if: always()
    steps:
      - name: Final outcome
        id: final
        env:
          SUCCESS: ${{ needs.detect-env.outputs.outcome != 'failure' && needs.generator.outputs.outcome != 'failure' }}
          CONTINUE: ${{ inputs.continue-on-error }}
        run: |
          echo "outcome=$([ "$SUCCESS" == "true" ] && echo "success" || echo "failure")" >> $GITHUB_OUTPUT
          [ "$CONTINUE" == "true" ] || [ "$SUCCESS" == "true" ] || exit 27