field_ios

In-the-field app for Radroots on iOS
git clone https://radroots.dev/git/field_ios.git
Log | Files | Refs | README | LICENSE

release-evidence.sh (9305B)


      1 #!/bin/sh
      2 set -eu
      3 
      4 repo_root=$(CDPATH='' cd -- "$(dirname -- "$0")/.." && pwd)
      5 mode=${1:-}
      6 case "$mode" in
      7     write|check) ;;
      8     *) echo "usage: $0 {write|check}" >&2; exit 64 ;;
      9 esac
     10 
     11 for tool in cargo jq shasum git uv rg
     12 do
     13     command -v "$tool" >/dev/null 2>&1 || {
     14         echo "error: required release-evidence tool is unavailable: $tool" >&2
     15         exit 1
     16     }
     17 done
     18 
     19 tmp_root=$(mktemp -d "${TMPDIR:-/tmp}/tera-ios-release.XXXXXX")
     20 trap 'rm -rf "$tmp_root"' EXIT HUP INT TERM
     21 metadata="$tmp_root/cargo-metadata.json"
     22 rendered_sbom="$tmp_root/sbom.cdx.json"
     23 rendered_provenance="$tmp_root/provenance.json"
     24 authored_app="$tmp_root/authored-app.json"
     25 authored_app_final="$tmp_root/authored-app-final.json"
     26 capture_authored_app() {
     27     uv run --project "$repo_root/scripts/persona-verifier" --offline --frozen \
     28         python "$repo_root/scripts/app_source.py" --repo-root "$repo_root"
     29 }
     30 capture_authored_app > "$authored_app"
     31 
     32 cargo metadata --locked --format-version 1 > "$metadata"
     33 
     34 version=$(jq -er '
     35     [.packages[] | select(.name == "tera_ffi") | .version]
     36     | if length == 1 then .[0] else error("missing owned FFI package") end
     37 ' "$metadata")
     38 
     39 jq -S --slurpfile swift "$repo_root/Package.resolved" \
     40     --arg version "$version" '
     41     def cargo_ref:
     42         "cargo:" + .name + "@" + .version + "?source=" + (.source // "workspace");
     43     def swift_ref:
     44         "swift:" + .identity + "@" + .state.revision + "?source=" + .location;
     45     def cargo_components:
     46         [.packages[] |
     47             {
     48                 "bom-ref": cargo_ref,
     49                 type: "library",
     50                 name: .name,
     51                 version: .version,
     52                 licenses: (
     53                     if .license == null then [] else [{expression: .license}] end
     54                 ),
     55                 properties: [
     56                     {name: "radroots.package.manager", value: "cargo"},
     57                     {name: "radroots.package.source", value: (.source // "workspace")}
     58                 ]
     59             }
     60         ];
     61     def swift_components:
     62         [$swift[0].pins[] |
     63             {
     64                 "bom-ref": swift_ref,
     65                 type: "library",
     66                 name: .identity,
     67                 version: .state.revision,
     68                 properties: [
     69                     {name: "radroots.package.manager", value: "swiftpm"},
     70                     {name: "radroots.package.source", value: .location},
     71                     {name: "radroots.package.revision", value: .state.revision}
     72                 ]
     73             }
     74         ];
     75     . as $cargo |
     76     ($cargo.packages |
     77         map({key: .id, value: cargo_ref}) |
     78         from_entries
     79     ) as $cargo_refs |
     80     (cargo_components + swift_components | sort_by(."bom-ref")) as $components |
     81     ("pkg:generic/tera@" + $version) as $application_ref |
     82     (
     83         [$cargo.resolve.nodes[] |
     84             {
     85                 ref: $cargo_refs[.id],
     86                 dependsOn: ([.dependencies[] as $dependency | $cargo_refs[$dependency]] | sort)
     87             }
     88         ] +
     89         [$swift[0].pins[] | {ref: swift_ref, dependsOn: []}] +
     90         [{
     91             ref: $application_ref,
     92             dependsOn: (
     93                 ([$cargo.workspace_members[] as $member | $cargo_refs[$member]] +
     94                  [$swift[0].pins[] | swift_ref]) |
     95                 sort
     96             )
     97         }] |
     98         sort_by(.ref)
     99     ) as $dependencies |
    100     {
    101         bomFormat: "CycloneDX",
    102         specVersion: "1.5",
    103         version: 1,
    104         metadata: {
    105             component: {
    106                 "bom-ref": $application_ref,
    107                 type: "application",
    108                 name: "tera",
    109                 version: $version,
    110                 purl: ("pkg:generic/tera@" + $version),
    111                 externalReferences: [{
    112                     type: "vcs",
    113                     url: "https://github.com/radrootslabs/tera"
    114                 }]
    115             }
    116         },
    117         components: $components,
    118         dependencies: $dependencies
    119     }
    120 ' "$metadata" > "$rendered_sbom"
    121 
    122 hash_file() {
    123     shasum -a 256 "$1" | awk '{print $1}'
    124 }
    125 
    126 lib_revision=$(jq -er '.foundation.revision' "$repo_root/TeraFFI/source/aarch64-apple-ios.json")
    127 source_date_epoch=$(jq -er '.source_date_epoch' "$authored_app")
    128 tera_ffi_source_tree=$(jq -er '.candidate.source.tree' "$repo_root/TeraFFI/provenance.json")
    129 consumer_lock_sha256=$(hash_file "$repo_root/radroots.lib.source-lock.v1.toml")
    130 cargo_lock_sha256=$(hash_file "$repo_root/Cargo.lock")
    131 swift_lock_sha256=$(hash_file "$repo_root/Package.resolved")
    132 xcode_swift_lock_sha256=$(hash_file \
    133     "$repo_root/Tera.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved")
    134 ffi_provenance_sha256=$(hash_file "$repo_root/TeraFFI/provenance.json")
    135 ffi_api_sha256=$(hash_file "$repo_root/TeraFFI/api/TeraKitBindings.symbols.json")
    136 app_api_sha256=$(hash_file "$repo_root/api/TeraApp.symbols.json")
    137 info_plist_sha256=$(hash_file "$repo_root/Tera/Info.plist")
    138 privacy_manifest_sha256=$(hash_file "$repo_root/Tera/Resources/PrivacyInfo.xcprivacy")
    139 xcode_project_sha256=$(hash_file "$repo_root/Tera.xcodeproj/project.pbxproj")
    140 sbom_sha256=$(hash_file "$rendered_sbom")
    141 
    142 jq -nS \
    143     --slurpfile authored_app "$authored_app" \
    144     --arg version "$version" \
    145     --arg lib_revision "$lib_revision" \
    146     --arg tera_ffi_source_tree "$tera_ffi_source_tree" \
    147     --argjson source_date_epoch "$source_date_epoch" \
    148     --arg consumer_lock_sha256 "$consumer_lock_sha256" \
    149     --arg cargo_lock_sha256 "$cargo_lock_sha256" \
    150     --arg swift_lock_sha256 "$swift_lock_sha256" \
    151     --arg xcode_swift_lock_sha256 "$xcode_swift_lock_sha256" \
    152     --arg ffi_provenance_sha256 "$ffi_provenance_sha256" \
    153     --arg ffi_api_sha256 "$ffi_api_sha256" \
    154     --arg app_api_sha256 "$app_api_sha256" \
    155     --arg info_plist_sha256 "$info_plist_sha256" \
    156     --arg privacy_manifest_sha256 "$privacy_manifest_sha256" \
    157     --arg xcode_project_sha256 "$xcode_project_sha256" \
    158     --arg sbom_sha256 "$sbom_sha256" '
    159     {
    160         schema: "tera.release-provenance.v1",
    161         product: "tera",
    162         version: $version,
    163         repository: "https://github.com/radrootslabs/tera",
    164         source: {
    165             authored_app: $authored_app[0].source,
    166             lib_revision: $lib_revision,
    167             tera_ffi_source_tree: $tera_ffi_source_tree,
    168             source_date_epoch: $source_date_epoch,
    169             consumer_source_lock_sha256: $consumer_lock_sha256,
    170             cargo_lock_sha256: $cargo_lock_sha256,
    171             swift_package_lock_sha256: $swift_lock_sha256,
    172             xcode_package_lock_sha256: $xcode_swift_lock_sha256
    173         },
    174         artifacts: {
    175             ffi_provenance_sha256: $ffi_provenance_sha256,
    176             ffi_api_sha256: $ffi_api_sha256,
    177             app_api_sha256: $app_api_sha256,
    178             info_plist_sha256: $info_plist_sha256,
    179             privacy_manifest_sha256: $privacy_manifest_sha256,
    180             xcode_project_sha256: $xcode_project_sha256,
    181             sbom_sha256: $sbom_sha256
    182         },
    183         platforms: ["ios-arm64", "ios-arm64-simulator"],
    184         disposition: "unsigned"
    185     }
    186 ' > "$rendered_provenance"
    187 
    188 jq -e '
    189     .bomFormat == "CycloneDX" and
    190     .specVersion == "1.5" and
    191     .version == 1 and
    192     .metadata.component.name == "tera" and
    193     (.components | length > 0) and
    194     (([.components[]."bom-ref"] | unique | length) == (.components | length)) and
    195     ([.components[]."bom-ref"] == ([.components[]."bom-ref"] | sort)) and
    196     ([.dependencies[].ref] == ([.dependencies[].ref] | sort)) and
    197     (.dependencies | all(.dependsOn == (.dependsOn | sort))) and
    198     (.components | all(
    199         (.name | type == "string" and length > 0) and
    200         (.version | type == "string" and length > 0)
    201     ))
    202 ' "$rendered_sbom" >/dev/null
    203 jq -e \
    204     --arg lib_revision "$lib_revision" \
    205     --arg tera_ffi_source_tree "$tera_ffi_source_tree" \
    206     --arg sbom_sha256 "$sbom_sha256" '
    207     .schema == "tera.release-provenance.v1" and
    208     .repository == "https://github.com/radrootslabs/tera" and
    209     .source.lib_revision == $lib_revision and
    210     .source.tera_ffi_source_tree == $tera_ffi_source_tree and
    211     .artifacts.sbom_sha256 == $sbom_sha256 and
    212     .platforms == ["ios-arm64", "ios-arm64-simulator"] and
    213     .disposition == "unsigned"
    214 ' "$rendered_provenance" >/dev/null
    215 
    216 scan_status=0
    217 rg --quiet '/Users/|/Volumes/|BEGIN [A-Z ]*PRIVATE KEY' \
    218     "$rendered_sbom" "$rendered_provenance" >/dev/null 2>&1 || scan_status=$?
    219 case "$scan_status" in
    220     1) ;;
    221     0)
    222         echo "error: release evidence contains forbidden host or protected material" >&2
    223         exit 1
    224         ;;
    225     *)
    226         echo "error: release evidence scan is incomplete" >&2
    227         exit 1
    228         ;;
    229 esac
    230 
    231 capture_authored_app > "$authored_app_final"
    232 if ! cmp -s "$authored_app" "$authored_app_final"; then
    233     echo "error: authored app source changed during release rendering" >&2
    234     exit 1
    235 fi
    236 
    237 output_root="$repo_root/release"
    238 case "$mode" in
    239     write)
    240         mkdir -p "$output_root"
    241         install -m 0644 "$rendered_sbom" "$output_root/sbom.cdx.json"
    242         install -m 0644 "$rendered_provenance" "$output_root/provenance.json"
    243         ;;
    244     check)
    245         cmp "$rendered_sbom" "$output_root/sbom.cdx.json"
    246         cmp "$rendered_provenance" "$output_root/provenance.json"
    247         ;;
    248 esac
    249 
    250 echo "release evidence $mode succeeded for tera@$version"