Skip to content

Free, open-source 3D sculpting for Linux, macOS and Windows: dense meshes, remeshing, painting, built-in AI (image/text to 3D), Send to Unreal, game-ready LODs, Gaussian splats and OpenUSD.

apt and dnf repositories: signed metadata from the release's .deb/.rpm (release.yml, environment release), served from sculptforge.app/apt and /rpm (pages.yml), end-to-end test with a throwaway key; off until the REPO_SIGNING_KEY secret exists (#149)

islandmed920e4e054838
diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml
index 7a9cd333..82aae567 100644
--- a/.github/workflows/pages.yml
+++ b/.github/workflows/pages.yml
@@ -43,6 +43,13 @@ jobs:
# No image or video that shows a mark goes out, whichever commit it came from (tools/marks_media_flagged.txt).
- name: Media takedown
run: python3 tools/media_takedown.py website
+ # The apt and dnf repositories (sculptforge.app/apt and /rpm): the latest published release's signed metadata
+ # and its .deb and .rpm files, each checked against that release's SHA256SUMS.txt (docs/design/package-repos.md).
+ # Nothing until a release carries the metadata (it needs the REPO_SIGNING_KEY secret).
+ - name: Package repositories
+ env:
+ GH_TOKEN: ${{ github.token }}
+ run: tools/publish/package_repos_fetch.sh "$(gh api "repos/$GITHUB_REPOSITORY/releases/latest" -q .tag_name)" website
# The credits page always matches docs/supporters.txt on main.
- name: Supporters page
run: python3 tools/guide/build_site.py --supporters
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index e3a349a4..912421ae 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -298,6 +298,8 @@ jobs:
permissions:
contents: write
actions: read
+ env:
+ HAS_REPO_KEY: ${{ secrets.REPO_SIGNING_KEY != '' }}
steps:
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
with: { ref: '${{ env.TAG }}', persist-credentials: false }
@@ -349,6 +351,19 @@ jobs:
run: python3 -m zipfile -c dist/sculptforge_maya.zip integrations/maya/sculptforge_maya.py integrations/maya/README.md
- name: Software bill of materials (CycloneDX; covered by the checksums and their signature)
run: python3 tools/release/sbom.py --version "${TAG#v}" --out "dist/SculptForge-${TAG#v}-sbom.cdx.json"
+ # The apt and dnf repositories (sculptforge.app/apt and /rpm, docs/design/package-repos.md): signed metadata for
+ # this release's .deb and .rpm, put on the site by pages.yml. Skipped until the REPO_SIGNING_KEY secret exists
+ # in this environment. The tools are installed in their own step, which never sees the key.
+ - name: Repository tools
+ if: ${{ env.HAS_REPO_KEY == 'true' }}
+ run: sudo apt-get update -q && sudo apt-get install -y -q createrepo-c apt-utils
+ - name: Signed apt and dnf repository metadata
+ env:
+ REPO_SIGNING_KEY: ${{ secrets.REPO_SIGNING_KEY }}
+ REPO_SIGNING_PASSPHRASE: ${{ secrets.REPO_SIGNING_PASSPHRASE }}
+ run: |
+ if [ -z "$REPO_SIGNING_KEY" ]; then echo "No REPO_SIGNING_KEY secret: no package repositories for this release"; exit 0; fi
+ tools/publish/package_repos.sh dist dist/sculptforge-package-repos.tar.gz
- name: Checksums
run: cd dist && sha256sum * > SHA256SUMS.txt && cat SHA256SUMS.txt
- name: Sign the checksums (one-click update checks SHA256SUMS.txt.sig, src/core/SelfUpdate.h)
diff --git a/.github/workflows/repos.yml b/.github/workflows/repos.yml
new file mode 100644
index 00000000..c8343aa5
--- /dev/null
+++ b/.github/workflows/repos.yml
@@ -0,0 +1,83 @@
+name: Package repositories
+
+# tools/publish/package_repos.sh (release workflow) and package_repos_fetch.sh (pages.yml) end to end, with the
+# latest release's packages and a throwaway test key made in this job (never the real REPO_SIGNING_KEY): build the
+# signed metadata, put the site together, serve it locally, then install SculptForge with apt in Debian and Ubuntu
+# and with dnf in Fedora and Rocky 9 containers, and check that a package whose bytes differ is refused.
+
+on:
+ push:
+ paths:
+ - tools/publish/package_repos*.sh
+ - .github/workflows/repos.yml
+ workflow_dispatch:
+
+permissions:
+ contents: read
+
+jobs:
+ e2e:
+ runs-on: ubuntu-24.04
+ timeout-minutes: 30
+ steps:
+ - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+ with:
+ persist-credentials: false
+ - name: Tools
+ run: sudo apt-get update -q && sudo apt-get install -y -q createrepo-c
+ - name: The latest release's packages
+ env:
+ GH_TOKEN: ${{ github.token }}
+ run: |
+ mkdir dist && cd dist
+ gh release download -R "$GITHUB_REPOSITORY" -p 'sculptforge_[0-9]*.deb' -p 'sculptforge-[0-9]*.rpm' -p SHA256SUMS.txt
+ ls -l
+ - name: Metadata, signed with a throwaway key
+ run: |
+ export GNUPGHOME=$(mktemp -d)
+ gpg --batch --pinentry-mode loopback --passphrase test --quick-gen-key "Test only <test@invalid>" rsa4096 sign 1d
+ REPO_SIGNING_KEY=$(gpg --batch --pinentry-mode loopback --passphrase test --armor --export-secret-keys) \
+ REPO_SIGNING_PASSPHRASE=test tools/publish/package_repos.sh dist dist/sculptforge-package-repos.tar.gz
+ (cd dist && sha256sum sculptforge-package-repos.tar.gz >> SHA256SUMS.txt)
+ tar -tzf dist/sculptforge-package-repos.tar.gz
+ - name: Site put together (as pages.yml does)
+ run: |
+ mkdir site
+ PACKAGE_REPOS_LOCAL=dist tools/publish/package_repos_fetch.sh vTEST site
+ find site -type f | sort
+ (cd site && python3 -m http.server 8000 --bind 127.0.0.1 >/dev/null 2>&1 &)
+ sleep 1
+ - name: apt (Debian stable, Ubuntu 24.04)
+ run: |
+ for img in debian:stable ubuntu:24.04; do
+ docker run --rm --network host "$img" sh -euc '
+ apt-get update -q >/dev/null && apt-get install -y -q curl ca-certificates >/dev/null
+ install -d -m 0755 /etc/apt/keyrings
+ curl -fsSL http://127.0.0.1:8000/apt/sculptforge.asc -o /etc/apt/keyrings/sculptforge.asc
+ echo "deb [signed-by=/etc/apt/keyrings/sculptforge.asc] http://127.0.0.1:8000/apt stable main" > /etc/apt/sources.list.d/sculptforge.list
+ apt-get update -q
+ apt-get install -y -q sculptforge >/dev/null
+ dpkg -s sculptforge | grep -E "^(Version|Architecture)"
+ test -x /usr/bin/sculptforge && test -x /usr/bin/sculptforge-cli'
+ done
+ - name: dnf (Fedora, Rocky 9)
+ run: |
+ sed 's|https://sculptforge.app/rpm|http://127.0.0.1:8000/rpm|' site/rpm/sculptforge.repo > test.repo
+ for img in fedora:latest rockylinux:9; do
+ docker run --rm --network host -v "$PWD/test.repo:/etc/yum.repos.d/sculptforge.repo:ro" "$img" sh -euc '
+ dnf install -y -q sculptforge
+ rpm -q sculptforge
+ test -x /usr/bin/sculptforge && test -x /usr/bin/sculptforge-cli'
+ done
+ - name: A package with other bytes is refused
+ run: |
+ deb=$(ls site/apt/pool/main/s/sculptforge/*_amd64.deb)
+ printf 'x' >> "$deb"
+ docker run --rm --network host debian:stable sh -euc '
+ apt-get update -q >/dev/null && apt-get install -y -q curl ca-certificates >/dev/null
+ install -d -m 0755 /etc/apt/keyrings
+ curl -fsSL http://127.0.0.1:8000/apt/sculptforge.asc -o /etc/apt/keyrings/sculptforge.asc
+ echo "deb [signed-by=/etc/apt/keyrings/sculptforge.asc] http://127.0.0.1:8000/apt stable main" > /etc/apt/sources.list.d/sculptforge.list
+ apt-get update -q
+ if apt-get install -y -q sculptforge; then echo "apt installed a tampered package"; exit 1; fi
+ echo "apt refused the tampered package"'
diff --git a/changes/feat-package-repos.md b/changes/feat-package-repos.md
new file mode 100644
index 00000000..3822e2bb
--- /dev/null
+++ b/changes/feat-package-repos.md
@@ -0,0 +1,9 @@
+---
+whats_new: **Package managers**: the install guide lists where SculptForge is today: Homebrew available, winget and
+ Omarchy in review, the AUR package ready to publish, apt and dnf repositories on the way. Thanks @NicTanghe (#149).
+changed: Install guide: a **Package managers** table with each one's status (Homebrew available; winget and Omarchy
+ in review; AUR ready, not published yet; apt and dnf repositories built, live once their signing key exists).
+ Asked for by @NicTanghe (#149).
+---
+Reviewers: AUR submission in packaging/arch/SUBMIT.md (maintainer's account); apt/dnf design and key steps in
+docs/design/package-repos.md (maintainer creates the key; workflows skip until the secret exists).
diff --git a/docs/design/package-repos.md b/docs/design/package-repos.md
new file mode 100644
index 00000000..05618f2d
--- /dev/null
+++ b/docs/design/package-repos.md
@@ -0,0 +1,93 @@
+# apt and dnf repositories (#149)
+
+Status: built and tested, **off until the maintainer creates the signing key** (below). Until then nothing changes
+for users: releases carry no repository metadata and the site has no /apt or /rpm.
+
+## What users get
+
+```sh
+# Debian, Ubuntu, Mint, Pop!_OS (amd64, arm64)
+sudo install -d -m 0755 /etc/apt/keyrings
+curl -fsSL https://sculptforge.app/apt/sculptforge.asc | sudo tee /etc/apt/keyrings/sculptforge.asc >/dev/null
+echo "deb [signed-by=/etc/apt/keyrings/sculptforge.asc] https://sculptforge.app/apt stable main" |
+ sudo tee /etc/apt/sources.list.d/sculptforge.list
+sudo apt update && sudo apt install sculptforge
+
+# Fedora, RHEL, Rocky, Alma 9+ (x86_64, aarch64)
+sudo curl -fsSL -o /etc/yum.repos.d/sculptforge.repo https://sculptforge.app/rpm/sculptforge.repo
+sudo dnf install sculptforge # asks once to trust the key: compare its fingerprint with the guide's
+```
+
+Then `apt upgrade` / `dnf upgrade` bring each release. The packages are the release's own `.deb` and `.rpm`
+files, byte for byte (the ones the release workflow verified and smoke-tested).
+
+## How it works
+
+1. **Release workflow** (`release.yml`, job publish, environment `release`): `tools/publish/package_repos.sh` builds
+ the metadata for the release's versioned `.deb` and `.rpm` and signs it: apt `InRelease` (clearsigned) and
+ `Release.gpg`, dnf `repodata/repomd.xml.asc`. It uploads only the metadata, `sculptforge-package-repos.tar.gz`, as a
+ release asset, covered by `SHA256SUMS.txt` and its signature like every other asset. Without the
+ `REPO_SIGNING_KEY` secret the step says so and does nothing.
+2. **Website** (`pages.yml`): `tools/publish/package_repos_fetch.sh` takes the latest published release's metadata
+ and downloads the packages it names into `website/apt/pool/...` and `website/rpm/packages/`, each checked against
+ that release's `SHA256SUMS.txt`, then deploys with the rest of the site. Nothing is committed to git (about
+ 120 MB per release); only the newest version is in the repositories (older ones stay on the releases page).
+3. **Trust chain**: the key signs the metadata; the metadata lists each package's SHA-256; apt and dnf refuse a
+ package whose bytes differ (`.github/workflows/repos.yml` tests exactly that, plus installs on Debian, Ubuntu,
+ Fedora and Rocky 9 with a throwaway key). The `.rpm` files themselves are not signed, because signing would
+ change the tested bytes: the repo file sets `repo_gpgcheck=1` (signed metadata, which carries every package's
+ checksum) and `gpgcheck=0`. A later step can sign the `.rpm` in `packages.yml` if a distribution policy needs it.
+
+The key lives only in the `release` environment (tags `v*` only), reaches one step, and is never written to disk
+outside that step's temporary keyring. The tools are installed in an earlier step that never sees it. pages.yml
+and everything else never see it.
+
+## The signing key (maintainer: once, about 5 minutes)
+
+Not the app's update key (`UPDATE_SIGNING_KEY`): a separate OpenPGP key used only for these repositories.
+
+- **Type**: OpenPGP, RSA 4096, sign-only primary key, no subkeys (works with every apt, including `sqv` on Debian
+ 13+, and with dnf/rpm on RHEL 9).
+- **Identity**: `SculptForge packages <[email protected]>` (no personal name or address).
+- **Expiry**: none. apt and dnf keep the copy users installed and never refresh it, so an expiring key silently
+ stops every user's updates on the expiry date. Rotation (below) handles compromise instead.
+- **Where it is made**: on the laptop, in a temporary keyring in RAM (`/dev/shm`), never in `~/.gnupg`.
+- **Where the private part lives**: GitHub Actions secrets `REPO_SIGNING_KEY` (armored private key) and
+ `REPO_SIGNING_PASSPHRASE`, in the **`release` environment only**: not repository secrets, not `member-release`.
+ One offline copy in the password manager: the armored private key, the passphrase and the revocation
+ certificate gpg writes (`openpgp-revocs.d/<fingerprint>.rev`).
+
+```sh
+export GNUPGHOME=$(mktemp -d -p /dev/shm)
+gpg --quick-gen-key "SculptForge packages <[email protected]>" rsa4096 sign never
+# (pick a long passphrase when asked; it goes in the password manager and the second secret)
+gpg --armor --export-secret-keys | gh secret set REPO_SIGNING_KEY --env release -R islandmed/SculptForge
+gh secret set REPO_SIGNING_PASSPHRASE --env release -R islandmed/SculptForge # paste the passphrase
+gpg --armor --export-secret-keys; cat "$GNUPGHOME"/openpgp-revocs.d/*.rev # both into the password manager
+gpg --fingerprint # send the fingerprint to the coordinator
+rm -rf "$GNUPGHOME"; unset GNUPGHOME
+```
+
+From the next release on, the repositories go live by themselves.
+
+**The coordinator then**: checks that https://sculptforge.app/apt/dists/stable/InRelease is signed by that
+fingerprint (`gpg --show-keys` on `/apt/sculptforge.asc`), adds the snippets above and the fingerprint to
+docs/guide/installing.md ("Package managers": apt and dnf **Available**), install/README.md and the home page note,
+and replies on #149 (credit @NicTanghe).
+
+## Rotation and compromise
+
+- **Suspected leak** (a secret exposed, a stolen laptop with the password-manager copy unlocked): make a new key
+ exactly as above, replace both secrets, release at once, and announce in the release notes, #announcements and
+ #149 that apt users re-run the `curl ... sculptforge.asc` line (dnf asks to import the new key by itself on the
+ next upgrade). Publish the old key's revocation certificate on docs/guide/security.md.
+- **Planned rotation** (optional, e.g. every 5 years or a stronger algorithm): the same steps without the revocation;
+ announce a release ahead.
+- **Who can read the secret**: maintainers with admin on the repository, through a workflow run in the `release`
+ environment from a `v*` tag. Keep that environment's deployment rule at tags `v*` only.
+
+## Not in scope here
+
+- The app's update banner for a `.deb`/`.rpm` install still says to download the new file; once the repositories
+ are live it can say `sudo apt upgrade` / `sudo dnf upgrade` (small app change, its own branch).
+- Flathub, winget and the AUR are separate (docs/guide/installing.md, "Package managers").
diff --git a/tools/publish/package_repos.sh b/tools/publish/package_repos.sh
new file mode 100755
index 00000000..4065a6a3
--- /dev/null
+++ b/tools/publish/package_repos.sh
@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+# Signed apt and dnf repository metadata for one release's .deb and .rpm files (design: docs/design/package-repos.md).
+# tools/publish/package_repos.sh DIST OUT.tar.gz
+# DIST holds the release's versioned sculptforge_<v>_<arch>.deb and sculptforge-<v>-<rel>.<arch>.rpm. Writes
+# OUT.tar.gz with the metadata only (no packages):
+# apt/dists/stable/{InRelease,Release,Release.gpg,main/binary-{amd64,arm64}/Packages{,.gz}}, apt/sculptforge.asc
+# rpm/repodata/* (repomd.xml signed: repomd.xml.asc), rpm/sculptforge.repo, rpm/sculptforge.asc
+# FILES.txt: "<path on the site> <release asset name>" for every package the metadata names
+# website/apt and website/rpm are put together from it by tools/publish/package_repos_fetch.sh (pages.yml), which
+# downloads those assets. The signature covers each package's SHA-256, so apt and dnf refuse any other bytes.
+# Signing key: REPO_SIGNING_KEY (armored OpenPGP private key) and REPO_SIGNING_PASSPHRASE in the environment, as
+# the release workflow's `release` environment provides them. Needs apt-ftparchive (apt-utils), createrepo_c, gpg.
+set -euo pipefail
+dist=$(cd "$1" && pwd)
+out=$(realpath -m "$2")
+[ -n "${REPO_SIGNING_KEY:-}" ] || { echo "package_repos: REPO_SIGNING_KEY is empty" >&2; exit 2; }
+for t in apt-ftparchive createrepo_c gpg; do command -v "$t" >/dev/null || { echo "package_repos: $t missing" >&2; exit 2; }; done
+
+work=$(mktemp -d)
+trap 'rm -rf "$work"' EXIT
+export GNUPGHOME="$work/gnupg"
+mkdir -m 700 "$GNUPGHOME"
+printf '%s\n' "$REPO_SIGNING_KEY" | gpg --batch --quiet --import
+fpr=$(gpg --batch --with-colons --list-secret-keys | awk -F: '$1 == "fpr" {print $10; exit}')
+[ -n "$fpr" ] || { echo "package_repos: REPO_SIGNING_KEY holds no secret key" >&2; exit 2; }
+sign() { gpg --batch --yes --quiet --pinentry-mode loopback --passphrase "${REPO_SIGNING_PASSPHRASE:-}" \
+ --digest-algo SHA512 --local-user "$fpr" "$@"; }
+
+shopt -s nullglob
+debs=("$dist"/sculptforge_[0-9]*_*.deb)
+rpms=("$dist"/sculptforge-[0-9]*.rpm)
+[ ${#debs[@]} -gt 0 ] && [ ${#rpms[@]} -gt 0 ] || { echo "package_repos: no versioned .deb or .rpm in $dist" >&2; exit 2; }
+root="$work/out"
+mkdir -p "$root/apt" "$root/rpm"
+: > "$root/FILES.txt"
+
+# apt: one suite (stable), one component (main), the packages in pool/.
+pool=pool/main/s/sculptforge
+mkdir -p "$root/apt/$pool"
+for f in "${debs[@]}"; do
+ ln -s "$f" "$root/apt/$pool/$(basename "$f")"
+ echo "apt/$pool/$(basename "$f") $(basename "$f")" >> "$root/FILES.txt"
+done
+archs=()
+for a in amd64 arm64; do
+ compgen -G "$root/apt/$pool/*_$a.deb" >/dev/null || continue
+ archs+=("$a")
+ d="$root/apt/dists/stable/main/binary-$a"
+ mkdir -p "$d"
+ (cd "$root/apt" && apt-ftparchive --arch "$a" packages "$pool") > "$d/Packages"
+ gzip -9kn "$d/Packages"
+done
+(cd "$root/apt/dists/stable" && apt-ftparchive \
+ -o APT::FTPArchive::Release::Origin=SculptForge -o APT::FTPArchive::Release::Label=SculptForge \
+ -o APT::FTPArchive::Release::Suite=stable -o APT::FTPArchive::Release::Codename=stable \
+ -o APT::FTPArchive::Release::Components=main -o "APT::FTPArchive::Release::Architectures=${archs[*]}" \
+ -o APT::FTPArchive::Release::Description="SculptForge releases" release . > "$work/Release")
+mv "$work/Release" "$root/apt/dists/stable/Release"
+sign --clearsign -o "$root/apt/dists/stable/InRelease" "$root/apt/dists/stable/Release"
+sign --armor --detach-sign -o "$root/apt/dists/stable/Release.gpg" "$root/apt/dists/stable/Release"
+rm -r "$root/apt/pool" # the site fetches them (FILES.txt)
+
+# rpm: one repository for both architectures (dnf picks its own), the packages in packages/.
+mkdir -p "$root/rpm/packages"
+for f in "${rpms[@]}"; do
+ cp "$f" "$root/rpm/packages/" # createrepo_c reads headers; copies are dropped below
+ echo "rpm/packages/$(basename "$f") $(basename "$f")" >> "$root/FILES.txt"
+done
+createrepo_c --quiet --no-database --simple-md-filenames "$root/rpm" >/dev/null
+sign --armor --detach-sign -o "$root/rpm/repodata/repomd.xml.asc" "$root/rpm/repodata/repomd.xml"
+rm -r "$root/rpm/packages"
+cat > "$root/rpm/sculptforge.repo" <<'EOF'
+[sculptforge]
+name=SculptForge
+baseurl=https://sculptforge.app/rpm
+enabled=1
+# The repository metadata is signed and lists every package's SHA-256, so dnf checks each download against the
+# signed checksum. The .rpm files themselves are the release's exact bytes, unsigned (docs/design/package-repos.md).
+repo_gpgcheck=1
+gpgcheck=0
+gpgkey=https://sculptforge.app/rpm/sculptforge.asc
+EOF
+
+gpg --batch --armor --export "$fpr" > "$root/apt/sculptforge.asc"
+cp "$root/apt/sculptforge.asc" "$root/rpm/sculptforge.asc"
+tar -C "$root" -czf "$out" --owner=0 --group=0 --sort=name FILES.txt apt rpm
+echo "package_repos: $(basename "$out"): apt (${archs[*]}), rpm ($(ls "$dist"/sculptforge-[0-9]*.rpm | sed 's/.*\.\([^.]*\)\.rpm/\1/' | tr '\n' ' ')), key $fpr"
diff --git a/tools/publish/package_repos_fetch.sh b/tools/publish/package_repos_fetch.sh
new file mode 100755
index 00000000..bda7ea91
--- /dev/null
+++ b/tools/publish/package_repos_fetch.sh
@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+# Puts the apt and dnf repositories into the website (pages.yml): the latest release's signed metadata
+# (sculptforge-package-repos.tar.gz, made by tools/publish/package_repos.sh in the release workflow) plus the
+# release's .deb and .rpm files it names. Every download must match the release's SHA256SUMS.txt.
+# tools/publish/package_repos_fetch.sh TAG WEBSITE_DIR [REPO]
+# A release without the metadata (before the signing key exists) leaves the site as it is: exit 0, a note.
+set -euo pipefail
+tag=$1 site=$2 repo=${3:-islandmed/SculptForge}
+base="https://github.com/$repo/releases/download/$tag"
+work=$(mktemp -d)
+trap 'rm -rf "$work"' EXIT
+# PACKAGE_REPOS_LOCAL=DIR takes the assets from DIR instead of the release (the test, .github/workflows/repos.yml).
+get() {
+ if [ -n "${PACKAGE_REPOS_LOCAL:-}" ]; then cp "$PACKAGE_REPOS_LOCAL/$1" "$2"
+ else curl -fsSL --retry 4 --retry-all-errors -o "$2" "$base/$1"; fi
+}
+
+get SHA256SUMS.txt "$work/SHA256SUMS.txt"
+check() { # check <asset name> <file>
+ local want
+ want=$(awk -v n="$1" '$2 == n || $2 == "*" n {print $1}' "$work/SHA256SUMS.txt")
+ [ -n "$want" ] || { echo "package_repos_fetch: $1 is not in $tag's SHA256SUMS.txt" >&2; exit 1; }
+ [ "$(sha256sum "$2" | cut -d' ' -f1)" = "$want" ] || { echo "package_repos_fetch: $1 doesn't match SHA256SUMS.txt" >&2; exit 1; }
+}
+if ! grep -q ' \*\?sculptforge-package-repos.tar.gz$' "$work/SHA256SUMS.txt"; then
+ echo "package_repos_fetch: $tag has no package repositories (no REPO_SIGNING_KEY when it was released): skipped"
+ exit 0
+fi
+get sculptforge-package-repos.tar.gz "$work/repos.tar.gz"
+check sculptforge-package-repos.tar.gz "$work/repos.tar.gz"
+mkdir "$work/x"
+tar -C "$work/x" -xzf "$work/repos.tar.gz" --no-same-owner
+rm -rf "$site/apt" "$site/rpm"
+cp -r "$work/x/apt" "$work/x/rpm" "$site/"
+while read -r path asset; do
+ case "$path" in apt/*|rpm/*) ;; *) echo "package_repos_fetch: unexpected path $path" >&2; exit 1 ;; esac
+ case "$path$asset" in *..*) echo "package_repos_fetch: unexpected path $path" >&2; exit 1 ;; esac
+ mkdir -p "$site/$(dirname "$path")"
+ get "$asset" "$site/$path"
+ check "$asset" "$site/$path"
+done < "$work/x/FILES.txt"
+echo "package_repos_fetch: $tag's apt and dnf repositories in $site/apt and $site/rpm"