# Complete pipeline from the Keyserver guide "How-To: Integrate the Keyserver with Azure DevOps":
#   https://cryptera-device-security.github.io/documentation/howtos/ci/azuredevops/
# Assembled from the guide's steps when the documentation was built.
# Review every step before use. Replace each placeholder with your own values, and keep
# secrets in your CI platform's secret store, never in this file.

trigger:
- main

pool:
  name: 'Development'
  demands:
    - Agent.Name -equals azure-runner

variables:
  KEYSERVER: 'https://keyserver.<UNIQUE-ID>.cryptera-security.io'
  HASH_ALGORITHM: '-sha256'
  KEYID: 'fw-quickstart'
  TENANT_ID: 'AZURE ENTRA ID TENANT ID'
  CLIENT_ID: 'AZURE ENTRA CLIENT ID (of the primary Entra ID, not the service connection)'
  SCOPE: 'api://$(CLIENT_ID)/.default'
  OP_DESCRIPTION: 'Azure DevOps PKCS#11 signing'

stages:
- stage: SignBinary
  displayName: "Sign Binary"
  jobs:
  - job: Main
    displayName: "Main signing flow"
    steps:
      # First step: the AzureCLI@2 GetToken task from Step 3

      - task: AzureCLI@2
        name: GetToken
        displayName: "Acquire Azure access token to access Keyserver API"
        inputs:
          azureSubscription: '<YOUR SERVICE CONNECTION NAME>'
          scriptType: 'bash'
          scriptLocation: 'inlineScript'
          inlineScript: |
            set -Eeuo pipefail
            ACCESS_TOKEN=$(az account get-access-token \
              --tenant $(TENANT_ID) \
              --scope $(SCOPE) \
              --query accessToken -o tsv)
            if [ -z "$ACCESS_TOKEN" ]; then
              echo "##vso[task.logissue type=error]Failed to acquire access token"
              exit 1
            fi
            echo "##vso[task.setvariable variable=KSC_ID_TOKEN;issecret=true]$ACCESS_TOKEN"

      - task: Bash@3
        displayName: Download prebuilt libpkcs11ks
        inputs:
          targetType: inline
          script: |
            set -euo pipefail
            mkdir -p "$(Pipeline.Workspace)/scripts"
            curl -sSL --fail -o "$(Pipeline.Workspace)/scripts/libpkcs11ks.so" \
              https://github.com/cryptera-device-security/libpkcs11ks/releases/download/v1.0.4/libpkcs11ks.so
            # Check the SHA-256 you recorded on first download:
            # echo "<RECORDED_SHA256>  $(Pipeline.Workspace)/scripts/libpkcs11ks.so" | sha256sum -c -

      - task: Bash@3
        name: EnsurePkcs11Engine
        displayName: "Install and locate the OpenSSL PKCS#11 engine"
        inputs:
          targetType: inline
          script: |
            set -euo pipefail
            if ! dpkg -s libengine-pkcs11-openssl >/dev/null 2>&1; then
              sudo apt-get update
              sudo apt-get install -y libengine-pkcs11-openssl
            fi
            # openssl reports its module directory; the engine lives in engines-<major>
            ENGINE_DIR="$(openssl version -e | sed -E 's/^ENGINESDIR: "(.*)"$/\1/')"
            ENGINE_PATH="$ENGINE_DIR/pkcs11.so"
            [ -f "$ENGINE_PATH" ] || ENGINE_PATH="$ENGINE_DIR/libpkcs11.so"
            if [ ! -f "$ENGINE_PATH" ]; then
              echo "##vso[task.logissue type=error]PKCS#11 engine not found under $ENGINE_DIR"
              exit 1
            fi
            echo "Using PKCS#11 engine: $ENGINE_PATH"
            echo "##vso[task.setvariable variable=PKCS11_ENGINE_PATH;issecret=false]$ENGINE_PATH"

      - task: Bash@3
        displayName: Generate OpenSSL PKCS#11 config
        inputs:
          targetType: inline
          script: |
            set -euo pipefail
            cat >$(Pipeline.Workspace)/scripts/openssl-ks.cnf <<'EOF'
            openssl_conf = openssl_init

            [openssl_init]
            engines = engine_section
            providers = provider_sect

            [provider_sect]
            default = default_sect
            base = base_sect

            [default_sect]
            activate = 1

            [base_sect]
            activate = 1

            [engine_section]
            pkcs11 = pkcs11_section

            [pkcs11_section]
            engine_id = pkcs11
            dynamic_path = $(PKCS11_ENGINE_PATH)
            MODULE_PATH = $(Pipeline.Workspace)/scripts/libpkcs11ks.so
            init = 0
            EOF
            echo "##vso[task.setvariable variable=OPENSSL_CONF;issecret=false]$(Pipeline.Workspace)/scripts/openssl-ks.cnf"

      - task: Bash@3
        displayName: Create Keyserver operation
        env:
          KSC_ID_TOKEN: $(KSC_ID_TOKEN)
          KSC_API_SERVER: $(KEYSERVER)
          KSC_OPERATION_DESCRIPTION: $(OP_DESCRIPTION)
        inputs:
          targetType: inline
          script: |
            set -euo pipefail
            : "${KSC_ID_TOKEN:?Missing KSC_ID_TOKEN}"
            BODY=$(jq -n --arg d "$KSC_OPERATION_DESCRIPTION" --arg k "$(KEYID)" \
              '{validms: 900000, description: $d, "new-keyusagerestrictions": [{keyid: $k, maxusagecount: 1}]}')
            RESPONSE=$(curl -sS --tlsv1.3 -X POST "$KSC_API_SERVER/api/operations" \
              -H "Authorization: Bearer $KSC_ID_TOKEN" -H "Content-Type: application/json" \
              -d "$BODY") || { echo "Create-operation request failed"; exit 1; }
            KSC_OPERATION_ID=$(jq -r '.id // empty' <<<"$RESPONSE" 2>/dev/null || true)
            if [ -z "$KSC_OPERATION_ID" ]; then
              echo "Failed to create operation. Keyserver response:"
              printf '%s\n' "$RESPONSE"
              exit 1
            fi
            echo "##vso[task.setvariable variable=KSC_OPERATION_ID;issecret=false]$KSC_OPERATION_ID"
            echo "Operation ID: $KSC_OPERATION_ID"

      - task: Bash@3
        name: WaitForApproval
        displayName: "Wait for signing approval"
        env:
          KSC_ID_TOKEN: $(KSC_ID_TOKEN)
          KSC_OPERATION_ID: $(KSC_OPERATION_ID)
          KSC_API_SERVER: $(KEYSERVER)
        inputs:
          targetType: inline
          script: |
            set -euo pipefail
            : "${KSC_ID_TOKEN:?Missing KSC_ID_TOKEN}"
            for i in {1..12}; do
              # A network error or a 5xx counts as "not yet". Any other refusal, such as
              # 410 "Operation is cancelled", ends the wait at once.
              RESP=$(curl -sS --tlsv1.3 -w '\n%{http_code}' \
                "$KSC_API_SERVER/api/operations/$KSC_OPERATION_ID" \
                -H "Authorization: Bearer $KSC_ID_TOKEN") || RESP=$'\n000'
              CODE=${RESP##*$'\n'}
              case "$CODE" in
                200) STATUS=$(jq -r '.approved' <<<"${RESP%$'\n'*}") ;;
                000|5??) STATUS="error" ;;
                *) echo "Keyserver refused the poll (HTTP $CODE):"; printf '%s\n' "${RESP%$'\n'*}"; exit 1 ;;
              esac
              echo "Attempt $i - Approved: $STATUS"
              [ "$STATUS" = "true" ] && exit 0
              sleep 10
            done

            echo "Approval timeout"
            exit 1

      - task: Bash@3
        displayName: Sign test file with OpenSSL + PKCS#11
        env:
          KSC_ID_TOKEN: $(KSC_ID_TOKEN)
          KSC_OPERATION_ID: $(KSC_OPERATION_ID)
          OPENSSL_CONF: $(OPENSSL_CONF)
          KSC_API_SERVER: $(KEYSERVER)
          KSC_OPERATION_DESCRIPTION: $(OP_DESCRIPTION)
          KSC_HTTP_CLIENT_TIMEOUT: 15s
        inputs:
          targetType: inline
          script: |
            set -euo pipefail
            : "${KSC_ID_TOKEN:?Missing KSC_ID_TOKEN}"
            : "${KSC_OPERATION_ID:?Missing KSC_OPERATION_ID}"
            export OPENSSL_CONF
            export KSC_API_SERVER
            export KSC_OPERATION_DESCRIPTION
            export KSC_OPERATION_ID
            echo "Test" > test.txt
            openssl dgst \
              -engine pkcs11 \
              -keyform engine \
              -sign "pkcs11:object=$(KEYID);type=private" \
              $(HASH_ALGORITHM) \
              -out test.txt.sig \
              test.txt
            echo "Signature written to test.txt.sig"

      - task: Bash@3
        name: GetCertificate
        displayName: "Download certificate for signing key (for validation)"
        env:
          KSC_ID_TOKEN: $(KSC_ID_TOKEN)
          KSC_API_SERVER: $(KEYSERVER)
        inputs:
          targetType: inline
          script: |
            set -Eeuo pipefail
            : "${KSC_ID_TOKEN:?Missing KSC_ID_TOKEN}"
            : "${KSC_API_SERVER:?Missing KSC_API_SERVER}"

            curl --fail-with-body -sS --tlsv1.3 \
              -H "Authorization: Bearer $KSC_ID_TOKEN" \
              -H "Accept: application/json" \
              "$KSC_API_SERVER/api/keys/$(KEYID)" \
              | jq -er '.certificate' > certificate.pem

            test -s certificate.pem
            echo "Saved certificate to certificate.pem"


      - task: Bash@3
        displayName: "Validate signature using certificate"
        inputs:
          targetType: inline
          script: |
            set -Eeuo pipefail

            test -s certificate.pem
            test -s test.txt
            test -s test.txt.sig

            # Extract pubkey from cert
            openssl x509 -in certificate.pem -pubkey -noout > pubkey.pem
            test -s pubkey.pem

            # Verify signature
            openssl dgst \
              -verify pubkey.pem \
              $(HASH_ALGORITHM) \
              -signature test.txt.sig \
              test.txt

            echo "Signature verification OK"

      - task: PublishBuildArtifacts@1
        displayName: Publish signature
        inputs:
          PathtoPublish: "$(System.DefaultWorkingDirectory)"
          ArtifactName: signed-output
          publishLocation: "Container"
