From 1003ae407b591faece2a44c24da4818f2aeb019c Mon Sep 17 00:00:00 2001 From: Peiikai <339721950+peiikai@users.noreply.github.com> Date: Sun, 15 Nov 2026 18:16:41 -0600 Subject: [PATCH 1/8] Signed update manifests for releases and nightlies Every Windows and Linux release file gets a manifest (update-.txt): its version, platform, size and sha256, and for the zips every app file inside, signed with one Ed25519 key (Monocypher 4.0.2, CC0, vendored in third_party/monocypher). tools/update_sign.cpp makes the key, the manifests and the Sparkle signatures for macOS; tools/update_manifest.sh runs it in release.yml and nightly.yml with the UPDATE_SIGNING_KEY secret, and only warns when the secret is missing, so builds keep shipping without it. nightly.yml also lists the pull requests merged since the previous round under "Changes" in the nightly notes, keeping the last 30 rounds, for the start screen's update dialog. Asset names and tag formats are unchanged; the manifests' names never match a nightly file. Test: tools/test_update.cpp (manifest parse, signature, unsafe paths, swap and rollback). Co-Authored-By: Claude Opus 5.5 --- .github/workflows/nightly.yml | 27 +- .github/workflows/release.yml | 30 +- README.md | 4 +- runtime/update_core.h | 400 +++ third_party/monocypher/LICENCE.md | 167 ++ third_party/monocypher/README.md | 4 + third_party/monocypher/monocypher-ed25519.c | 500 ++++ third_party/monocypher/monocypher-ed25519.h | 140 + third_party/monocypher/monocypher.c | 2956 +++++++++++++++++++ third_party/monocypher/monocypher.h | 321 ++ tools/nightly_publish.sh | 7 + tools/test_update.cpp | 230 ++ tools/update_manifest.sh | 21 + tools/update_sign.cpp | 155 + 14 files changed, 4953 insertions(+), 9 deletions(-) create mode 100644 runtime/update_core.h create mode 100644 third_party/monocypher/LICENCE.md create mode 100644 third_party/monocypher/README.md create mode 100644 third_party/monocypher/monocypher-ed25519.c create mode 100644 third_party/monocypher/monocypher-ed25519.h create mode 100644 third_party/monocypher/monocypher.c create mode 100644 third_party/monocypher/monocypher.h create mode 100644 tools/test_update.cpp create mode 100755 tools/update_manifest.sh create mode 100644 tools/update_sign.cpp diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index fa8db3dfa..14f788400 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -78,9 +78,23 @@ jobs: echo "- Linux: \`linux-x86_64.AppImage\`, \`linux-aarch64.AppImage\`" echo "- Android: \`android.apk\`, installed as its own app, LAS Recomp Nightly, beside the release one" echo "- iPhone and iPad: \`iOS.laskit\`, made into the app with a nightly desktop build of the same date" + # Changes: the pull requests merged since the previous round, newest round first, with the earlier + # rounds' lists kept (the last 30), so a player several nightlies behind sees everything in the start + # screen's update dialog. Each round starts with a "nightly-changes: " line; the dialog shows the + # rounds newer than its own build (runtime/ui/update_notes.h). + CHANGES= if [ -n "$RSHA" ]; then - MERGES=$(gh api "repos/$GH_REPO/compare/$RSHA...$SHA" --jq '.commits[] | select(.parents | length > 1) | .commit.message | split("\n") | .[0]' 2>/dev/null | sed -n 's/^Merge pull request \(#[0-9]*\).*/\1/p' | tr '\n' ' ' || true) - [ -n "$MERGES" ] && { echo; echo "New since the previous nightly: $MERGES"; } + CHANGES=$(gh api "repos/$GH_REPO/compare/$RSHA...$SHA" --jq '.commits[] | select(.parents | length > 1) | .commit.message | capture("^Merge pull request #(?[0-9]+)[^\n]*\n\n(?[^\n]+)") | "- \(.t) (#\(.n))"' 2>/dev/null | tac || true) + fi + OLD=$(awk '/^$/ { n++ } n && n < 30 && !/^To report a problem/' <<< "$BODY" | sed '/^" + echo "**$(date -u -d "${STAMP::8}" '+%Y-%m-%d')**"; echo + echo "$CHANGES"; echo + fi + [ -n "$OLD" ] && echo "$OLD" fi echo echo "To report a problem, open an [issue]($URL/issues), say it's a nightly and which date, and attach the log (\`lasrecomp.log\` in the data folder)." @@ -283,6 +297,9 @@ jobs: bad=$(find "$D" -type d \( -name extracted -o -name 'generated*' -o -name exefs -o -name romfs \); find "$D" -name '*.c' ! -path '*/zig/lib/*' ! -path '*/gamelib-src/gamelib_entry.c'; find "$D" -name 'lasgame*') [ -z "$bad" ] || { echo "::error::must not ship: $bad"; exit 1; } + - name: Update manifest + env: { UPDATE_SIGNING_KEY: '${{ secrets.UPDATE_SIGNING_KEY }}', VERSION: '${{ needs.plan.outputs.version }}' } + run: tools/update_manifest.sh "$VERSION" windows build/dist/*-windows.zip "build/dist/LAS Recomp" - name: Publish shell: bash # (Git Bash: gh is on its PATH, not MSYS2's) env: { GH_TOKEN: '${{ github.token }}', GH_REPO: '${{ github.repository }}' } @@ -349,6 +366,9 @@ jobs: bad=$(find "$D" -type d \( -name extracted -o -name 'generated*' -o -name exefs -o -name romfs \); find "$D" -name '*.c' ! -path '*/zig/lib/*' ! -path '*/gamelib-src/gamelib_entry.c'; find "$D" -name 'lasgame*') [ -z "$bad" ] || { echo "::error::must not ship: $bad"; exit 1; } + - name: Update manifest + env: { UPDATE_SIGNING_KEY: '${{ secrets.UPDATE_SIGNING_KEY }}', VERSION: '${{ needs.plan.outputs.version }}' } + run: tools/update_manifest.sh "$VERSION" windows-arm64 build/dist/*-windows-arm64.zip "build/dist/LAS Recomp" - name: Publish shell: bash # (Git Bash: gh is on its PATH, not MSYS2's) env: { GH_TOKEN: '${{ github.token }}', GH_REPO: '${{ github.repository }}' } @@ -404,6 +424,9 @@ jobs: find "$A" -type f \( -perm /111 -o -name '*.so*' \) | while read -r f; do if readelf -Ws --wide "$f" 2>/dev/null | grep ' f_70' >/dev/null; then echo "::error::game code in $f"; exit 1; fi done + - name: Update manifest + env: { UPDATE_SIGNING_KEY: '${{ secrets.UPDATE_SIGNING_KEY }}', VERSION: '${{ needs.plan.outputs.version }}' } + run: tools/update_manifest.sh "$VERSION" linux-${{ matrix.arch }} build/dist/*-linux-${{ matrix.arch }}.AppImage - name: Publish env: { GH_TOKEN: '${{ github.token }}', GH_REPO: '${{ github.repository }}' } run: tools/nightly_publish.sh build/dist/*-linux-${{ matrix.arch }}.AppImage linux-${{ matrix.arch }}.AppImage diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 40dd5e6c5..6c64f9a20 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -219,10 +219,16 @@ jobs: find "$D" -name '*.c' ! -path '*/zig/lib/*' ! -path '*/gamelib-src/gamelib_entry.c'; find "$D" -name 'lasgame*') [ -z "$bad" ] || { echo "::error::must not ship: $bad"; exit 1; } ls -la build/dist + # the self-updater's signed manifest (tools/update_manifest.sh; none without the key: Download only) + - name: Update manifest + env: { UPDATE_SIGNING_KEY: '${{ secrets.UPDATE_SIGNING_KEY }}', VERSION: '${{ needs.check.outputs.version }}' } + run: tools/update_manifest.sh "$VERSION" windows build/dist/*-windows.zip "build/dist/LAS Recomp" - uses: actions/upload-artifact@v4 with: name: windows - path: build/dist/*.zip + path: | + build/dist/*.zip + build/dist/update-*.txt if-no-files-found: error compression-level: 0 @@ -365,10 +371,15 @@ jobs: if readelf -Ws --wide "$f" 2>/dev/null | grep ' f_70' >/dev/null; then echo "::error::game code in $f"; exit 1; fi done ls -la build/dist + - name: Update manifest + env: { UPDATE_SIGNING_KEY: '${{ secrets.UPDATE_SIGNING_KEY }}', VERSION: '${{ needs.check.outputs.version }}' } + run: tools/update_manifest.sh "$VERSION" linux-${{ matrix.arch }} build/dist/*-linux-${{ matrix.arch }}.AppImage - uses: actions/upload-artifact@v4 with: name: linux-${{ matrix.arch }} - path: build/dist/*.AppImage + path: | + build/dist/*.AppImage + build/dist/update-*.txt if-no-files-found: error compression-level: 0 @@ -472,7 +483,8 @@ jobs: GH_REPO: ${{ github.repository }} run: | cd dist - ls -la + mkdir ../manifests && mv update-*.txt ../manifests/ 2>/dev/null || true # (the self-updater's, beside the files) + ls -la . ../manifests [ "$(ls | wc -l)" = 6 ] || { echo "::error::expected 6 files"; exit 1; } # (a test build: only the platforms its fix targets ship; the others were built as a compile check) for f in *; do @@ -481,11 +493,17 @@ jobs: *) echo "::error::unknown file $f"; exit 1 ;; esac [[ " $PLATFORMS " == *" $p "* ]] || { echo "built, not shipped: $f"; rm "$f"; } done + for m in ../manifests/update-*.txt; do # (a manifest goes up only with its platform's file) + [ -f "$m" ] || continue + plat=$(basename "$m" .txt); plat=${plat#update-} + ls ./*-"$plat".zip ./*-"$plat".AppImage >/dev/null 2>&1 || rm "$m" + done + MANIFESTS=(); for m in ../manifests/update-*.txt; do [ -f "$m" ] && MANIFESTS+=("$m"); done if [ "$EVENT" = release ]; then # (published on GitHub: attach the files, the notes get the sha256 table) gh release view "$TAG" --json body -q .body | grep -v '^> The download files are being built' > ../body.md || true { cat ../body.md; echo; echo "| File | sha256 |"; echo "|---|---|" for f in *; do echo "| \`${f// /.}\` | \`$(sha256sum "$f" | cut -d' ' -f1)\` |"; done; } > ../notes.md - gh release upload "$TAG" --clobber * + gh release upload "$TAG" --clobber * "${MANIFESTS[@]}" gh release edit "$TAG" --notes-file ../notes.md gh release view "$TAG" --json url,assets -q '.url, (.assets[] | "\(.name) \(.size)")' exit 0 @@ -506,9 +524,9 @@ jobs: if DRAFT=$(gh release view "$TAG" --json isDraft -q .isDraft 2>/dev/null); then [ "$DRAFT" = true ] || { echo "::error::release $TAG is already published: not touched"; exit 1; } gh release edit "$TAG" --draft --target "$SHA" --notes-file ../notes.md "${PRE[@]}" - gh release upload "$TAG" --clobber * + gh release upload "$TAG" --clobber * "${MANIFESTS[@]}" else - gh release create "$TAG" --draft --target "$SHA" --title "$TAG" --notes-file ../notes.md "${PRE[@]}" * + gh release create "$TAG" --draft --target "$SHA" --title "$TAG" --notes-file ../notes.md "${PRE[@]}" * "${MANIFESTS[@]}" fi gh release view "$TAG" --json url,isDraft,assets -q '.url, .isDraft, (.assets[] | "\(.name) \(.size)")' diff --git a/README.md b/README.md index d01816d85..2d34594c2 100644 --- a/README.md +++ b/README.md @@ -296,6 +296,8 @@ none of their files are used): - [BIZ UDPGothic](https://github.com/googlefonts/morisawa-biz-ud-gothic) by Morisawa - the game's text on Linux when you haven't imported the Switch fonts: a free font from the same universal-design gothic family as the Switch's UD Shin Go (SIL Open Font License 1.1, `third_party/fonts/BIZUDPGothic/OFL.txt`) - [DejaVu Sans](https://dejavu-fonts.github.io) - the in-game menu and button letters when no system font fits, and the game text's last resort (Bitstream Vera / DejaVu license, `third_party/fonts/DejaVu/LICENSE`) - [Vulkan Memory Allocator](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator) - Windows and Linux renderer (MIT) +- [Monocypher](https://monocypher.org) by Loup Vaillant and contributors - checks the signature of updates on Windows and + Linux (CC0, `third_party/monocypher/LICENCE.md`) - [SMAA](https://github.com/iryoku/smaa) by Jorge Jimenez, Jose I. Echevarria, Belen Masia, Fernando Navarro and Diego Gutierrez - the anti-aliasing option (MIT, `third_party/smaa/LICENSE.txt`) - [AMD FidelityFX Super Resolution 1](https://github.com/GPUOpen-Effects/FidelityFX-FSR) - the Windows and Linux upscaler @@ -348,7 +350,7 @@ LAS Recomp's own code (the recompiler tools, the runtime, the randomizer additio Vulkan Memory Allocator (MIT), SMAA (MIT), AMD FSR 1 (MIT), the Baloo 2 and BIZ UDPGothic fonts (SIL OFL 1.1), the DejaVu Sans font (Bitstream Vera / DejaVu license), SDL 3 (zlib), FFmpeg (LGPL 2.1+, linked dynamically, and statically in the iOS app), the Zig compiler (MIT; its LLVM / Clang / LLD: Apache 2.0 with LLVM exceptions; its C library headers keep their own licenses), the iOS kit's Mach-O linker (LLD as built by the Rust project: Apache 2.0 with LLVM exceptions), miniz -(MIT: the iOS kit and the .ipa it makes), and the generator helpers' bundled libraries listed under Credits (oead / evfl / Keystone in the seed +(MIT: the iOS kit and the .ipa it makes), Monocypher (CC0: update signatures), and the generator helpers' bundled libraries listed under Credits (oead / evfl / Keystone in the seed generator and Unicorn in the game code generator are under the GPL, versions in the table below: each helper is a separate program the game runs, and its sources are this repository plus those projects' published sources). The iOS app is the exception: iOS runs no helper processes, so it embeds CPython and the seed generator's packages - oead, evfl and Keystone (GPL 2.0+ / GPL 2.0), diff --git a/runtime/update_core.h b/runtime/update_core.h new file mode 100644 index 000000000..ac712bceb --- /dev/null +++ b/runtime/update_core.h @@ -0,0 +1,400 @@ +// The self-updater's core (runtime/update.cpp drives it; tools/test_update.cpp tests it without network or game): +// the signed update manifest, the list of app files it may replace, and the journaled swap with its rollback. +// +// Manifest: one per platform and release or nightly round, published next to the file as update-.txt by +// tools/update_sign (release.yml, nightly.yml). Plain text, LF lines: +// LAS Recomp update 1 +// version (v0.7.0, nightly-202611161000-abc1234) +// platform (LARECOMP_PLATFORM: windows, windows-arm64, linux-x86_64, ...) +// asset (the file on the release page) +// file (zips: each app file inside, relative to the zip's top folder; none for AppImages) +// signature (over every byte before this line; the key: UPDATE_PUBLIC_KEY in update.cpp) +// +// Swap: the new files are staged in /.lasrecomp-update/new/, then each one is moved into place, the file it +// replaces moved to old/ first. Every step is written to the journal (state) before it happens, so a swap killed +// halfway is undone on the next start. The old files stay until the new version reaches the start screen once; if it +// starts and never gets there, the next start puts them back (upd_boot). +#pragma once +#include +#include +#include +#include + +#include +#include + +#ifdef _WIN32 +#include +#include +#include +#else +#include +#include +#endif + +#include "../third_party/monocypher/monocypher-ed25519.h" +#include "cache_sha256.h" + +struct UpdFile { + std::string path; // relative, '/' separated + uint64_t size = 0; + std::string sha256; // 64 lowercase hex +}; +struct UpdManifest { + std::string version, platform; + std::string asset, asset_sha256; + uint64_t asset_size = 0; + std::vector files; +}; + +static inline bool upd_hex(const std::string &s, uint8_t *out, size_t n) { + if (s.size() != n * 2) return false; + for (size_t i = 0; i < n; i++) { + int v = 0; + for (int k = 0; k < 2; k++) { + char c = s[i * 2 + k]; + int d = c >= '0' && c <= '9' ? c - '0' : c >= 'a' && c <= 'f' ? c - 'a' + 10 : -1; // (lowercase only) + if (d < 0) return false; + v = v * 16 + d; + } + out[i] = (uint8_t)v; + } + return true; +} +static inline bool upd_is_sha(const std::string &s) { + uint8_t b[32]; + return upd_hex(s, b, 32); +} +static inline bool upd_parse_u64(const std::string &s, uint64_t *v) { + if (s.empty() || s.size() > 15) return false; // (under 1 PB: no overflow) + *v = 0; + for (char c : s) { + if (c < '0' || c > '9') return false; + *v = *v * 10 + (uint64_t)(c - '0'); + } + return true; +} +static inline std::string upd_lower(std::string s) { + for (char &c : s) if (c >= 'A' && c <= 'Z') c = (char)(c - 'A' + 'a'); + return s; +} + +// The update work folder, in the app's folder (removed once the new version reached the start screen) +#define UPD_WORK ".lasrecomp-update" + +// A path the updater may write in the app's folder: relative, plain components, never one of the player's data +// entries. On Windows the data folder is the app's folder by default (runtime/paths.h), so a manifest that named a +// save or the settings would overwrite them: refused here even though the manifest is signed (a packaging mistake +// must not cost anyone their saves). +static inline bool upd_safe_path(const std::string &p) { + if (p.empty() || p.size() > 400 || p[0] == '/' || p.back() == '/') return false; + for (unsigned char c : p) + if (c < 0x20 || c == '\\' || c == ':' || c == '*' || c == '?' || c == '"' || c == '<' || c == '>' || c == '|' || + c == 0x7f) + return false; + std::string first; + for (size_t at = 0; at <= p.size();) { + size_t sl = p.find('/', at); + if (sl == std::string::npos) sl = p.size(); + std::string c = p.substr(at, sl - at); + if (c.empty() || c == "." || c == ".." || c.back() == '.' || c.back() == ' ') return false; // (Windows drops those) + if (first.empty()) first = upd_lower(c); + at = sl + 1; + } + // runtime/paths.c DATA_ENTRIES and the pointer file, the logs, our own work folder + static const char *const data[] = {"save", "rando", "larecomp.ini", "fonts", "gamecontrollerdb.txt", "cache", + "extracted", "data_root.txt", UPD_WORK}; + for (const char *d : data) + if (first == d) return false; + if (!first.compare(0, 9, "lasrecomp") && first.size() > 4 && !first.compare(first.size() - 4, 4, ".log")) return false; + return true; +} + +// Checks the signature, then reads the manifest. false: why says what's wrong (nothing in m is to be trusted). +static inline bool upd_parse_manifest(const std::string &text, const uint8_t pub[32], UpdManifest *m, std::string *why) { + *m = UpdManifest(); + auto fail = [&](const char *w) { if (why) *why = w; return false; }; + size_t sig = text.rfind("\nsignature "); + if (sig == std::string::npos) return fail("no signature"); + std::string sighex = text.substr(sig + 11); + if (!sighex.empty() && sighex.back() == '\n') sighex.pop_back(); + uint8_t sb[64]; + if (!upd_hex(sighex, sb, 64)) return fail("bad signature line"); + if (crypto_ed25519_check(sb, pub, (const uint8_t *)text.data(), sig + 1) != 0) return fail("signature does not match"); + std::string body = text.substr(0, sig + 1); + if (body.find('\r') != std::string::npos || body.find('\0') != std::string::npos) return fail("bad characters"); + std::vector lines; + for (size_t at = 0; at < body.size();) { + size_t nl = body.find('\n', at); + lines.push_back(body.substr(at, nl - at)); + at = nl + 1; + } + if (lines.empty() || lines[0] != "LAS Recomp update 1") return fail("not an update manifest (or a newer format)"); + // " " (the rest may hold spaces) + auto sized = [](const std::string &l, uint64_t *size, std::string *sha, std::string *rest) { + size_t a = l.find(' '), b = a == std::string::npos ? a : l.find(' ', a + 1); + if (b == std::string::npos) return false; + *sha = l.substr(a + 1, b - a - 1); + *rest = l.substr(b + 1); + return upd_parse_u64(l.substr(0, a), size) && upd_is_sha(*sha) && !rest->empty(); + }; + std::vector seen; + for (size_t i = 1; i < lines.size(); i++) { + const std::string &l = lines[i]; + if (!l.compare(0, 8, "version ")) m->version = l.substr(8); + else if (!l.compare(0, 9, "platform ")) m->platform = l.substr(9); + else if (!l.compare(0, 6, "asset ")) { + if (!sized(l.substr(6), &m->asset_size, &m->asset_sha256, &m->asset)) return fail("bad asset line"); + if (m->asset.find('/') != std::string::npos || m->asset.find('\\') != std::string::npos) return fail("bad asset name"); + } else if (!l.compare(0, 5, "file ")) { + UpdFile f; + if (!sized(l.substr(5), &f.size, &f.sha256, &f.path)) return fail("bad file line"); + if (!upd_safe_path(f.path)) return fail("a file outside the app"); + std::string low = upd_lower(f.path); // (Windows: one file whatever the case) + for (const std::string &s : seen) + if (s == low) return fail("a file listed twice"); + seen.push_back(low); + m->files.push_back(f); + } else return fail("unknown line"); + } + if (m->version.empty() || m->platform.empty() || m->asset.empty()) return fail("version, platform or asset missing"); + return true; +} + +// The manifest's text before its signature line (tools/update_sign.c writes it, then signs it) +static inline std::string upd_manifest_text(const UpdManifest &m) { + std::string t = "LAS Recomp update 1\nversion " + m.version + "\nplatform " + m.platform + "\nasset " + + std::to_string(m.asset_size) + " " + m.asset_sha256 + " " + m.asset + "\n"; + for (const UpdFile &f : m.files) t += "file " + std::to_string(f.size) + " " + f.sha256 + " " + f.path + "\n"; + return t; +} + +// ---- files +static inline std::string upd_join(const std::string &a, const std::string &b) { return a.empty() ? b : a + "/" + b; } +static inline bool upd_exists(const std::string &p) { + struct stat st; + return stat(p.c_str(), &st) == 0; +} +static inline bool upd_is_file(const std::string &p) { + struct stat st; + return stat(p.c_str(), &st) == 0 && S_ISREG(st.st_mode); +} +static inline std::string upd_file_sha256(const std::string &p, uint64_t *size) { + FILE *f = fopen(p.c_str(), "rb"); + if (!f) return ""; + CacheSha256 h; + static thread_local char buf[1 << 16]; + size_t n; + uint64_t total = 0; + while ((n = fread(buf, 1, sizeof buf, f)) > 0) h.add(buf, n), total += n; + bool err = ferror(f); + fclose(f); + if (err) return ""; + if (size) *size = total; + return h.finish(); +} +static inline int upd_mkdir(const char *d) { +#ifdef _WIN32 + return _mkdir(d); +#else + return mkdir(d, 0755); +#endif +} +// The folders above path/name (mkdir -p of its parent) +static inline bool upd_mkdirs_for(const std::string &file) { + for (size_t at = 1; (at = file.find('/', at)) != std::string::npos; at++) { + std::string d = file.substr(0, at); + if (d.size() == 2 && d[1] == ':') continue; // (C:) + if (upd_mkdir(d.c_str()) != 0 && !upd_exists(d)) return false; + } + return true; +} +// rename(), replacing the target (Windows: rename() refuses an existing target; a running .exe or loaded DLL may be +// moved but not deleted, which is why every file being replaced is moved aside, never deleted) +static inline bool upd_move(const std::string &from, const std::string &to) { +#ifdef _WIN32 + return MoveFileExA(from.c_str(), to.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) != 0; +#else + return rename(from.c_str(), to.c_str()) == 0; +#endif +} +static inline bool upd_remove_tree(const std::string &p) { + struct stat st; +#ifdef _WIN32 + if (stat(p.c_str(), &st) != 0) return true; + if (!S_ISDIR(st.st_mode)) { SetFileAttributesA(p.c_str(), FILE_ATTRIBUTE_NORMAL); return DeleteFileA(p.c_str()) != 0; } + WIN32_FIND_DATAA fd; + HANDLE h = FindFirstFileA((p + "/*").c_str(), &fd); + bool ok = true; + if (h != INVALID_HANDLE_VALUE) { + do { + if (!strcmp(fd.cFileName, ".") || !strcmp(fd.cFileName, "..")) continue; + ok &= upd_remove_tree(p + "/" + fd.cFileName); + } while (FindNextFileA(h, &fd)); + FindClose(h); + } + return RemoveDirectoryA(p.c_str()) != 0 && ok; +#else + if (lstat(p.c_str(), &st) != 0) return true; + if (!S_ISDIR(st.st_mode)) return unlink(p.c_str()) == 0; + bool ok = true; + if (DIR *d = opendir(p.c_str())) { + while (struct dirent *e = readdir(d)) { + if (!strcmp(e->d_name, ".") || !strcmp(e->d_name, "..")) continue; + ok &= upd_remove_tree(p + "/" + e->d_name); + } + closedir(d); + } + return rmdir(p.c_str()) == 0 && ok; +#endif +} +// The folder accepts new files (a probe file made and removed): false = Update can't work here (Download still does) +static inline bool upd_dir_writable(const std::string &dir) { + std::string probe = upd_join(dir, ".lasrecomp-write-test"); + FILE *f = fopen(probe.c_str(), "wb"); + if (!f) return false; + bool ok = fputs("x", f) >= 0; + ok &= fclose(f) == 0; + remove(probe.c_str()); + return ok; +} + +// A staged copy checked against the manifest: every listed file present with its size and sha256 +static inline bool upd_check_staged(const std::string &staged, const std::vector &files, std::string *why) { + for (const UpdFile &f : files) { + uint64_t size = 0; + std::string sha = upd_file_sha256(upd_join(staged, f.path), &size); + if (sha.empty()) { if (why) *why = "missing in the download: " + f.path; return false; } + if (size != f.size || sha != f.sha256) { if (why) *why = "doesn't match the manifest: " + f.path; return false; } + } + return true; +} + +// ---- the swap and its journal (/.lasrecomp-update/state) +// Lines: "state ", "version ", "from ", then one line per file before it is +// touched: "moved " (an old file moved to old/) or "added " (none there before). The state line is +// rewritten in place (it's first, and the word is padded to 9 letters) after the journal is synced. +struct UpdPaths { + std::string app; // the app's folder + std::string work() const { return upd_join(app, UPD_WORK); } + std::string state() const { return upd_join(work(), "state"); } + std::string old_dir() const { return upd_join(work(), "old"); } + std::string new_dir() const { return upd_join(work(), "new"); } +}; +static inline void upd_sync(FILE *f) { + fflush(f); +#ifdef _WIN32 + _commit(_fileno(f)); +#else + fsync(fileno(f)); +#endif +} +static inline bool upd_set_state(const UpdPaths &p, const char *state) { + char word[10]; + snprintf(word, sizeof word, "%-9s", state); + FILE *f = fopen(p.state().c_str(), "r+b"); + if (!f) return false; + bool ok = fseek(f, 6, SEEK_SET) == 0 && fwrite(word, 1, 9, f) == 9; + upd_sync(f); + return fclose(f) == 0 && ok; +} +struct UpdJournal { + std::string state, version, from; + std::vector> entries; // (moved, path) +}; +static inline bool upd_read_journal(const UpdPaths &p, UpdJournal *j) { + FILE *f = fopen(p.state().c_str(), "rb"); + if (!f) return false; + *j = UpdJournal(); + char line[1024]; + while (fgets(line, sizeof line, f)) { + std::string l = line; + if (!l.empty() && l.back() == '\n') l.pop_back(); + else if (!feof(f)) continue; // (too long: not ours) + if (!l.compare(0, 6, "state ")) { + j->state = l.substr(6); + while (!j->state.empty() && j->state.back() == ' ') j->state.pop_back(); + } + else if (!l.compare(0, 8, "version ")) j->version = l.substr(8); + else if (!l.compare(0, 5, "from ")) j->from = l.substr(5); + else if (!l.compare(0, 6, "moved ") && upd_safe_path(l.substr(6))) j->entries.push_back({true, l.substr(6)}); + else if (!l.compare(0, 6, "added ") && upd_safe_path(l.substr(6))) j->entries.push_back({false, l.substr(6)}); + // (a half-written last line - killed while writing it - fails upd_safe_path or is ignored: its file wasn't + // touched yet) + } + fclose(f); + return !j->state.empty(); +} + +// Moves the staged files (new/) into the app folder. Test hook: stop_after = n stops (as if killed) after n +// files, journal and all, returning false. +static inline bool upd_swap(const UpdPaths &p, const std::vector &files, const std::string &version, + const std::string &from, std::string *why, int stop_after = -1) { + FILE *j = fopen(p.state().c_str(), "wb"); + if (!j) { if (why) *why = "can't write the update journal"; return false; } + fprintf(j, "state %-9s\nversion %s\nfrom %s\n", "swapping", version.c_str(), from.c_str()); + upd_sync(j); + int done = 0; + for (const UpdFile &f : files) { + if (stop_after >= 0 && done == stop_after) { fclose(j); if (why) *why = "stopped (test)"; return false; } + std::string dst = upd_join(p.app, f.path), src = upd_join(p.new_dir(), f.path), old = upd_join(p.old_dir(), f.path); + bool had = upd_exists(dst); + fprintf(j, "%s %s\n", had ? "moved" : "added", f.path.c_str()); + upd_sync(j); + if (had && !(upd_mkdirs_for(old) && upd_move(dst, old))) { + fclose(j); + if (why) *why = "can't move aside: " + f.path; + return false; + } + if (!(upd_mkdirs_for(dst) && upd_move(src, dst))) { + fclose(j); + if (why) *why = "can't put in place: " + f.path; + return false; + } + done++; + } + fclose(j); + if (stop_after == done) { if (why) *why = "stopped (test)"; return false; } + if (!upd_set_state(p, "installed")) { if (why) *why = "can't finish the update journal"; return false; } + return true; +} + +// Puts the old files back (a swap that didn't finish, or a new version that never reached the start screen) and +// removes the work folder. A file in the way (the new one, perhaps running) is moved into trash/ rather than deleted. +static inline bool upd_restore(const UpdPaths &p, const UpdJournal &j) { + bool ok = true; + int n = 0; + std::string trash = upd_join(p.work(), "trash"); + for (auto it = j.entries.rbegin(); it != j.entries.rend(); ++it) { + std::string dst = upd_join(p.app, it->second), old = upd_join(p.old_dir(), it->second); + if (it->first && !upd_exists(old)) continue; // (journaled, never moved: the old file is still in place) + if (upd_exists(dst)) { + std::string t = upd_join(trash, std::to_string(n++)); + if (!(upd_mkdirs_for(t) && upd_move(dst, t))) { ok = false; continue; } + } + if (it->first && !upd_move(old, dst)) ok = false; + } + if (ok) upd_remove_tree(p.work()); // (trash/ may hold a running .exe: removed as far as it can be, next time the rest) + return ok; +} + +// At start, before anything else of the app's is loaded. this_version: LARECOMP_VERSION. +enum { UPD_BOOT_NOTHING, UPD_BOOT_RESTORED, UPD_BOOT_STARTED }; +static inline int upd_boot(const UpdPaths &p, const std::string &this_version) { + UpdJournal j; + if (!upd_read_journal(p, &j)) { + if (upd_exists(p.work())) upd_remove_tree(p.work()); // (a download that never got to the swap) + return UPD_BOOT_NOTHING; + } + if (j.state == "swapping" || j.state == "started") return upd_restore(p, j) ? UPD_BOOT_RESTORED : UPD_BOOT_NOTHING; + if (j.state == "installed" && j.version == this_version) return upd_set_state(p, "started") ? UPD_BOOT_STARTED : UPD_BOOT_NOTHING; + // installed, but another version runs (put back by hand?): the old files aren't needed by anyone + upd_remove_tree(p.work()); + return UPD_BOOT_NOTHING; +} +// The new version reached the start screen: the old files go. +static inline void upd_commit(const UpdPaths &p) { + UpdJournal j; + if (upd_read_journal(p, &j) && j.state != "started") return; + upd_remove_tree(p.work()); +} diff --git a/third_party/monocypher/LICENCE.md b/third_party/monocypher/LICENCE.md new file mode 100644 index 000000000..9c3fae955 --- /dev/null +++ b/third_party/monocypher/LICENCE.md @@ -0,0 +1,167 @@ +Monocypher as a whole is dual-licensed. Choose whichever licence you +want from the two licences listed below. + +The first licence is a regular 2-clause BSD licence. The second licence +is the CC-0 from Creative Commons. It is intended to release Monocypher +to the public domain. The BSD licence serves as a fallback option. + +See the individual files for specific information about who contributed +to what file during which years. See below for special notes. + +Licence 1 (2-clause BSD) +------------------------ + +Copyright (c) 2017-2023, Loup Vaillant +Copyright (c) 2017-2019, Michael Savage +Copyright (c) 2017-2023, Fabio Scotoni +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the + distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +Licence 2 (CC-0) +---------------- + +> CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE +> LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN +> ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS +> INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES +> REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS +> PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM +> THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED +> HEREUNDER. + +### Statement of Purpose + +The laws of most jurisdictions throughout the world automatically confer +exclusive Copyright and Related Rights (defined below) upon the creator +and subsequent owner(s) (each and all, an "owner") of an original work +of authorship and/or a database (each, a "Work"). + +Certain owners wish to permanently relinquish those rights to a Work for +the purpose of contributing to a commons of creative, cultural and +scientific works ("Commons") that the public can reliably and without +fear of later claims of infringement build upon, modify, incorporate in +other works, reuse and redistribute as freely as possible in any form +whatsoever and for any purposes, including without limitation commercial +purposes. These owners may contribute to the Commons to promote the +ideal of a free culture and the further production of creative, cultural +and scientific works, or to gain reputation or greater distribution for +their Work in part through the use and efforts of others. + +For these and/or other purposes and motivations, and without any +expectation of additional consideration or compensation, the person +associating CC0 with a Work (the "Affirmer"), to the extent that he or +she is an owner of Copyright and Related Rights in the Work, voluntarily +elects to apply CC0 to the Work and publicly distribute the Work under +its terms, with knowledge of his or her Copyright and Related Rights in +the Work and the meaning and intended legal effect of CC0 on those +rights. + +1. **Copyright and Related Rights.** A Work made available under CC0 may + be protected by copyright and related or neighboring rights + ("Copyright and Related Rights"). Copyright and Related Rights + include, but are not limited to, the following: + + - the right to reproduce, adapt, distribute, perform, display, + communicate, and translate a Work; + - moral rights retained by the original author(s) and/or + performer(s); publicity and privacy rights pertaining to a person's + image or likeness depicted in a Work; + - rights protecting against unfair competition in regards to a Work, + subject to the limitations in paragraph 4(a), below; + - rights protecting the extraction, dissemination, use and reuse of + data in a Work; + - database rights (such as those arising under Directive 96/9/EC of + the European Parliament and of the Council of 11 March 1996 on the + legal protection of databases, and under any national + implementation thereof, including any amended or successor version + of such directive); and + - other similar, equivalent or corresponding rights throughout the + world based on applicable law or treaty, and any national + implementations thereof. + +2. **Waiver.** To the greatest extent permitted by, but not in + contravention of, applicable law, Affirmer hereby overtly, fully, + permanently, irrevocably and unconditionally waives, abandons, and + surrenders all of Affirmer's Copyright and Related Rights and + associated claims and causes of action, whether now known or unknown + (including existing as well as future claims and causes of action), + in the Work (i) in all territories worldwide, (ii) for the maximum + duration provided by applicable law or treaty (including future time + extensions), (iii) in any current or future medium and for any number + of copies, and (iv) for any purpose whatsoever, including without + limitation commercial, advertising or promotional purposes (the + "Waiver"). Affirmer makes the Waiver for the benefit of each member + of the public at large and to the detriment of Affirmer's heirs and + successors, fully intending that such Waiver shall not be subject to + revocation, rescission, cancellation, termination, or any other legal + or equitable action to disrupt the quiet enjoyment of the Work by the + public as contemplated by Affirmer's express Statement of Purpose. + +3. **Public License Fallback.** Should any part of the Waiver for any + reason be judged legally invalid or ineffective under applicable law, + then the Waiver shall be preserved to the maximum extent permitted + taking into account Affirmer's express Statement of Purpose. In + addition, to the extent the Waiver is so judged Affirmer hereby + grants to each affected person a royalty-free, non transferable, non + sublicensable, non exclusive, irrevocable and unconditional license + to exercise Affirmer's Copyright and Related Rights in the Work (i) + in all territories worldwide, (ii) for the maximum duration provided + by applicable law or treaty (including future time extensions), (iii) + in any current or future medium and for any number of copies, and + (iv) for any purpose whatsoever, including without limitation + commercial, advertising or promotional purposes (the "License"). The + License shall be deemed effective as of the date CC0 was applied by + Affirmer to the Work. Should any part of the License for any reason + be judged legally invalid or ineffective under applicable law, such + partial invalidity or ineffectiveness shall not invalidate the + remainder of the License, and in such case Affirmer hereby affirms + that he or she will not (i) exercise any of his or her remaining + Copyright and Related Rights in the Work or (ii) assert any + associated claims and causes of action with respect to the Work, in + either case contrary to Affirmer's express Statement of Purpose. + +4. **Limitations and Disclaimers.** + + - No trademark or patent rights held by Affirmer are waived, + abandoned, surrendered, licensed or otherwise affected by this + document. + - Affirmer offers the Work as-is and makes no representations or + warranties of any kind concerning the Work, express, implied, + statutory or otherwise, including without limitation warranties of + title, merchantability, fitness for a particular purpose, non + infringement, or the absence of latent or other defects, accuracy, + or the present or absence of errors, whether or not discoverable, + all to the greatest extent permissible under applicable law. + - Affirmer disclaims responsibility for clearing rights of other + persons that may apply to the Work or any use thereof, including + without limitation any person's Copyright and Related Rights in the + Work. Further, Affirmer disclaims responsibility for obtaining any + necessary consents, permissions or other rights required for any + use of the Work. + - Affirmer understands and acknowledges that Creative Commons is not + a party to this document and has no duty or obligation with respect + to this CC0 or use of the Work. diff --git a/third_party/monocypher/README.md b/third_party/monocypher/README.md new file mode 100644 index 000000000..d651edbf4 --- /dev/null +++ b/third_party/monocypher/README.md @@ -0,0 +1,4 @@ +Monocypher 4.0.2 (https://monocypher.org, release tarball sha256 +38d07179738c0c90677dba3ceb7a7b8496bcfea758ba1a53e803fed30ae0879c): `src/monocypher.*` and `src/optional/monocypher-ed25519.*`, +unchanged. Used under its CC0 licence (LICENCE.md) for Ed25519 signatures of updates: runtime/update_crypto*.c, +runtime/update_core.h, tools/update_sign.cpp. diff --git a/third_party/monocypher/monocypher-ed25519.c b/third_party/monocypher/monocypher-ed25519.c new file mode 100644 index 000000000..1dbcfbb3f --- /dev/null +++ b/third_party/monocypher/monocypher-ed25519.c @@ -0,0 +1,500 @@ +// Monocypher version 4.0.2 +// +// This file is dual-licensed. Choose whichever licence you want from +// the two licences listed below. +// +// The first licence is a regular 2-clause BSD licence. The second licence +// is the CC-0 from Creative Commons. It is intended to release Monocypher +// to the public domain. The BSD licence serves as a fallback option. +// +// SPDX-License-Identifier: BSD-2-Clause OR CC0-1.0 +// +// ------------------------------------------------------------------------ +// +// Copyright (c) 2017-2019, Loup Vaillant +// All rights reserved. +// +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// ------------------------------------------------------------------------ +// +// Written in 2017-2019 by Loup Vaillant +// +// To the extent possible under law, the author(s) have dedicated all copyright +// and related neighboring rights to this software to the public domain +// worldwide. This software is distributed without any warranty. +// +// You should have received a copy of the CC0 Public Domain Dedication along +// with this software. If not, see +// + +#include "monocypher-ed25519.h" + +#ifdef MONOCYPHER_CPP_NAMESPACE +namespace MONOCYPHER_CPP_NAMESPACE { +#endif + +///////////////// +/// Utilities /// +///////////////// +#define FOR(i, min, max) for (size_t i = min; i < max; i++) +#define COPY(dst, src, size) FOR(_i_, 0, size) (dst)[_i_] = (src)[_i_] +#define ZERO(buf, size) FOR(_i_, 0, size) (buf)[_i_] = 0 +#define WIPE_CTX(ctx) crypto_wipe(ctx , sizeof(*(ctx))) +#define WIPE_BUFFER(buffer) crypto_wipe(buffer, sizeof(buffer)) +#define MIN(a, b) ((a) <= (b) ? (a) : (b)) +typedef uint8_t u8; +typedef uint64_t u64; + +// Returns the smallest positive integer y such that +// (x + y) % pow_2 == 0 +// Basically, it's how many bytes we need to add to "align" x. +// Only works when pow_2 is a power of 2. +// Note: we use ~x+1 instead of -x to avoid compiler warnings +static size_t align(size_t x, size_t pow_2) +{ + return (~x + 1) & (pow_2 - 1); +} + +static u64 load64_be(const u8 s[8]) +{ + return((u64)s[0] << 56) + | ((u64)s[1] << 48) + | ((u64)s[2] << 40) + | ((u64)s[3] << 32) + | ((u64)s[4] << 24) + | ((u64)s[5] << 16) + | ((u64)s[6] << 8) + | (u64)s[7]; +} + +static void store64_be(u8 out[8], u64 in) +{ + out[0] = (in >> 56) & 0xff; + out[1] = (in >> 48) & 0xff; + out[2] = (in >> 40) & 0xff; + out[3] = (in >> 32) & 0xff; + out[4] = (in >> 24) & 0xff; + out[5] = (in >> 16) & 0xff; + out[6] = (in >> 8) & 0xff; + out[7] = in & 0xff; +} + +static void load64_be_buf (u64 *dst, const u8 *src, size_t size) { + FOR(i, 0, size) { dst[i] = load64_be(src + i*8); } +} + +/////////////// +/// SHA 512 /// +/////////////// +static u64 rot(u64 x, int c ) { return (x >> c) | (x << (64 - c)); } +static u64 ch (u64 x, u64 y, u64 z) { return (x & y) ^ (~x & z); } +static u64 maj(u64 x, u64 y, u64 z) { return (x & y) ^ ( x & z) ^ (y & z); } +static u64 big_sigma0(u64 x) { return rot(x, 28) ^ rot(x, 34) ^ rot(x, 39); } +static u64 big_sigma1(u64 x) { return rot(x, 14) ^ rot(x, 18) ^ rot(x, 41); } +static u64 lit_sigma0(u64 x) { return rot(x, 1) ^ rot(x, 8) ^ (x >> 7); } +static u64 lit_sigma1(u64 x) { return rot(x, 19) ^ rot(x, 61) ^ (x >> 6); } + +static const u64 K[80] = { + 0x428a2f98d728ae22,0x7137449123ef65cd,0xb5c0fbcfec4d3b2f,0xe9b5dba58189dbbc, + 0x3956c25bf348b538,0x59f111f1b605d019,0x923f82a4af194f9b,0xab1c5ed5da6d8118, + 0xd807aa98a3030242,0x12835b0145706fbe,0x243185be4ee4b28c,0x550c7dc3d5ffb4e2, + 0x72be5d74f27b896f,0x80deb1fe3b1696b1,0x9bdc06a725c71235,0xc19bf174cf692694, + 0xe49b69c19ef14ad2,0xefbe4786384f25e3,0x0fc19dc68b8cd5b5,0x240ca1cc77ac9c65, + 0x2de92c6f592b0275,0x4a7484aa6ea6e483,0x5cb0a9dcbd41fbd4,0x76f988da831153b5, + 0x983e5152ee66dfab,0xa831c66d2db43210,0xb00327c898fb213f,0xbf597fc7beef0ee4, + 0xc6e00bf33da88fc2,0xd5a79147930aa725,0x06ca6351e003826f,0x142929670a0e6e70, + 0x27b70a8546d22ffc,0x2e1b21385c26c926,0x4d2c6dfc5ac42aed,0x53380d139d95b3df, + 0x650a73548baf63de,0x766a0abb3c77b2a8,0x81c2c92e47edaee6,0x92722c851482353b, + 0xa2bfe8a14cf10364,0xa81a664bbc423001,0xc24b8b70d0f89791,0xc76c51a30654be30, + 0xd192e819d6ef5218,0xd69906245565a910,0xf40e35855771202a,0x106aa07032bbd1b8, + 0x19a4c116b8d2d0c8,0x1e376c085141ab53,0x2748774cdf8eeb99,0x34b0bcb5e19b48a8, + 0x391c0cb3c5c95a63,0x4ed8aa4ae3418acb,0x5b9cca4f7763e373,0x682e6ff3d6b2b8a3, + 0x748f82ee5defb2fc,0x78a5636f43172f60,0x84c87814a1f0ab72,0x8cc702081a6439ec, + 0x90befffa23631e28,0xa4506cebde82bde9,0xbef9a3f7b2c67915,0xc67178f2e372532b, + 0xca273eceea26619c,0xd186b8c721c0c207,0xeada7dd6cde0eb1e,0xf57d4f7fee6ed178, + 0x06f067aa72176fba,0x0a637dc5a2c898a6,0x113f9804bef90dae,0x1b710b35131c471b, + 0x28db77f523047d84,0x32caab7b40c72493,0x3c9ebe0a15c9bebc,0x431d67c49c100d4c, + 0x4cc5d4becb3e42b6,0x597f299cfc657e2a,0x5fcb6fab3ad6faec,0x6c44198c4a475817 +}; + +static void sha512_compress(crypto_sha512_ctx *ctx) +{ + u64 a = ctx->hash[0]; u64 b = ctx->hash[1]; + u64 c = ctx->hash[2]; u64 d = ctx->hash[3]; + u64 e = ctx->hash[4]; u64 f = ctx->hash[5]; + u64 g = ctx->hash[6]; u64 h = ctx->hash[7]; + + FOR (j, 0, 16) { + u64 in = K[j] + ctx->input[j]; + u64 t1 = big_sigma1(e) + ch (e, f, g) + h + in; + u64 t2 = big_sigma0(a) + maj(a, b, c); + h = g; g = f; f = e; e = d + t1; + d = c; c = b; b = a; a = t1 + t2; + } + size_t i16 = 0; + FOR(i, 1, 5) { + i16 += 16; + FOR (j, 0, 16) { + ctx->input[j] += lit_sigma1(ctx->input[(j- 2) & 15]); + ctx->input[j] += lit_sigma0(ctx->input[(j-15) & 15]); + ctx->input[j] += ctx->input[(j- 7) & 15]; + u64 in = K[i16 + j] + ctx->input[j]; + u64 t1 = big_sigma1(e) + ch (e, f, g) + h + in; + u64 t2 = big_sigma0(a) + maj(a, b, c); + h = g; g = f; f = e; e = d + t1; + d = c; c = b; b = a; a = t1 + t2; + } + } + + ctx->hash[0] += a; ctx->hash[1] += b; + ctx->hash[2] += c; ctx->hash[3] += d; + ctx->hash[4] += e; ctx->hash[5] += f; + ctx->hash[6] += g; ctx->hash[7] += h; +} + +// Write 1 input byte +static void sha512_set_input(crypto_sha512_ctx *ctx, u8 input) +{ + size_t word = ctx->input_idx >> 3; + size_t byte = ctx->input_idx & 7; + ctx->input[word] |= (u64)input << (8 * (7 - byte)); +} + +// Increment a 128-bit "word". +static void sha512_incr(u64 x[2], u64 y) +{ + x[1] += y; + if (x[1] < y) { + x[0]++; + } +} + +void crypto_sha512_init(crypto_sha512_ctx *ctx) +{ + ctx->hash[0] = 0x6a09e667f3bcc908; + ctx->hash[1] = 0xbb67ae8584caa73b; + ctx->hash[2] = 0x3c6ef372fe94f82b; + ctx->hash[3] = 0xa54ff53a5f1d36f1; + ctx->hash[4] = 0x510e527fade682d1; + ctx->hash[5] = 0x9b05688c2b3e6c1f; + ctx->hash[6] = 0x1f83d9abfb41bd6b; + ctx->hash[7] = 0x5be0cd19137e2179; + ctx->input_size[0] = 0; + ctx->input_size[1] = 0; + ctx->input_idx = 0; + ZERO(ctx->input, 16); +} + +void crypto_sha512_update(crypto_sha512_ctx *ctx, + const u8 *message, size_t message_size) +{ + // Avoid undefined NULL pointer increments with empty messages + if (message_size == 0) { + return; + } + + // Align ourselves with word boundaries + if ((ctx->input_idx & 7) != 0) { + size_t nb_bytes = MIN(align(ctx->input_idx, 8), message_size); + FOR (i, 0, nb_bytes) { + sha512_set_input(ctx, message[i]); + ctx->input_idx++; + } + message += nb_bytes; + message_size -= nb_bytes; + } + + // Align ourselves with block boundaries + if ((ctx->input_idx & 127) != 0) { + size_t nb_words = MIN(align(ctx->input_idx, 128), message_size) >> 3; + load64_be_buf(ctx->input + (ctx->input_idx >> 3), message, nb_words); + ctx->input_idx += nb_words << 3; + message += nb_words << 3; + message_size -= nb_words << 3; + } + + // Compress block if needed + if (ctx->input_idx == 128) { + sha512_incr(ctx->input_size, 1024); // size is in bits + sha512_compress(ctx); + ctx->input_idx = 0; + ZERO(ctx->input, 16); + } + + // Process the message block by block + FOR (i, 0, message_size >> 7) { // number of blocks + load64_be_buf(ctx->input, message, 16); + sha512_incr(ctx->input_size, 1024); // size is in bits + sha512_compress(ctx); + ctx->input_idx = 0; + ZERO(ctx->input, 16); + message += 128; + } + message_size &= 127; + + if (message_size != 0) { + // Remaining words + size_t nb_words = message_size >> 3; + load64_be_buf(ctx->input, message, nb_words); + ctx->input_idx += nb_words << 3; + message += nb_words << 3; + message_size -= nb_words << 3; + + // Remaining bytes + FOR (i, 0, message_size) { + sha512_set_input(ctx, message[i]); + ctx->input_idx++; + } + } +} + +void crypto_sha512_final(crypto_sha512_ctx *ctx, u8 hash[64]) +{ + // Add padding bit + if (ctx->input_idx == 0) { + ZERO(ctx->input, 16); + } + sha512_set_input(ctx, 128); + + // Update size + sha512_incr(ctx->input_size, ctx->input_idx * 8); + + // Compress penultimate block (if any) + if (ctx->input_idx > 111) { + sha512_compress(ctx); + ZERO(ctx->input, 14); + } + // Compress last block + ctx->input[14] = ctx->input_size[0]; + ctx->input[15] = ctx->input_size[1]; + sha512_compress(ctx); + + // Copy hash to output (big endian) + FOR (i, 0, 8) { + store64_be(hash + i*8, ctx->hash[i]); + } + + WIPE_CTX(ctx); +} + +void crypto_sha512(u8 hash[64], const u8 *message, size_t message_size) +{ + crypto_sha512_ctx ctx; + crypto_sha512_init (&ctx); + crypto_sha512_update(&ctx, message, message_size); + crypto_sha512_final (&ctx, hash); +} + +//////////////////// +/// HMAC SHA 512 /// +//////////////////// +void crypto_sha512_hmac_init(crypto_sha512_hmac_ctx *ctx, + const u8 *key, size_t key_size) +{ + // hash key if it is too long + if (key_size > 128) { + crypto_sha512(ctx->key, key, key_size); + key = ctx->key; + key_size = 64; + } + // Compute inner key: padded key XOR 0x36 + FOR (i, 0, key_size) { ctx->key[i] = key[i] ^ 0x36; } + FOR (i, key_size, 128) { ctx->key[i] = 0x36; } + // Start computing inner hash + crypto_sha512_init (&ctx->ctx); + crypto_sha512_update(&ctx->ctx, ctx->key, 128); +} + +void crypto_sha512_hmac_update(crypto_sha512_hmac_ctx *ctx, + const u8 *message, size_t message_size) +{ + crypto_sha512_update(&ctx->ctx, message, message_size); +} + +void crypto_sha512_hmac_final(crypto_sha512_hmac_ctx *ctx, u8 hmac[64]) +{ + // Finish computing inner hash + crypto_sha512_final(&ctx->ctx, hmac); + // Compute outer key: padded key XOR 0x5c + FOR (i, 0, 128) { + ctx->key[i] ^= 0x36 ^ 0x5c; + } + // Compute outer hash + crypto_sha512_init (&ctx->ctx); + crypto_sha512_update(&ctx->ctx, ctx->key , 128); + crypto_sha512_update(&ctx->ctx, hmac, 64); + crypto_sha512_final (&ctx->ctx, hmac); // outer hash + WIPE_CTX(ctx); +} + +void crypto_sha512_hmac(u8 hmac[64], const u8 *key, size_t key_size, + const u8 *message, size_t message_size) +{ + crypto_sha512_hmac_ctx ctx; + crypto_sha512_hmac_init (&ctx, key, key_size); + crypto_sha512_hmac_update(&ctx, message, message_size); + crypto_sha512_hmac_final (&ctx, hmac); +} + +//////////////////// +/// HKDF SHA 512 /// +//////////////////// +void crypto_sha512_hkdf_expand(u8 *okm, size_t okm_size, + const u8 *prk, size_t prk_size, + const u8 *info, size_t info_size) +{ + int not_first = 0; + u8 ctr = 1; + u8 blk[64]; + + while (okm_size > 0) { + size_t out_size = MIN(okm_size, sizeof(blk)); + + crypto_sha512_hmac_ctx ctx; + crypto_sha512_hmac_init(&ctx, prk , prk_size); + if (not_first) { + // For some reason HKDF uses some kind of CBC mode. + // For some reason CTR mode alone wasn't enough. + // Like what, they didn't trust HMAC in 2010? Really?? + crypto_sha512_hmac_update(&ctx, blk , sizeof(blk)); + } + crypto_sha512_hmac_update(&ctx, info, info_size); + crypto_sha512_hmac_update(&ctx, &ctr, 1); + crypto_sha512_hmac_final(&ctx, blk); + + COPY(okm, blk, out_size); + + not_first = 1; + okm += out_size; + okm_size -= out_size; + ctr++; + } +} + +void crypto_sha512_hkdf(u8 *okm , size_t okm_size, + const u8 *ikm , size_t ikm_size, + const u8 *salt, size_t salt_size, + const u8 *info, size_t info_size) +{ + // Extract + u8 prk[64]; + crypto_sha512_hmac(prk, salt, salt_size, ikm, ikm_size); + + // Expand + crypto_sha512_hkdf_expand(okm, okm_size, prk, sizeof(prk), info, info_size); +} + +/////////////// +/// Ed25519 /// +/////////////// +void crypto_ed25519_key_pair(u8 secret_key[64], u8 public_key[32], u8 seed[32]) +{ + u8 a[64]; + COPY(a, seed, 32); // a[ 0..31] = seed + crypto_wipe(seed, 32); + COPY(secret_key, a, 32); // secret key = seed + crypto_sha512(a, a, 32); // a[ 0..31] = scalar + crypto_eddsa_trim_scalar(a, a); // a[ 0..31] = trimmed scalar + crypto_eddsa_scalarbase(public_key, a); // public key = [trimmed scalar]B + COPY(secret_key + 32, public_key, 32); // secret key includes public half + WIPE_BUFFER(a); +} + +static void hash_reduce(u8 h[32], + const u8 *a, size_t a_size, + const u8 *b, size_t b_size, + const u8 *c, size_t c_size, + const u8 *d, size_t d_size) +{ + u8 hash[64]; + crypto_sha512_ctx ctx; + crypto_sha512_init (&ctx); + crypto_sha512_update(&ctx, a, a_size); + crypto_sha512_update(&ctx, b, b_size); + crypto_sha512_update(&ctx, c, c_size); + crypto_sha512_update(&ctx, d, d_size); + crypto_sha512_final (&ctx, hash); + crypto_eddsa_reduce(h, hash); +} + +static void ed25519_dom_sign(u8 signature [64], const u8 secret_key[32], + const u8 *dom, size_t dom_size, + const u8 *message, size_t message_size) +{ + u8 a[64]; // secret scalar and prefix + u8 r[32]; // secret deterministic "random" nonce + u8 h[32]; // publically verifiable hash of the message (not wiped) + u8 R[32]; // first half of the signature (allows overlapping inputs) + const u8 *pk = secret_key + 32; + + crypto_sha512(a, secret_key, 32); + crypto_eddsa_trim_scalar(a, a); + hash_reduce(r, dom, dom_size, a + 32, 32, message, message_size, 0, 0); + crypto_eddsa_scalarbase(R, r); + hash_reduce(h, dom, dom_size, R, 32, pk, 32, message, message_size); + COPY(signature, R, 32); + crypto_eddsa_mul_add(signature + 32, h, a, r); + + WIPE_BUFFER(a); + WIPE_BUFFER(r); +} + +void crypto_ed25519_sign(u8 signature [64], const u8 secret_key[64], + const u8 *message, size_t message_size) +{ + ed25519_dom_sign(signature, secret_key, 0, 0, message, message_size); +} + +int crypto_ed25519_check(const u8 signature[64], const u8 public_key[32], + const u8 *msg, size_t msg_size) +{ + u8 h_ram[32]; + hash_reduce(h_ram, signature, 32, public_key, 32, msg, msg_size, 0, 0); + return crypto_eddsa_check_equation(signature, public_key, h_ram); +} + +static const u8 domain[34] = "SigEd25519 no Ed25519 collisions\1"; + +void crypto_ed25519_ph_sign(uint8_t signature[64], const uint8_t secret_key[64], + const uint8_t message_hash[64]) +{ + ed25519_dom_sign(signature, secret_key, domain, sizeof(domain), + message_hash, 64); +} + +int crypto_ed25519_ph_check(const uint8_t sig[64], const uint8_t pk[32], + const uint8_t msg_hash[64]) +{ + u8 h_ram[32]; + hash_reduce(h_ram, domain, sizeof(domain), sig, 32, pk, 32, msg_hash, 64); + return crypto_eddsa_check_equation(sig, pk, h_ram); +} + + +#ifdef MONOCYPHER_CPP_NAMESPACE +} +#endif diff --git a/third_party/monocypher/monocypher-ed25519.h b/third_party/monocypher/monocypher-ed25519.h new file mode 100644 index 000000000..1e6d705da --- /dev/null +++ b/third_party/monocypher/monocypher-ed25519.h @@ -0,0 +1,140 @@ +// Monocypher version 4.0.2 +// +// This file is dual-licensed. Choose whichever licence you want from +// the two licences listed below. +// +// The first licence is a regular 2-clause BSD licence. The second licence +// is the CC-0 from Creative Commons. It is intended to release Monocypher +// to the public domain. The BSD licence serves as a fallback option. +// +// SPDX-License-Identifier: BSD-2-Clause OR CC0-1.0 +// +// ------------------------------------------------------------------------ +// +// Copyright (c) 2017-2019, Loup Vaillant +// All rights reserved. +// +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// ------------------------------------------------------------------------ +// +// Written in 2017-2019 by Loup Vaillant +// +// To the extent possible under law, the author(s) have dedicated all copyright +// and related neighboring rights to this software to the public domain +// worldwide. This software is distributed without any warranty. +// +// You should have received a copy of the CC0 Public Domain Dedication along +// with this software. If not, see +// + +#ifndef ED25519_H +#define ED25519_H + +#include "monocypher.h" + +#ifdef MONOCYPHER_CPP_NAMESPACE +namespace MONOCYPHER_CPP_NAMESPACE { +#elif defined(__cplusplus) +extern "C" { +#endif + +//////////////////////// +/// Type definitions /// +//////////////////////// + +// Do not rely on the size or content on any of those types, +// they may change without notice. +typedef struct { + uint64_t hash[8]; + uint64_t input[16]; + uint64_t input_size[2]; + size_t input_idx; +} crypto_sha512_ctx; + +typedef struct { + uint8_t key[128]; + crypto_sha512_ctx ctx; +} crypto_sha512_hmac_ctx; + + +// SHA 512 +// ------- +void crypto_sha512_init (crypto_sha512_ctx *ctx); +void crypto_sha512_update(crypto_sha512_ctx *ctx, + const uint8_t *message, size_t message_size); +void crypto_sha512_final (crypto_sha512_ctx *ctx, uint8_t hash[64]); +void crypto_sha512(uint8_t hash[64], + const uint8_t *message, size_t message_size); + +// SHA 512 HMAC +// ------------ +void crypto_sha512_hmac_init(crypto_sha512_hmac_ctx *ctx, + const uint8_t *key, size_t key_size); +void crypto_sha512_hmac_update(crypto_sha512_hmac_ctx *ctx, + const uint8_t *message, size_t message_size); +void crypto_sha512_hmac_final(crypto_sha512_hmac_ctx *ctx, uint8_t hmac[64]); +void crypto_sha512_hmac(uint8_t hmac[64], + const uint8_t *key , size_t key_size, + const uint8_t *message, size_t message_size); + +// SHA 512 HKDF +// ------------ +void crypto_sha512_hkdf_expand(uint8_t *okm, size_t okm_size, + const uint8_t *prk, size_t prk_size, + const uint8_t *info, size_t info_size); +void crypto_sha512_hkdf(uint8_t *okm , size_t okm_size, + const uint8_t *ikm , size_t ikm_size, + const uint8_t *salt, size_t salt_size, + const uint8_t *info, size_t info_size); + +// Ed25519 +// ------- +// Signatures (EdDSA with curve25519 + SHA-512) +// -------------------------------------------- +void crypto_ed25519_key_pair(uint8_t secret_key[64], + uint8_t public_key[32], + uint8_t seed[32]); +void crypto_ed25519_sign(uint8_t signature [64], + const uint8_t secret_key[64], + const uint8_t *message, size_t message_size); +int crypto_ed25519_check(const uint8_t signature [64], + const uint8_t public_key[32], + const uint8_t *message, size_t message_size); + +// Pre-hash variants +void crypto_ed25519_ph_sign(uint8_t signature [64], + const uint8_t secret_key [64], + const uint8_t message_hash[64]); +int crypto_ed25519_ph_check(const uint8_t signature [64], + const uint8_t public_key [32], + const uint8_t message_hash[64]); + +#ifdef __cplusplus +} +#endif + +#endif // ED25519_H diff --git a/third_party/monocypher/monocypher.c b/third_party/monocypher/monocypher.c new file mode 100644 index 000000000..d3930fb84 --- /dev/null +++ b/third_party/monocypher/monocypher.c @@ -0,0 +1,2956 @@ +// Monocypher version 4.0.2 +// +// This file is dual-licensed. Choose whichever licence you want from +// the two licences listed below. +// +// The first licence is a regular 2-clause BSD licence. The second licence +// is the CC-0 from Creative Commons. It is intended to release Monocypher +// to the public domain. The BSD licence serves as a fallback option. +// +// SPDX-License-Identifier: BSD-2-Clause OR CC0-1.0 +// +// ------------------------------------------------------------------------ +// +// Copyright (c) 2017-2020, Loup Vaillant +// All rights reserved. +// +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// ------------------------------------------------------------------------ +// +// Written in 2017-2020 by Loup Vaillant +// +// To the extent possible under law, the author(s) have dedicated all copyright +// and related neighboring rights to this software to the public domain +// worldwide. This software is distributed without any warranty. +// +// You should have received a copy of the CC0 Public Domain Dedication along +// with this software. If not, see +// + +#include "monocypher.h" + +#ifdef MONOCYPHER_CPP_NAMESPACE +namespace MONOCYPHER_CPP_NAMESPACE { +#endif + +///////////////// +/// Utilities /// +///////////////// +#define FOR_T(type, i, start, end) for (type i = (start); i < (end); i++) +#define FOR(i, start, end) FOR_T(size_t, i, start, end) +#define COPY(dst, src, size) FOR(_i_, 0, size) (dst)[_i_] = (src)[_i_] +#define ZERO(buf, size) FOR(_i_, 0, size) (buf)[_i_] = 0 +#define WIPE_CTX(ctx) crypto_wipe(ctx , sizeof(*(ctx))) +#define WIPE_BUFFER(buffer) crypto_wipe(buffer, sizeof(buffer)) +#define MIN(a, b) ((a) <= (b) ? (a) : (b)) +#define MAX(a, b) ((a) >= (b) ? (a) : (b)) + +typedef int8_t i8; +typedef uint8_t u8; +typedef int16_t i16; +typedef uint32_t u32; +typedef int32_t i32; +typedef int64_t i64; +typedef uint64_t u64; + +static const u8 zero[128] = {0}; + +// returns the smallest positive integer y such that +// (x + y) % pow_2 == 0 +// Basically, y is the "gap" missing to align x. +// Only works when pow_2 is a power of 2. +// Note: we use ~x+1 instead of -x to avoid compiler warnings +static size_t gap(size_t x, size_t pow_2) +{ + return (~x + 1) & (pow_2 - 1); +} + +static u32 load24_le(const u8 s[3]) +{ + return + ((u32)s[0] << 0) | + ((u32)s[1] << 8) | + ((u32)s[2] << 16); +} + +static u32 load32_le(const u8 s[4]) +{ + return + ((u32)s[0] << 0) | + ((u32)s[1] << 8) | + ((u32)s[2] << 16) | + ((u32)s[3] << 24); +} + +static u64 load64_le(const u8 s[8]) +{ + return load32_le(s) | ((u64)load32_le(s+4) << 32); +} + +static void store32_le(u8 out[4], u32 in) +{ + out[0] = in & 0xff; + out[1] = (in >> 8) & 0xff; + out[2] = (in >> 16) & 0xff; + out[3] = (in >> 24) & 0xff; +} + +static void store64_le(u8 out[8], u64 in) +{ + store32_le(out , (u32)in ); + store32_le(out + 4, in >> 32); +} + +static void load32_le_buf (u32 *dst, const u8 *src, size_t size) { + FOR(i, 0, size) { dst[i] = load32_le(src + i*4); } +} +static void load64_le_buf (u64 *dst, const u8 *src, size_t size) { + FOR(i, 0, size) { dst[i] = load64_le(src + i*8); } +} +static void store32_le_buf(u8 *dst, const u32 *src, size_t size) { + FOR(i, 0, size) { store32_le(dst + i*4, src[i]); } +} +static void store64_le_buf(u8 *dst, const u64 *src, size_t size) { + FOR(i, 0, size) { store64_le(dst + i*8, src[i]); } +} + +static u64 rotr64(u64 x, u64 n) { return (x >> n) ^ (x << (64 - n)); } +static u32 rotl32(u32 x, u32 n) { return (x << n) ^ (x >> (32 - n)); } + +static int neq0(u64 diff) +{ + // constant time comparison to zero + // return diff != 0 ? -1 : 0 + u64 half = (diff >> 32) | ((u32)diff); + return (1 & ((half - 1) >> 32)) - 1; +} + +static u64 x16(const u8 a[16], const u8 b[16]) +{ + return (load64_le(a + 0) ^ load64_le(b + 0)) + | (load64_le(a + 8) ^ load64_le(b + 8)); +} +static u64 x32(const u8 a[32],const u8 b[32]){return x16(a,b)| x16(a+16, b+16);} +static u64 x64(const u8 a[64],const u8 b[64]){return x32(a,b)| x32(a+32, b+32);} +int crypto_verify16(const u8 a[16], const u8 b[16]){ return neq0(x16(a, b)); } +int crypto_verify32(const u8 a[32], const u8 b[32]){ return neq0(x32(a, b)); } +int crypto_verify64(const u8 a[64], const u8 b[64]){ return neq0(x64(a, b)); } + +void crypto_wipe(void *secret, size_t size) +{ + volatile u8 *v_secret = (u8*)secret; + ZERO(v_secret, size); +} + +///////////////// +/// Chacha 20 /// +///////////////// +#define QUARTERROUND(a, b, c, d) \ + a += b; d = rotl32(d ^ a, 16); \ + c += d; b = rotl32(b ^ c, 12); \ + a += b; d = rotl32(d ^ a, 8); \ + c += d; b = rotl32(b ^ c, 7) + +static void chacha20_rounds(u32 out[16], const u32 in[16]) +{ + // The temporary variables make Chacha20 10% faster. + u32 t0 = in[ 0]; u32 t1 = in[ 1]; u32 t2 = in[ 2]; u32 t3 = in[ 3]; + u32 t4 = in[ 4]; u32 t5 = in[ 5]; u32 t6 = in[ 6]; u32 t7 = in[ 7]; + u32 t8 = in[ 8]; u32 t9 = in[ 9]; u32 t10 = in[10]; u32 t11 = in[11]; + u32 t12 = in[12]; u32 t13 = in[13]; u32 t14 = in[14]; u32 t15 = in[15]; + + FOR (i, 0, 10) { // 20 rounds, 2 rounds per loop. + QUARTERROUND(t0, t4, t8 , t12); // column 0 + QUARTERROUND(t1, t5, t9 , t13); // column 1 + QUARTERROUND(t2, t6, t10, t14); // column 2 + QUARTERROUND(t3, t7, t11, t15); // column 3 + QUARTERROUND(t0, t5, t10, t15); // diagonal 0 + QUARTERROUND(t1, t6, t11, t12); // diagonal 1 + QUARTERROUND(t2, t7, t8 , t13); // diagonal 2 + QUARTERROUND(t3, t4, t9 , t14); // diagonal 3 + } + out[ 0] = t0; out[ 1] = t1; out[ 2] = t2; out[ 3] = t3; + out[ 4] = t4; out[ 5] = t5; out[ 6] = t6; out[ 7] = t7; + out[ 8] = t8; out[ 9] = t9; out[10] = t10; out[11] = t11; + out[12] = t12; out[13] = t13; out[14] = t14; out[15] = t15; +} + +static const u8 *chacha20_constant = (const u8*)"expand 32-byte k"; // 16 bytes + +void crypto_chacha20_h(u8 out[32], const u8 key[32], const u8 in [16]) +{ + u32 block[16]; + load32_le_buf(block , chacha20_constant, 4); + load32_le_buf(block + 4, key , 8); + load32_le_buf(block + 12, in , 4); + + chacha20_rounds(block, block); + + // prevent reversal of the rounds by revealing only half of the buffer. + store32_le_buf(out , block , 4); // constant + store32_le_buf(out+16, block+12, 4); // counter and nonce + WIPE_BUFFER(block); +} + +u64 crypto_chacha20_djb(u8 *cipher_text, const u8 *plain_text, + size_t text_size, const u8 key[32], const u8 nonce[8], + u64 ctr) +{ + u32 input[16]; + load32_le_buf(input , chacha20_constant, 4); + load32_le_buf(input + 4, key , 8); + load32_le_buf(input + 14, nonce , 2); + input[12] = (u32) ctr; + input[13] = (u32)(ctr >> 32); + + // Whole blocks + u32 pool[16]; + size_t nb_blocks = text_size >> 6; + FOR (i, 0, nb_blocks) { + chacha20_rounds(pool, input); + if (plain_text != 0) { + FOR (j, 0, 16) { + u32 p = pool[j] + input[j]; + store32_le(cipher_text, p ^ load32_le(plain_text)); + cipher_text += 4; + plain_text += 4; + } + } else { + FOR (j, 0, 16) { + u32 p = pool[j] + input[j]; + store32_le(cipher_text, p); + cipher_text += 4; + } + } + input[12]++; + if (input[12] == 0) { + input[13]++; + } + } + text_size &= 63; + + // Last (incomplete) block + if (text_size > 0) { + if (plain_text == 0) { + plain_text = zero; + } + chacha20_rounds(pool, input); + u8 tmp[64]; + FOR (i, 0, 16) { + store32_le(tmp + i*4, pool[i] + input[i]); + } + FOR (i, 0, text_size) { + cipher_text[i] = tmp[i] ^ plain_text[i]; + } + WIPE_BUFFER(tmp); + } + ctr = input[12] + ((u64)input[13] << 32) + (text_size > 0); + + WIPE_BUFFER(pool); + WIPE_BUFFER(input); + return ctr; +} + +u32 crypto_chacha20_ietf(u8 *cipher_text, const u8 *plain_text, + size_t text_size, + const u8 key[32], const u8 nonce[12], u32 ctr) +{ + u64 big_ctr = ctr + ((u64)load32_le(nonce) << 32); + return (u32)crypto_chacha20_djb(cipher_text, plain_text, text_size, + key, nonce + 4, big_ctr); +} + +u64 crypto_chacha20_x(u8 *cipher_text, const u8 *plain_text, + size_t text_size, + const u8 key[32], const u8 nonce[24], u64 ctr) +{ + u8 sub_key[32]; + crypto_chacha20_h(sub_key, key, nonce); + ctr = crypto_chacha20_djb(cipher_text, plain_text, text_size, + sub_key, nonce + 16, ctr); + WIPE_BUFFER(sub_key); + return ctr; +} + +///////////////// +/// Poly 1305 /// +///////////////// + +// h = (h + c) * r +// preconditions: +// ctx->h <= 4_ffffffff_ffffffff_ffffffff_ffffffff +// ctx->r <= 0ffffffc_0ffffffc_0ffffffc_0fffffff +// end <= 1 +// Postcondition: +// ctx->h <= 4_ffffffff_ffffffff_ffffffff_ffffffff +static void poly_blocks(crypto_poly1305_ctx *ctx, const u8 *in, + size_t nb_blocks, unsigned end) +{ + // Local all the things! + const u32 r0 = ctx->r[0]; + const u32 r1 = ctx->r[1]; + const u32 r2 = ctx->r[2]; + const u32 r3 = ctx->r[3]; + const u32 rr0 = (r0 >> 2) * 5; // lose 2 bits... + const u32 rr1 = (r1 >> 2) + r1; // rr1 == (r1 >> 2) * 5 + const u32 rr2 = (r2 >> 2) + r2; // rr1 == (r2 >> 2) * 5 + const u32 rr3 = (r3 >> 2) + r3; // rr1 == (r3 >> 2) * 5 + const u32 rr4 = r0 & 3; // ...recover 2 bits + u32 h0 = ctx->h[0]; + u32 h1 = ctx->h[1]; + u32 h2 = ctx->h[2]; + u32 h3 = ctx->h[3]; + u32 h4 = ctx->h[4]; + + FOR (i, 0, nb_blocks) { + // h + c, without carry propagation + const u64 s0 = (u64)h0 + load32_le(in); in += 4; + const u64 s1 = (u64)h1 + load32_le(in); in += 4; + const u64 s2 = (u64)h2 + load32_le(in); in += 4; + const u64 s3 = (u64)h3 + load32_le(in); in += 4; + const u32 s4 = h4 + end; + + // (h + c) * r, without carry propagation + const u64 x0 = s0*r0+ s1*rr3+ s2*rr2+ s3*rr1+ s4*rr0; + const u64 x1 = s0*r1+ s1*r0 + s2*rr3+ s3*rr2+ s4*rr1; + const u64 x2 = s0*r2+ s1*r1 + s2*r0 + s3*rr3+ s4*rr2; + const u64 x3 = s0*r3+ s1*r2 + s2*r1 + s3*r0 + s4*rr3; + const u32 x4 = s4*rr4; + + // partial reduction modulo 2^130 - 5 + const u32 u5 = x4 + (x3 >> 32); // u5 <= 7ffffff5 + const u64 u0 = (u5 >> 2) * 5 + (x0 & 0xffffffff); + const u64 u1 = (u0 >> 32) + (x1 & 0xffffffff) + (x0 >> 32); + const u64 u2 = (u1 >> 32) + (x2 & 0xffffffff) + (x1 >> 32); + const u64 u3 = (u2 >> 32) + (x3 & 0xffffffff) + (x2 >> 32); + const u32 u4 = (u3 >> 32) + (u5 & 3); // u4 <= 4 + + // Update the hash + h0 = u0 & 0xffffffff; + h1 = u1 & 0xffffffff; + h2 = u2 & 0xffffffff; + h3 = u3 & 0xffffffff; + h4 = u4; + } + ctx->h[0] = h0; + ctx->h[1] = h1; + ctx->h[2] = h2; + ctx->h[3] = h3; + ctx->h[4] = h4; +} + +void crypto_poly1305_init(crypto_poly1305_ctx *ctx, const u8 key[32]) +{ + ZERO(ctx->h, 5); // Initial hash is zero + ctx->c_idx = 0; + // load r and pad (r has some of its bits cleared) + load32_le_buf(ctx->r , key , 4); + load32_le_buf(ctx->pad, key+16, 4); + FOR (i, 0, 1) { ctx->r[i] &= 0x0fffffff; } + FOR (i, 1, 4) { ctx->r[i] &= 0x0ffffffc; } +} + +void crypto_poly1305_update(crypto_poly1305_ctx *ctx, + const u8 *message, size_t message_size) +{ + // Avoid undefined NULL pointer increments with empty messages + if (message_size == 0) { + return; + } + + // Align ourselves with block boundaries + size_t aligned = MIN(gap(ctx->c_idx, 16), message_size); + FOR (i, 0, aligned) { + ctx->c[ctx->c_idx] = *message; + ctx->c_idx++; + message++; + message_size--; + } + + // If block is complete, process it + if (ctx->c_idx == 16) { + poly_blocks(ctx, ctx->c, 1, 1); + ctx->c_idx = 0; + } + + // Process the message block by block + size_t nb_blocks = message_size >> 4; + poly_blocks(ctx, message, nb_blocks, 1); + message += nb_blocks << 4; + message_size &= 15; + + // remaining bytes (we never complete a block here) + FOR (i, 0, message_size) { + ctx->c[ctx->c_idx] = message[i]; + ctx->c_idx++; + } +} + +void crypto_poly1305_final(crypto_poly1305_ctx *ctx, u8 mac[16]) +{ + // Process the last block (if any) + // We move the final 1 according to remaining input length + // (this will add less than 2^130 to the last input block) + if (ctx->c_idx != 0) { + ZERO(ctx->c + ctx->c_idx, 16 - ctx->c_idx); + ctx->c[ctx->c_idx] = 1; + poly_blocks(ctx, ctx->c, 1, 0); + } + + // check if we should subtract 2^130-5 by performing the + // corresponding carry propagation. + u64 c = 5; + FOR (i, 0, 4) { + c += ctx->h[i]; + c >>= 32; + } + c += ctx->h[4]; + c = (c >> 2) * 5; // shift the carry back to the beginning + // c now indicates how many times we should subtract 2^130-5 (0 or 1) + FOR (i, 0, 4) { + c += (u64)ctx->h[i] + ctx->pad[i]; + store32_le(mac + i*4, (u32)c); + c = c >> 32; + } + WIPE_CTX(ctx); +} + +void crypto_poly1305(u8 mac[16], const u8 *message, + size_t message_size, const u8 key[32]) +{ + crypto_poly1305_ctx ctx; + crypto_poly1305_init (&ctx, key); + crypto_poly1305_update(&ctx, message, message_size); + crypto_poly1305_final (&ctx, mac); +} + +//////////////// +/// BLAKE2 b /// +//////////////// +static const u64 iv[8] = { + 0x6a09e667f3bcc908, 0xbb67ae8584caa73b, + 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1, + 0x510e527fade682d1, 0x9b05688c2b3e6c1f, + 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179, +}; + +static void blake2b_compress(crypto_blake2b_ctx *ctx, int is_last_block) +{ + static const u8 sigma[12][16] = { + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, + { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }, + { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 }, + { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 }, + { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 }, + { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 }, + { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 }, + { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 }, + { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 }, + { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 }, + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, + { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }, + }; + + // increment input offset + u64 *x = ctx->input_offset; + size_t y = ctx->input_idx; + x[0] += y; + if (x[0] < y) { + x[1]++; + } + + // init work vector + u64 v0 = ctx->hash[0]; u64 v8 = iv[0]; + u64 v1 = ctx->hash[1]; u64 v9 = iv[1]; + u64 v2 = ctx->hash[2]; u64 v10 = iv[2]; + u64 v3 = ctx->hash[3]; u64 v11 = iv[3]; + u64 v4 = ctx->hash[4]; u64 v12 = iv[4] ^ ctx->input_offset[0]; + u64 v5 = ctx->hash[5]; u64 v13 = iv[5] ^ ctx->input_offset[1]; + u64 v6 = ctx->hash[6]; u64 v14 = iv[6] ^ (u64)~(is_last_block - 1); + u64 v7 = ctx->hash[7]; u64 v15 = iv[7]; + + // mangle work vector + u64 *input = ctx->input; +#define BLAKE2_G(a, b, c, d, x, y) \ + a += b + x; d = rotr64(d ^ a, 32); \ + c += d; b = rotr64(b ^ c, 24); \ + a += b + y; d = rotr64(d ^ a, 16); \ + c += d; b = rotr64(b ^ c, 63) +#define BLAKE2_ROUND(i) \ + BLAKE2_G(v0, v4, v8 , v12, input[sigma[i][ 0]], input[sigma[i][ 1]]); \ + BLAKE2_G(v1, v5, v9 , v13, input[sigma[i][ 2]], input[sigma[i][ 3]]); \ + BLAKE2_G(v2, v6, v10, v14, input[sigma[i][ 4]], input[sigma[i][ 5]]); \ + BLAKE2_G(v3, v7, v11, v15, input[sigma[i][ 6]], input[sigma[i][ 7]]); \ + BLAKE2_G(v0, v5, v10, v15, input[sigma[i][ 8]], input[sigma[i][ 9]]); \ + BLAKE2_G(v1, v6, v11, v12, input[sigma[i][10]], input[sigma[i][11]]); \ + BLAKE2_G(v2, v7, v8 , v13, input[sigma[i][12]], input[sigma[i][13]]); \ + BLAKE2_G(v3, v4, v9 , v14, input[sigma[i][14]], input[sigma[i][15]]) + +#ifdef BLAKE2_NO_UNROLLING + FOR (i, 0, 12) { + BLAKE2_ROUND(i); + } +#else + BLAKE2_ROUND(0); BLAKE2_ROUND(1); BLAKE2_ROUND(2); BLAKE2_ROUND(3); + BLAKE2_ROUND(4); BLAKE2_ROUND(5); BLAKE2_ROUND(6); BLAKE2_ROUND(7); + BLAKE2_ROUND(8); BLAKE2_ROUND(9); BLAKE2_ROUND(10); BLAKE2_ROUND(11); +#endif + + // update hash + ctx->hash[0] ^= v0 ^ v8; ctx->hash[1] ^= v1 ^ v9; + ctx->hash[2] ^= v2 ^ v10; ctx->hash[3] ^= v3 ^ v11; + ctx->hash[4] ^= v4 ^ v12; ctx->hash[5] ^= v5 ^ v13; + ctx->hash[6] ^= v6 ^ v14; ctx->hash[7] ^= v7 ^ v15; +} + +void crypto_blake2b_keyed_init(crypto_blake2b_ctx *ctx, size_t hash_size, + const u8 *key, size_t key_size) +{ + // initial hash + COPY(ctx->hash, iv, 8); + ctx->hash[0] ^= 0x01010000 ^ (key_size << 8) ^ hash_size; + + ctx->input_offset[0] = 0; // beginning of the input, no offset + ctx->input_offset[1] = 0; // beginning of the input, no offset + ctx->hash_size = hash_size; + ctx->input_idx = 0; + ZERO(ctx->input, 16); + + // if there is a key, the first block is that key (padded with zeroes) + if (key_size > 0) { + u8 key_block[128] = {0}; + COPY(key_block, key, key_size); + // same as calling crypto_blake2b_update(ctx, key_block , 128) + load64_le_buf(ctx->input, key_block, 16); + ctx->input_idx = 128; + } +} + +void crypto_blake2b_init(crypto_blake2b_ctx *ctx, size_t hash_size) +{ + crypto_blake2b_keyed_init(ctx, hash_size, 0, 0); +} + +void crypto_blake2b_update(crypto_blake2b_ctx *ctx, + const u8 *message, size_t message_size) +{ + // Avoid undefined NULL pointer increments with empty messages + if (message_size == 0) { + return; + } + + // Align with word boundaries + if ((ctx->input_idx & 7) != 0) { + size_t nb_bytes = MIN(gap(ctx->input_idx, 8), message_size); + size_t word = ctx->input_idx >> 3; + size_t byte = ctx->input_idx & 7; + FOR (i, 0, nb_bytes) { + ctx->input[word] |= (u64)message[i] << ((byte + i) << 3); + } + ctx->input_idx += nb_bytes; + message += nb_bytes; + message_size -= nb_bytes; + } + + // Align with block boundaries (faster than byte by byte) + if ((ctx->input_idx & 127) != 0) { + size_t nb_words = MIN(gap(ctx->input_idx, 128), message_size) >> 3; + load64_le_buf(ctx->input + (ctx->input_idx >> 3), message, nb_words); + ctx->input_idx += nb_words << 3; + message += nb_words << 3; + message_size -= nb_words << 3; + } + + // Process block by block + size_t nb_blocks = message_size >> 7; + FOR (i, 0, nb_blocks) { + if (ctx->input_idx == 128) { + blake2b_compress(ctx, 0); + } + load64_le_buf(ctx->input, message, 16); + message += 128; + ctx->input_idx = 128; + } + message_size &= 127; + + if (message_size != 0) { + // Compress block & flush input buffer as needed + if (ctx->input_idx == 128) { + blake2b_compress(ctx, 0); + ctx->input_idx = 0; + } + if (ctx->input_idx == 0) { + ZERO(ctx->input, 16); + } + // Fill remaining words (faster than byte by byte) + size_t nb_words = message_size >> 3; + load64_le_buf(ctx->input, message, nb_words); + ctx->input_idx += nb_words << 3; + message += nb_words << 3; + message_size -= nb_words << 3; + + // Fill remaining bytes + FOR (i, 0, message_size) { + size_t word = ctx->input_idx >> 3; + size_t byte = ctx->input_idx & 7; + ctx->input[word] |= (u64)message[i] << (byte << 3); + ctx->input_idx++; + } + } +} + +void crypto_blake2b_final(crypto_blake2b_ctx *ctx, u8 *hash) +{ + blake2b_compress(ctx, 1); // compress the last block + size_t hash_size = MIN(ctx->hash_size, 64); + size_t nb_words = hash_size >> 3; + store64_le_buf(hash, ctx->hash, nb_words); + FOR (i, nb_words << 3, hash_size) { + hash[i] = (ctx->hash[i >> 3] >> (8 * (i & 7))) & 0xff; + } + WIPE_CTX(ctx); +} + +void crypto_blake2b_keyed(u8 *hash, size_t hash_size, + const u8 *key, size_t key_size, + const u8 *message, size_t message_size) +{ + crypto_blake2b_ctx ctx; + crypto_blake2b_keyed_init(&ctx, hash_size, key, key_size); + crypto_blake2b_update (&ctx, message, message_size); + crypto_blake2b_final (&ctx, hash); +} + +void crypto_blake2b(u8 *hash, size_t hash_size, const u8 *msg, size_t msg_size) +{ + crypto_blake2b_keyed(hash, hash_size, 0, 0, msg, msg_size); +} + +////////////// +/// Argon2 /// +////////////// +// references to R, Z, Q etc. come from the spec + +// Argon2 operates on 1024 byte blocks. +typedef struct { u64 a[128]; } blk; + +// updates a BLAKE2 hash with a 32 bit word, little endian. +static void blake_update_32(crypto_blake2b_ctx *ctx, u32 input) +{ + u8 buf[4]; + store32_le(buf, input); + crypto_blake2b_update(ctx, buf, 4); + WIPE_BUFFER(buf); +} + +static void blake_update_32_buf(crypto_blake2b_ctx *ctx, + const u8 *buf, u32 size) +{ + blake_update_32(ctx, size); + crypto_blake2b_update(ctx, buf, size); +} + + +static void copy_block(blk *o,const blk*in){FOR(i, 0, 128) o->a[i] = in->a[i];} +static void xor_block(blk *o,const blk*in){FOR(i, 0, 128) o->a[i] ^= in->a[i];} + +// Hash with a virtually unlimited digest size. +// Doesn't extract more entropy than the base hash function. +// Mainly used for filling a whole kilobyte block with pseudo-random bytes. +// (One could use a stream cipher with a seed hash as the key, but +// this would introduce another dependency —and point of failure.) +static void extended_hash(u8 *digest, u32 digest_size, + const u8 *input , u32 input_size) +{ + crypto_blake2b_ctx ctx; + crypto_blake2b_init (&ctx, MIN(digest_size, 64)); + blake_update_32 (&ctx, digest_size); + crypto_blake2b_update(&ctx, input, input_size); + crypto_blake2b_final (&ctx, digest); + + if (digest_size > 64) { + // the conversion to u64 avoids integer overflow on + // ludicrously big hash sizes. + u32 r = (u32)(((u64)digest_size + 31) >> 5) - 2; + u32 i = 1; + u32 in = 0; + u32 out = 32; + while (i < r) { + // Input and output overlap. This is intentional + crypto_blake2b(digest + out, 64, digest + in, 64); + i += 1; + in += 32; + out += 32; + } + crypto_blake2b(digest + out, digest_size - (32 * r), digest + in , 64); + } +} + +#define LSB(x) ((u64)(u32)x) +#define G(a, b, c, d) \ + a += b + ((LSB(a) * LSB(b)) << 1); d ^= a; d = rotr64(d, 32); \ + c += d + ((LSB(c) * LSB(d)) << 1); b ^= c; b = rotr64(b, 24); \ + a += b + ((LSB(a) * LSB(b)) << 1); d ^= a; d = rotr64(d, 16); \ + c += d + ((LSB(c) * LSB(d)) << 1); b ^= c; b = rotr64(b, 63) +#define ROUND(v0, v1, v2, v3, v4, v5, v6, v7, \ + v8, v9, v10, v11, v12, v13, v14, v15) \ + G(v0, v4, v8, v12); G(v1, v5, v9, v13); \ + G(v2, v6, v10, v14); G(v3, v7, v11, v15); \ + G(v0, v5, v10, v15); G(v1, v6, v11, v12); \ + G(v2, v7, v8, v13); G(v3, v4, v9, v14) + +// Core of the compression function G. Computes Z from R in place. +static void g_rounds(blk *b) +{ + // column rounds (work_block = Q) + for (int i = 0; i < 128; i += 16) { + ROUND(b->a[i ], b->a[i+ 1], b->a[i+ 2], b->a[i+ 3], + b->a[i+ 4], b->a[i+ 5], b->a[i+ 6], b->a[i+ 7], + b->a[i+ 8], b->a[i+ 9], b->a[i+10], b->a[i+11], + b->a[i+12], b->a[i+13], b->a[i+14], b->a[i+15]); + } + // row rounds (b = Z) + for (int i = 0; i < 16; i += 2) { + ROUND(b->a[i ], b->a[i+ 1], b->a[i+ 16], b->a[i+ 17], + b->a[i+32], b->a[i+33], b->a[i+ 48], b->a[i+ 49], + b->a[i+64], b->a[i+65], b->a[i+ 80], b->a[i+ 81], + b->a[i+96], b->a[i+97], b->a[i+112], b->a[i+113]); + } +} + +const crypto_argon2_extras crypto_argon2_no_extras = { 0, 0, 0, 0 }; + +void crypto_argon2(u8 *hash, u32 hash_size, void *work_area, + crypto_argon2_config config, + crypto_argon2_inputs inputs, + crypto_argon2_extras extras) +{ + const u32 segment_size = config.nb_blocks / config.nb_lanes / 4; + const u32 lane_size = segment_size * 4; + const u32 nb_blocks = lane_size * config.nb_lanes; // rounding down + + // work area seen as blocks (must be suitably aligned) + blk *blocks = (blk*)work_area; + { + u8 initial_hash[72]; // 64 bytes plus 2 words for future hashes + crypto_blake2b_ctx ctx; + crypto_blake2b_init (&ctx, 64); + blake_update_32 (&ctx, config.nb_lanes ); // p: number of "threads" + blake_update_32 (&ctx, hash_size); + blake_update_32 (&ctx, config.nb_blocks); + blake_update_32 (&ctx, config.nb_passes); + blake_update_32 (&ctx, 0x13); // v: version number + blake_update_32 (&ctx, config.algorithm); // y: Argon2i, Argon2d... + blake_update_32_buf (&ctx, inputs.pass, inputs.pass_size); + blake_update_32_buf (&ctx, inputs.salt, inputs.salt_size); + blake_update_32_buf (&ctx, extras.key, extras.key_size); + blake_update_32_buf (&ctx, extras.ad, extras.ad_size); + crypto_blake2b_final(&ctx, initial_hash); // fill 64 first bytes only + + // fill first 2 blocks of each lane + u8 hash_area[1024]; + FOR_T(u32, l, 0, config.nb_lanes) { + FOR_T(u32, i, 0, 2) { + store32_le(initial_hash + 64, i); // first additional word + store32_le(initial_hash + 68, l); // second additional word + extended_hash(hash_area, 1024, initial_hash, 72); + load64_le_buf(blocks[l * lane_size + i].a, hash_area, 128); + } + } + + WIPE_BUFFER(initial_hash); + WIPE_BUFFER(hash_area); + } + + // Argon2i and Argon2id start with constant time indexing + int constant_time = config.algorithm != CRYPTO_ARGON2_D; + + // Fill (and re-fill) the rest of the blocks + // + // Note: even though each segment within the same slice can be + // computed in parallel, (one thread per lane), we are computing + // them sequentially, because Monocypher doesn't support threads. + // + // Yet optimal performance (and therefore security) requires one + // thread per lane. The only reason Monocypher supports multiple + // lanes is compatibility. + blk tmp; + FOR_T(u32, pass, 0, config.nb_passes) { + FOR_T(u32, slice, 0, 4) { + // On the first slice of the first pass, + // blocks 0 and 1 are already filled, hence pass_offset. + u32 pass_offset = pass == 0 && slice == 0 ? 2 : 0; + u32 slice_offset = slice * segment_size; + + // Argon2id switches back to non-constant time indexing + // after the first two slices of the first pass + if (slice == 2 && config.algorithm == CRYPTO_ARGON2_ID) { + constant_time = 0; + } + + // Each iteration of the following loop may be performed in + // a separate thread. All segments must be fully completed + // before we start filling the next slice. + FOR_T(u32, segment, 0, config.nb_lanes) { + blk index_block; + u32 index_ctr = 1; + FOR_T (u32, block, pass_offset, segment_size) { + // Current and previous blocks + u32 lane_offset = segment * lane_size; + blk *segment_start = blocks + lane_offset + slice_offset; + blk *current = segment_start + block; + blk *previous = + block == 0 && slice_offset == 0 + ? segment_start + lane_size - 1 + : segment_start + block - 1; + + u64 index_seed; + if (constant_time) { + if (block == pass_offset || (block % 128) == 0) { + // Fill or refresh deterministic indices block + + // seed the beginning of the block... + ZERO(index_block.a, 128); + index_block.a[0] = pass; + index_block.a[1] = segment; + index_block.a[2] = slice; + index_block.a[3] = nb_blocks; + index_block.a[4] = config.nb_passes; + index_block.a[5] = config.algorithm; + index_block.a[6] = index_ctr; + index_ctr++; + + // ... then shuffle it + copy_block(&tmp, &index_block); + g_rounds (&index_block); + xor_block (&index_block, &tmp); + copy_block(&tmp, &index_block); + g_rounds (&index_block); + xor_block (&index_block, &tmp); + } + index_seed = index_block.a[block % 128]; + } else { + index_seed = previous->a[0]; + } + + // Establish the reference set. *Approximately* comprises: + // - The last 3 slices (if they exist yet) + // - The already constructed blocks in the current segment + u32 next_slice = ((slice + 1) % 4) * segment_size; + u32 window_start = pass == 0 ? 0 : next_slice; + u32 nb_segments = pass == 0 ? slice : 3; + u64 lane = + pass == 0 && slice == 0 + ? segment + : (index_seed >> 32) % config.nb_lanes; + u32 window_size = + nb_segments * segment_size + + (lane == segment ? block-1 : + block == 0 ? (u32)-1 : 0); + + // Find reference block + u64 j1 = index_seed & 0xffffffff; // block selector + u64 x = (j1 * j1) >> 32; + u64 y = (window_size * x) >> 32; + u64 z = (window_size - 1) - y; + u64 ref = (window_start + z) % lane_size; + u32 index = lane * lane_size + (u32)ref; + blk *reference = blocks + index; + + // Shuffle the previous & reference block + // into the current block + copy_block(&tmp, previous); + xor_block (&tmp, reference); + if (pass == 0) { copy_block(current, &tmp); } + else { xor_block (current, &tmp); } + g_rounds (&tmp); + xor_block (current, &tmp); + } + } + } + } + + // Wipe temporary block + volatile u64* p = tmp.a; + ZERO(p, 128); + + // XOR last blocks of each lane + blk *last_block = blocks + lane_size - 1; + FOR_T (u32, lane, 1, config.nb_lanes) { + blk *next_block = last_block + lane_size; + xor_block(next_block, last_block); + last_block = next_block; + } + + // Serialize last block + u8 final_block[1024]; + store64_le_buf(final_block, last_block->a, 128); + + // Wipe work area + p = (u64*)work_area; + ZERO(p, 128 * nb_blocks); + + // Hash the very last block with H' into the output hash + extended_hash(hash, hash_size, final_block, 1024); + WIPE_BUFFER(final_block); +} + +//////////////////////////////////// +/// Arithmetic modulo 2^255 - 19 /// +//////////////////////////////////// +// Originally taken from SUPERCOP's ref10 implementation. +// A bit bigger than TweetNaCl, over 4 times faster. + +// field element +typedef i32 fe[10]; + +// field constants +// +// fe_one : 1 +// sqrtm1 : sqrt(-1) +// d : -121665 / 121666 +// D2 : 2 * -121665 / 121666 +// lop_x, lop_y: low order point in Edwards coordinates +// ufactor : -sqrt(-1) * 2 +// A2 : 486662^2 (A squared) +static const fe fe_one = {1}; +static const fe sqrtm1 = { + -32595792, -7943725, 9377950, 3500415, 12389472, + -272473, -25146209, -2005654, 326686, 11406482, +}; +static const fe d = { + -10913610, 13857413, -15372611, 6949391, 114729, + -8787816, -6275908, -3247719, -18696448, -12055116, +}; +static const fe D2 = { + -21827239, -5839606, -30745221, 13898782, 229458, + 15978800, -12551817, -6495438, 29715968, 9444199, +}; +static const fe lop_x = { + 21352778, 5345713, 4660180, -8347857, 24143090, + 14568123, 30185756, -12247770, -33528939, 8345319, +}; +static const fe lop_y = { + -6952922, -1265500, 6862341, -7057498, -4037696, + -5447722, 31680899, -15325402, -19365852, 1569102, +}; +static const fe ufactor = { + -1917299, 15887451, -18755900, -7000830, -24778944, + 544946, -16816446, 4011309, -653372, 10741468, +}; +static const fe A2 = { + 12721188, 3529, 0, 0, 0, 0, 0, 0, 0, 0, +}; + +static void fe_0(fe h) { ZERO(h , 10); } +static void fe_1(fe h) { h[0] = 1; ZERO(h+1, 9); } + +static void fe_copy(fe h,const fe f ){FOR(i,0,10) h[i] = f[i]; } +static void fe_neg (fe h,const fe f ){FOR(i,0,10) h[i] = -f[i]; } +static void fe_add (fe h,const fe f,const fe g){FOR(i,0,10) h[i] = f[i] + g[i];} +static void fe_sub (fe h,const fe f,const fe g){FOR(i,0,10) h[i] = f[i] - g[i];} + +static void fe_cswap(fe f, fe g, int b) +{ + i32 mask = -b; // -1 = 0xffffffff + FOR (i, 0, 10) { + i32 x = (f[i] ^ g[i]) & mask; + f[i] = f[i] ^ x; + g[i] = g[i] ^ x; + } +} + +static void fe_ccopy(fe f, const fe g, int b) +{ + i32 mask = -b; // -1 = 0xffffffff + FOR (i, 0, 10) { + i32 x = (f[i] ^ g[i]) & mask; + f[i] = f[i] ^ x; + } +} + + +// Signed carry propagation +// ------------------------ +// +// Let t be a number. It can be uniquely decomposed thus: +// +// t = h*2^26 + l +// such that -2^25 <= l < 2^25 +// +// Let c = (t + 2^25) / 2^26 (rounded down) +// c = (h*2^26 + l + 2^25) / 2^26 (rounded down) +// c = h + (l + 2^25) / 2^26 (rounded down) +// c = h (exactly) +// Because 0 <= l + 2^25 < 2^26 +// +// Let u = t - c*2^26 +// u = h*2^26 + l - h*2^26 +// u = l +// Therefore, -2^25 <= u < 2^25 +// +// Additionally, if |t| < x, then |h| < x/2^26 (rounded down) +// +// Notations: +// - In C, 1<<25 means 2^25. +// - In C, x>>25 means floor(x / (2^25)). +// - All of the above applies with 25 & 24 as well as 26 & 25. +// +// +// Note on negative right shifts +// ----------------------------- +// +// In C, x >> n, where x is a negative integer, is implementation +// defined. In practice, all platforms do arithmetic shift, which is +// equivalent to division by 2^26, rounded down. Some compilers, like +// GCC, even guarantee it. +// +// If we ever stumble upon a platform that does not propagate the sign +// bit (we won't), visible failures will show at the slightest test, and +// the signed shifts can be replaced by the following: +// +// typedef struct { i64 x:39; } s25; +// typedef struct { i64 x:38; } s26; +// i64 shift25(i64 x) { s25 s; s.x = ((u64)x)>>25; return s.x; } +// i64 shift26(i64 x) { s26 s; s.x = ((u64)x)>>26; return s.x; } +// +// Current compilers cannot optimise this, causing a 30% drop in +// performance. Fairly expensive for something that never happens. +// +// +// Precondition +// ------------ +// +// |t0| < 2^63 +// |t1|..|t9| < 2^62 +// +// Algorithm +// --------- +// c = t0 + 2^25 / 2^26 -- |c| <= 2^36 +// t0 -= c * 2^26 -- |t0| <= 2^25 +// t1 += c -- |t1| <= 2^63 +// +// c = t4 + 2^25 / 2^26 -- |c| <= 2^36 +// t4 -= c * 2^26 -- |t4| <= 2^25 +// t5 += c -- |t5| <= 2^63 +// +// c = t1 + 2^24 / 2^25 -- |c| <= 2^38 +// t1 -= c * 2^25 -- |t1| <= 2^24 +// t2 += c -- |t2| <= 2^63 +// +// c = t5 + 2^24 / 2^25 -- |c| <= 2^38 +// t5 -= c * 2^25 -- |t5| <= 2^24 +// t6 += c -- |t6| <= 2^63 +// +// c = t2 + 2^25 / 2^26 -- |c| <= 2^37 +// t2 -= c * 2^26 -- |t2| <= 2^25 < 1.1 * 2^25 (final t2) +// t3 += c -- |t3| <= 2^63 +// +// c = t6 + 2^25 / 2^26 -- |c| <= 2^37 +// t6 -= c * 2^26 -- |t6| <= 2^25 < 1.1 * 2^25 (final t6) +// t7 += c -- |t7| <= 2^63 +// +// c = t3 + 2^24 / 2^25 -- |c| <= 2^38 +// t3 -= c * 2^25 -- |t3| <= 2^24 < 1.1 * 2^24 (final t3) +// t4 += c -- |t4| <= 2^25 + 2^38 < 2^39 +// +// c = t7 + 2^24 / 2^25 -- |c| <= 2^38 +// t7 -= c * 2^25 -- |t7| <= 2^24 < 1.1 * 2^24 (final t7) +// t8 += c -- |t8| <= 2^63 +// +// c = t4 + 2^25 / 2^26 -- |c| <= 2^13 +// t4 -= c * 2^26 -- |t4| <= 2^25 < 1.1 * 2^25 (final t4) +// t5 += c -- |t5| <= 2^24 + 2^13 < 1.1 * 2^24 (final t5) +// +// c = t8 + 2^25 / 2^26 -- |c| <= 2^37 +// t8 -= c * 2^26 -- |t8| <= 2^25 < 1.1 * 2^25 (final t8) +// t9 += c -- |t9| <= 2^63 +// +// c = t9 + 2^24 / 2^25 -- |c| <= 2^38 +// t9 -= c * 2^25 -- |t9| <= 2^24 < 1.1 * 2^24 (final t9) +// t0 += c * 19 -- |t0| <= 2^25 + 2^38*19 < 2^44 +// +// c = t0 + 2^25 / 2^26 -- |c| <= 2^18 +// t0 -= c * 2^26 -- |t0| <= 2^25 < 1.1 * 2^25 (final t0) +// t1 += c -- |t1| <= 2^24 + 2^18 < 1.1 * 2^24 (final t1) +// +// Postcondition +// ------------- +// |t0|, |t2|, |t4|, |t6|, |t8| < 1.1 * 2^25 +// |t1|, |t3|, |t5|, |t7|, |t9| < 1.1 * 2^24 +#define FE_CARRY \ + i64 c; \ + c = (t0 + ((i64)1<<25)) >> 26; t0 -= c * ((i64)1 << 26); t1 += c; \ + c = (t4 + ((i64)1<<25)) >> 26; t4 -= c * ((i64)1 << 26); t5 += c; \ + c = (t1 + ((i64)1<<24)) >> 25; t1 -= c * ((i64)1 << 25); t2 += c; \ + c = (t5 + ((i64)1<<24)) >> 25; t5 -= c * ((i64)1 << 25); t6 += c; \ + c = (t2 + ((i64)1<<25)) >> 26; t2 -= c * ((i64)1 << 26); t3 += c; \ + c = (t6 + ((i64)1<<25)) >> 26; t6 -= c * ((i64)1 << 26); t7 += c; \ + c = (t3 + ((i64)1<<24)) >> 25; t3 -= c * ((i64)1 << 25); t4 += c; \ + c = (t7 + ((i64)1<<24)) >> 25; t7 -= c * ((i64)1 << 25); t8 += c; \ + c = (t4 + ((i64)1<<25)) >> 26; t4 -= c * ((i64)1 << 26); t5 += c; \ + c = (t8 + ((i64)1<<25)) >> 26; t8 -= c * ((i64)1 << 26); t9 += c; \ + c = (t9 + ((i64)1<<24)) >> 25; t9 -= c * ((i64)1 << 25); t0 += c * 19; \ + c = (t0 + ((i64)1<<25)) >> 26; t0 -= c * ((i64)1 << 26); t1 += c; \ + h[0]=(i32)t0; h[1]=(i32)t1; h[2]=(i32)t2; h[3]=(i32)t3; h[4]=(i32)t4; \ + h[5]=(i32)t5; h[6]=(i32)t6; h[7]=(i32)t7; h[8]=(i32)t8; h[9]=(i32)t9 + +// Decodes a field element from a byte buffer. +// mask specifies how many bits we ignore. +// Traditionally we ignore 1. It's useful for EdDSA, +// which uses that bit to denote the sign of x. +// Elligator however uses positive representatives, +// which means ignoring 2 bits instead. +static void fe_frombytes_mask(fe h, const u8 s[32], unsigned nb_mask) +{ + u32 mask = 0xffffff >> nb_mask; + i64 t0 = load32_le(s); // t0 < 2^32 + i64 t1 = load24_le(s + 4) << 6; // t1 < 2^30 + i64 t2 = load24_le(s + 7) << 5; // t2 < 2^29 + i64 t3 = load24_le(s + 10) << 3; // t3 < 2^27 + i64 t4 = load24_le(s + 13) << 2; // t4 < 2^26 + i64 t5 = load32_le(s + 16); // t5 < 2^32 + i64 t6 = load24_le(s + 20) << 7; // t6 < 2^31 + i64 t7 = load24_le(s + 23) << 5; // t7 < 2^29 + i64 t8 = load24_le(s + 26) << 4; // t8 < 2^28 + i64 t9 = (load24_le(s + 29) & mask) << 2; // t9 < 2^25 + FE_CARRY; // Carry precondition OK +} + +static void fe_frombytes(fe h, const u8 s[32]) +{ + fe_frombytes_mask(h, s, 1); +} + + +// Precondition +// |h[0]|, |h[2]|, |h[4]|, |h[6]|, |h[8]| < 1.1 * 2^25 +// |h[1]|, |h[3]|, |h[5]|, |h[7]|, |h[9]| < 1.1 * 2^24 +// +// Therefore, |h| < 2^255-19 +// There are two possibilities: +// +// - If h is positive, all we need to do is reduce its individual +// limbs down to their tight positive range. +// - If h is negative, we also need to add 2^255-19 to it. +// Or just remove 19 and chop off any excess bit. +static void fe_tobytes(u8 s[32], const fe h) +{ + i32 t[10]; + COPY(t, h, 10); + i32 q = (19 * t[9] + (((i32) 1) << 24)) >> 25; + // |t9| < 1.1 * 2^24 + // -1.1 * 2^24 < t9 < 1.1 * 2^24 + // -21 * 2^24 < 19 * t9 < 21 * 2^24 + // -2^29 < 19 * t9 + 2^24 < 2^29 + // -2^29 / 2^25 < (19 * t9 + 2^24) / 2^25 < 2^29 / 2^25 + // -16 < (19 * t9 + 2^24) / 2^25 < 16 + FOR (i, 0, 5) { + q += t[2*i ]; q >>= 26; // q = 0 or -1 + q += t[2*i+1]; q >>= 25; // q = 0 or -1 + } + // q = 0 iff h >= 0 + // q = -1 iff h < 0 + // Adding q * 19 to h reduces h to its proper range. + q *= 19; // Shift carry back to the beginning + FOR (i, 0, 5) { + t[i*2 ] += q; q = t[i*2 ] >> 26; t[i*2 ] -= q * ((i32)1 << 26); + t[i*2+1] += q; q = t[i*2+1] >> 25; t[i*2+1] -= q * ((i32)1 << 25); + } + // h is now fully reduced, and q represents the excess bit. + + store32_le(s + 0, ((u32)t[0] >> 0) | ((u32)t[1] << 26)); + store32_le(s + 4, ((u32)t[1] >> 6) | ((u32)t[2] << 19)); + store32_le(s + 8, ((u32)t[2] >> 13) | ((u32)t[3] << 13)); + store32_le(s + 12, ((u32)t[3] >> 19) | ((u32)t[4] << 6)); + store32_le(s + 16, ((u32)t[5] >> 0) | ((u32)t[6] << 25)); + store32_le(s + 20, ((u32)t[6] >> 7) | ((u32)t[7] << 19)); + store32_le(s + 24, ((u32)t[7] >> 13) | ((u32)t[8] << 12)); + store32_le(s + 28, ((u32)t[8] >> 20) | ((u32)t[9] << 6)); + + WIPE_BUFFER(t); +} + +// Precondition +// ------------- +// |f0|, |f2|, |f4|, |f6|, |f8| < 1.65 * 2^26 +// |f1|, |f3|, |f5|, |f7|, |f9| < 1.65 * 2^25 +// +// |g0|, |g2|, |g4|, |g6|, |g8| < 1.65 * 2^26 +// |g1|, |g3|, |g5|, |g7|, |g9| < 1.65 * 2^25 +static void fe_mul_small(fe h, const fe f, i32 g) +{ + i64 t0 = f[0] * (i64) g; i64 t1 = f[1] * (i64) g; + i64 t2 = f[2] * (i64) g; i64 t3 = f[3] * (i64) g; + i64 t4 = f[4] * (i64) g; i64 t5 = f[5] * (i64) g; + i64 t6 = f[6] * (i64) g; i64 t7 = f[7] * (i64) g; + i64 t8 = f[8] * (i64) g; i64 t9 = f[9] * (i64) g; + // |t0|, |t2|, |t4|, |t6|, |t8| < 1.65 * 2^26 * 2^31 < 2^58 + // |t1|, |t3|, |t5|, |t7|, |t9| < 1.65 * 2^25 * 2^31 < 2^57 + + FE_CARRY; // Carry precondition OK +} + +// Precondition +// ------------- +// |f0|, |f2|, |f4|, |f6|, |f8| < 1.65 * 2^26 +// |f1|, |f3|, |f5|, |f7|, |f9| < 1.65 * 2^25 +// +// |g0|, |g2|, |g4|, |g6|, |g8| < 1.65 * 2^26 +// |g1|, |g3|, |g5|, |g7|, |g9| < 1.65 * 2^25 +static void fe_mul(fe h, const fe f, const fe g) +{ + // Everything is unrolled and put in temporary variables. + // We could roll the loop, but that would make curve25519 twice as slow. + i32 f0 = f[0]; i32 f1 = f[1]; i32 f2 = f[2]; i32 f3 = f[3]; i32 f4 = f[4]; + i32 f5 = f[5]; i32 f6 = f[6]; i32 f7 = f[7]; i32 f8 = f[8]; i32 f9 = f[9]; + i32 g0 = g[0]; i32 g1 = g[1]; i32 g2 = g[2]; i32 g3 = g[3]; i32 g4 = g[4]; + i32 g5 = g[5]; i32 g6 = g[6]; i32 g7 = g[7]; i32 g8 = g[8]; i32 g9 = g[9]; + i32 F1 = f1*2; i32 F3 = f3*2; i32 F5 = f5*2; i32 F7 = f7*2; i32 F9 = f9*2; + i32 G1 = g1*19; i32 G2 = g2*19; i32 G3 = g3*19; + i32 G4 = g4*19; i32 G5 = g5*19; i32 G6 = g6*19; + i32 G7 = g7*19; i32 G8 = g8*19; i32 G9 = g9*19; + // |F1|, |F3|, |F5|, |F7|, |F9| < 1.65 * 2^26 + // |G0|, |G2|, |G4|, |G6|, |G8| < 2^31 + // |G1|, |G3|, |G5|, |G7|, |G9| < 2^30 + + i64 t0 = f0*(i64)g0 + F1*(i64)G9 + f2*(i64)G8 + F3*(i64)G7 + f4*(i64)G6 + + F5*(i64)G5 + f6*(i64)G4 + F7*(i64)G3 + f8*(i64)G2 + F9*(i64)G1; + i64 t1 = f0*(i64)g1 + f1*(i64)g0 + f2*(i64)G9 + f3*(i64)G8 + f4*(i64)G7 + + f5*(i64)G6 + f6*(i64)G5 + f7*(i64)G4 + f8*(i64)G3 + f9*(i64)G2; + i64 t2 = f0*(i64)g2 + F1*(i64)g1 + f2*(i64)g0 + F3*(i64)G9 + f4*(i64)G8 + + F5*(i64)G7 + f6*(i64)G6 + F7*(i64)G5 + f8*(i64)G4 + F9*(i64)G3; + i64 t3 = f0*(i64)g3 + f1*(i64)g2 + f2*(i64)g1 + f3*(i64)g0 + f4*(i64)G9 + + f5*(i64)G8 + f6*(i64)G7 + f7*(i64)G6 + f8*(i64)G5 + f9*(i64)G4; + i64 t4 = f0*(i64)g4 + F1*(i64)g3 + f2*(i64)g2 + F3*(i64)g1 + f4*(i64)g0 + + F5*(i64)G9 + f6*(i64)G8 + F7*(i64)G7 + f8*(i64)G6 + F9*(i64)G5; + i64 t5 = f0*(i64)g5 + f1*(i64)g4 + f2*(i64)g3 + f3*(i64)g2 + f4*(i64)g1 + + f5*(i64)g0 + f6*(i64)G9 + f7*(i64)G8 + f8*(i64)G7 + f9*(i64)G6; + i64 t6 = f0*(i64)g6 + F1*(i64)g5 + f2*(i64)g4 + F3*(i64)g3 + f4*(i64)g2 + + F5*(i64)g1 + f6*(i64)g0 + F7*(i64)G9 + f8*(i64)G8 + F9*(i64)G7; + i64 t7 = f0*(i64)g7 + f1*(i64)g6 + f2*(i64)g5 + f3*(i64)g4 + f4*(i64)g3 + + f5*(i64)g2 + f6*(i64)g1 + f7*(i64)g0 + f8*(i64)G9 + f9*(i64)G8; + i64 t8 = f0*(i64)g8 + F1*(i64)g7 + f2*(i64)g6 + F3*(i64)g5 + f4*(i64)g4 + + F5*(i64)g3 + f6*(i64)g2 + F7*(i64)g1 + f8*(i64)g0 + F9*(i64)G9; + i64 t9 = f0*(i64)g9 + f1*(i64)g8 + f2*(i64)g7 + f3*(i64)g6 + f4*(i64)g5 + + f5*(i64)g4 + f6*(i64)g3 + f7*(i64)g2 + f8*(i64)g1 + f9*(i64)g0; + // t0 < 0.67 * 2^61 + // t1 < 0.41 * 2^61 + // t2 < 0.52 * 2^61 + // t3 < 0.32 * 2^61 + // t4 < 0.38 * 2^61 + // t5 < 0.22 * 2^61 + // t6 < 0.23 * 2^61 + // t7 < 0.13 * 2^61 + // t8 < 0.09 * 2^61 + // t9 < 0.03 * 2^61 + + FE_CARRY; // Everything below 2^62, Carry precondition OK +} + +// Precondition +// ------------- +// |f0|, |f2|, |f4|, |f6|, |f8| < 1.65 * 2^26 +// |f1|, |f3|, |f5|, |f7|, |f9| < 1.65 * 2^25 +// +// Note: we could use fe_mul() for this, but this is significantly faster +static void fe_sq(fe h, const fe f) +{ + i32 f0 = f[0]; i32 f1 = f[1]; i32 f2 = f[2]; i32 f3 = f[3]; i32 f4 = f[4]; + i32 f5 = f[5]; i32 f6 = f[6]; i32 f7 = f[7]; i32 f8 = f[8]; i32 f9 = f[9]; + i32 f0_2 = f0*2; i32 f1_2 = f1*2; i32 f2_2 = f2*2; i32 f3_2 = f3*2; + i32 f4_2 = f4*2; i32 f5_2 = f5*2; i32 f6_2 = f6*2; i32 f7_2 = f7*2; + i32 f5_38 = f5*38; i32 f6_19 = f6*19; i32 f7_38 = f7*38; + i32 f8_19 = f8*19; i32 f9_38 = f9*38; + // |f0_2| , |f2_2| , |f4_2| , |f6_2| , |f8_2| < 1.65 * 2^27 + // |f1_2| , |f3_2| , |f5_2| , |f7_2| , |f9_2| < 1.65 * 2^26 + // |f5_38|, |f6_19|, |f7_38|, |f8_19|, |f9_38| < 2^31 + + i64 t0 = f0 *(i64)f0 + f1_2*(i64)f9_38 + f2_2*(i64)f8_19 + + f3_2*(i64)f7_38 + f4_2*(i64)f6_19 + f5 *(i64)f5_38; + i64 t1 = f0_2*(i64)f1 + f2 *(i64)f9_38 + f3_2*(i64)f8_19 + + f4 *(i64)f7_38 + f5_2*(i64)f6_19; + i64 t2 = f0_2*(i64)f2 + f1_2*(i64)f1 + f3_2*(i64)f9_38 + + f4_2*(i64)f8_19 + f5_2*(i64)f7_38 + f6 *(i64)f6_19; + i64 t3 = f0_2*(i64)f3 + f1_2*(i64)f2 + f4 *(i64)f9_38 + + f5_2*(i64)f8_19 + f6 *(i64)f7_38; + i64 t4 = f0_2*(i64)f4 + f1_2*(i64)f3_2 + f2 *(i64)f2 + + f5_2*(i64)f9_38 + f6_2*(i64)f8_19 + f7 *(i64)f7_38; + i64 t5 = f0_2*(i64)f5 + f1_2*(i64)f4 + f2_2*(i64)f3 + + f6 *(i64)f9_38 + f7_2*(i64)f8_19; + i64 t6 = f0_2*(i64)f6 + f1_2*(i64)f5_2 + f2_2*(i64)f4 + + f3_2*(i64)f3 + f7_2*(i64)f9_38 + f8 *(i64)f8_19; + i64 t7 = f0_2*(i64)f7 + f1_2*(i64)f6 + f2_2*(i64)f5 + + f3_2*(i64)f4 + f8 *(i64)f9_38; + i64 t8 = f0_2*(i64)f8 + f1_2*(i64)f7_2 + f2_2*(i64)f6 + + f3_2*(i64)f5_2 + f4 *(i64)f4 + f9 *(i64)f9_38; + i64 t9 = f0_2*(i64)f9 + f1_2*(i64)f8 + f2_2*(i64)f7 + + f3_2*(i64)f6 + f4 *(i64)f5_2; + // t0 < 0.67 * 2^61 + // t1 < 0.41 * 2^61 + // t2 < 0.52 * 2^61 + // t3 < 0.32 * 2^61 + // t4 < 0.38 * 2^61 + // t5 < 0.22 * 2^61 + // t6 < 0.23 * 2^61 + // t7 < 0.13 * 2^61 + // t8 < 0.09 * 2^61 + // t9 < 0.03 * 2^61 + + FE_CARRY; +} + +// Parity check. Returns 0 if even, 1 if odd +static int fe_isodd(const fe f) +{ + u8 s[32]; + fe_tobytes(s, f); + u8 isodd = s[0] & 1; + WIPE_BUFFER(s); + return isodd; +} + +// Returns 1 if equal, 0 if not equal +static int fe_isequal(const fe f, const fe g) +{ + u8 fs[32]; + u8 gs[32]; + fe_tobytes(fs, f); + fe_tobytes(gs, g); + int isdifferent = crypto_verify32(fs, gs); + WIPE_BUFFER(fs); + WIPE_BUFFER(gs); + return 1 + isdifferent; +} + +// Inverse square root. +// Returns true if x is a square, false otherwise. +// After the call: +// isr = sqrt(1/x) if x is a non-zero square. +// isr = sqrt(sqrt(-1)/x) if x is not a square. +// isr = 0 if x is zero. +// We do not guarantee the sign of the square root. +// +// Notes: +// Let quartic = x^((p-1)/4) +// +// x^((p-1)/2) = chi(x) +// quartic^2 = chi(x) +// quartic = sqrt(chi(x)) +// quartic = 1 or -1 or sqrt(-1) or -sqrt(-1) +// +// Note that x is a square if quartic is 1 or -1 +// There are 4 cases to consider: +// +// if quartic = 1 (x is a square) +// then x^((p-1)/4) = 1 +// x^((p-5)/4) * x = 1 +// x^((p-5)/4) = 1/x +// x^((p-5)/8) = sqrt(1/x) or -sqrt(1/x) +// +// if quartic = -1 (x is a square) +// then x^((p-1)/4) = -1 +// x^((p-5)/4) * x = -1 +// x^((p-5)/4) = -1/x +// x^((p-5)/8) = sqrt(-1) / sqrt(x) +// x^((p-5)/8) * sqrt(-1) = sqrt(-1)^2 / sqrt(x) +// x^((p-5)/8) * sqrt(-1) = -1/sqrt(x) +// x^((p-5)/8) * sqrt(-1) = -sqrt(1/x) or sqrt(1/x) +// +// if quartic = sqrt(-1) (x is not a square) +// then x^((p-1)/4) = sqrt(-1) +// x^((p-5)/4) * x = sqrt(-1) +// x^((p-5)/4) = sqrt(-1)/x +// x^((p-5)/8) = sqrt(sqrt(-1)/x) or -sqrt(sqrt(-1)/x) +// +// Note that the product of two non-squares is always a square: +// For any non-squares a and b, chi(a) = -1 and chi(b) = -1. +// Since chi(x) = x^((p-1)/2), chi(a)*chi(b) = chi(a*b) = 1. +// Therefore a*b is a square. +// +// Since sqrt(-1) and x are both non-squares, their product is a +// square, and we can compute their square root. +// +// if quartic = -sqrt(-1) (x is not a square) +// then x^((p-1)/4) = -sqrt(-1) +// x^((p-5)/4) * x = -sqrt(-1) +// x^((p-5)/4) = -sqrt(-1)/x +// x^((p-5)/8) = sqrt(-sqrt(-1)/x) +// x^((p-5)/8) = sqrt( sqrt(-1)/x) * sqrt(-1) +// x^((p-5)/8) * sqrt(-1) = sqrt( sqrt(-1)/x) * sqrt(-1)^2 +// x^((p-5)/8) * sqrt(-1) = sqrt( sqrt(-1)/x) * -1 +// x^((p-5)/8) * sqrt(-1) = -sqrt(sqrt(-1)/x) or sqrt(sqrt(-1)/x) +static int invsqrt(fe isr, const fe x) +{ + fe t0, t1, t2; + + // t0 = x^((p-5)/8) + // Can be achieved with a simple double & add ladder, + // but it would be slower. + fe_sq(t0, x); + fe_sq(t1,t0); fe_sq(t1, t1); fe_mul(t1, x, t1); + fe_mul(t0, t0, t1); + fe_sq(t0, t0); fe_mul(t0, t1, t0); + fe_sq(t1, t0); FOR (i, 1, 5) { fe_sq(t1, t1); } fe_mul(t0, t1, t0); + fe_sq(t1, t0); FOR (i, 1, 10) { fe_sq(t1, t1); } fe_mul(t1, t1, t0); + fe_sq(t2, t1); FOR (i, 1, 20) { fe_sq(t2, t2); } fe_mul(t1, t2, t1); + fe_sq(t1, t1); FOR (i, 1, 10) { fe_sq(t1, t1); } fe_mul(t0, t1, t0); + fe_sq(t1, t0); FOR (i, 1, 50) { fe_sq(t1, t1); } fe_mul(t1, t1, t0); + fe_sq(t2, t1); FOR (i, 1, 100) { fe_sq(t2, t2); } fe_mul(t1, t2, t1); + fe_sq(t1, t1); FOR (i, 1, 50) { fe_sq(t1, t1); } fe_mul(t0, t1, t0); + fe_sq(t0, t0); FOR (i, 1, 2) { fe_sq(t0, t0); } fe_mul(t0, t0, x); + + // quartic = x^((p-1)/4) + i32 *quartic = t1; + fe_sq (quartic, t0); + fe_mul(quartic, quartic, x); + + i32 *check = t2; + fe_0 (check); int z0 = fe_isequal(x , check); + fe_1 (check); int p1 = fe_isequal(quartic, check); + fe_neg(check, check ); int m1 = fe_isequal(quartic, check); + fe_neg(check, sqrtm1); int ms = fe_isequal(quartic, check); + + // if quartic == -1 or sqrt(-1) + // then isr = x^((p-1)/4) * sqrt(-1) + // else isr = x^((p-1)/4) + fe_mul(isr, t0, sqrtm1); + fe_ccopy(isr, t0, 1 - (m1 | ms)); + + WIPE_BUFFER(t0); + WIPE_BUFFER(t1); + WIPE_BUFFER(t2); + return p1 | m1 | z0; +} + +// Inverse in terms of inverse square root. +// Requires two additional squarings to get rid of the sign. +// +// 1/x = x * (+invsqrt(x^2))^2 +// = x * (-invsqrt(x^2))^2 +// +// A fully optimised exponentiation by p-1 would save 6 field +// multiplications, but it would require more code. +static void fe_invert(fe out, const fe x) +{ + fe tmp; + fe_sq(tmp, x); + invsqrt(tmp, tmp); + fe_sq(tmp, tmp); + fe_mul(out, tmp, x); + WIPE_BUFFER(tmp); +} + +// trim a scalar for scalar multiplication +void crypto_eddsa_trim_scalar(u8 out[32], const u8 in[32]) +{ + COPY(out, in, 32); + out[ 0] &= 248; + out[31] &= 127; + out[31] |= 64; +} + +// get bit from scalar at position i +static int scalar_bit(const u8 s[32], int i) +{ + if (i < 0) { return 0; } // handle -1 for sliding windows + return (s[i>>3] >> (i&7)) & 1; +} + +/////////////// +/// X-25519 /// Taken from SUPERCOP's ref10 implementation. +/////////////// +static void scalarmult(u8 q[32], const u8 scalar[32], const u8 p[32], + int nb_bits) +{ + // computes the scalar product + fe x1; + fe_frombytes(x1, p); + + // computes the actual scalar product (the result is in x2 and z2) + fe x2, z2, x3, z3, t0, t1; + // Montgomery ladder + // In projective coordinates, to avoid divisions: x = X / Z + // We don't care about the y coordinate, it's only 1 bit of information + fe_1(x2); fe_0(z2); // "zero" point + fe_copy(x3, x1); fe_1(z3); // "one" point + int swap = 0; + for (int pos = nb_bits-1; pos >= 0; --pos) { + // constant time conditional swap before ladder step + int b = scalar_bit(scalar, pos); + swap ^= b; // xor trick avoids swapping at the end of the loop + fe_cswap(x2, x3, swap); + fe_cswap(z2, z3, swap); + swap = b; // anticipates one last swap after the loop + + // Montgomery ladder step: replaces (P2, P3) by (P2*2, P2+P3) + // with differential addition + fe_sub(t0, x3, z3); + fe_sub(t1, x2, z2); + fe_add(x2, x2, z2); + fe_add(z2, x3, z3); + fe_mul(z3, t0, x2); + fe_mul(z2, z2, t1); + fe_sq (t0, t1 ); + fe_sq (t1, x2 ); + fe_add(x3, z3, z2); + fe_sub(z2, z3, z2); + fe_mul(x2, t1, t0); + fe_sub(t1, t1, t0); + fe_sq (z2, z2 ); + fe_mul_small(z3, t1, 121666); + fe_sq (x3, x3 ); + fe_add(t0, t0, z3); + fe_mul(z3, x1, z2); + fe_mul(z2, t1, t0); + } + // last swap is necessary to compensate for the xor trick + // Note: after this swap, P3 == P2 + P1. + fe_cswap(x2, x3, swap); + fe_cswap(z2, z3, swap); + + // normalises the coordinates: x == X / Z + fe_invert(z2, z2); + fe_mul(x2, x2, z2); + fe_tobytes(q, x2); + + WIPE_BUFFER(x1); + WIPE_BUFFER(x2); WIPE_BUFFER(z2); WIPE_BUFFER(t0); + WIPE_BUFFER(x3); WIPE_BUFFER(z3); WIPE_BUFFER(t1); +} + +void crypto_x25519(u8 raw_shared_secret[32], + const u8 your_secret_key [32], + const u8 their_public_key [32]) +{ + // restrict the possible scalar values + u8 e[32]; + crypto_eddsa_trim_scalar(e, your_secret_key); + scalarmult(raw_shared_secret, e, their_public_key, 255); + WIPE_BUFFER(e); +} + +void crypto_x25519_public_key(u8 public_key[32], + const u8 secret_key[32]) +{ + static const u8 base_point[32] = {9}; + crypto_x25519(public_key, secret_key, base_point); +} + +/////////////////////////// +/// Arithmetic modulo L /// +/////////////////////////// +static const u32 L[8] = { + 0x5cf5d3ed, 0x5812631a, 0xa2f79cd6, 0x14def9de, + 0x00000000, 0x00000000, 0x00000000, 0x10000000, +}; + +// p = a*b + p +static void multiply(u32 p[16], const u32 a[8], const u32 b[8]) +{ + FOR (i, 0, 8) { + u64 carry = 0; + FOR (j, 0, 8) { + carry += p[i+j] + (u64)a[i] * b[j]; + p[i+j] = (u32)carry; + carry >>= 32; + } + p[i+8] = (u32)carry; + } +} + +static int is_above_l(const u32 x[8]) +{ + // We work with L directly, in a 2's complement encoding + // (-L == ~L + 1) + u64 carry = 1; + FOR (i, 0, 8) { + carry += (u64)x[i] + (~L[i] & 0xffffffff); + carry >>= 32; + } + return (int)carry; // carry is either 0 or 1 +} + +// Final reduction modulo L, by conditionally removing L. +// if x < l , then r = x +// if l <= x 2*l, then r = x-l +// otherwise the result will be wrong +static void remove_l(u32 r[8], const u32 x[8]) +{ + u64 carry = (u64)is_above_l(x); + u32 mask = ~(u32)carry + 1; // carry == 0 or 1 + FOR (i, 0, 8) { + carry += (u64)x[i] + (~L[i] & mask); + r[i] = (u32)carry; + carry >>= 32; + } +} + +// Full reduction modulo L (Barrett reduction) +static void mod_l(u8 reduced[32], const u32 x[16]) +{ + static const u32 r[9] = { + 0x0a2c131b,0xed9ce5a3,0x086329a7,0x2106215d, + 0xffffffeb,0xffffffff,0xffffffff,0xffffffff,0xf, + }; + // xr = x * r + u32 xr[25] = {0}; + FOR (i, 0, 9) { + u64 carry = 0; + FOR (j, 0, 16) { + carry += xr[i+j] + (u64)r[i] * x[j]; + xr[i+j] = (u32)carry; + carry >>= 32; + } + xr[i+16] = (u32)carry; + } + // xr = floor(xr / 2^512) * L + // Since the result is guaranteed to be below 2*L, + // it is enough to only compute the first 256 bits. + // The division is performed by saying xr[i+16]. (16 * 32 = 512) + ZERO(xr, 8); + FOR (i, 0, 8) { + u64 carry = 0; + FOR (j, 0, 8-i) { + carry += xr[i+j] + (u64)xr[i+16] * L[j]; + xr[i+j] = (u32)carry; + carry >>= 32; + } + } + // xr = x - xr + u64 carry = 1; + FOR (i, 0, 8) { + carry += (u64)x[i] + (~xr[i] & 0xffffffff); + xr[i] = (u32)carry; + carry >>= 32; + } + // Final reduction modulo L (conditional subtraction) + remove_l(xr, xr); + store32_le_buf(reduced, xr, 8); + + WIPE_BUFFER(xr); +} + +void crypto_eddsa_reduce(u8 reduced[32], const u8 expanded[64]) +{ + u32 x[16]; + load32_le_buf(x, expanded, 16); + mod_l(reduced, x); + WIPE_BUFFER(x); +} + +// r = (a * b) + c +void crypto_eddsa_mul_add(u8 r[32], + const u8 a[32], const u8 b[32], const u8 c[32]) +{ + u32 A[8]; load32_le_buf(A, a, 8); + u32 B[8]; load32_le_buf(B, b, 8); + u32 p[16]; load32_le_buf(p, c, 8); ZERO(p + 8, 8); + multiply(p, A, B); + mod_l(r, p); + WIPE_BUFFER(p); + WIPE_BUFFER(A); + WIPE_BUFFER(B); +} + +/////////////// +/// Ed25519 /// +/////////////// + +// Point (group element, ge) in a twisted Edwards curve, +// in extended projective coordinates. +// ge : x = X/Z, y = Y/Z, T = XY/Z +// ge_cached : Yp = X+Y, Ym = X-Y, T2 = T*D2 +// ge_precomp: Z = 1 +typedef struct { fe X; fe Y; fe Z; fe T; } ge; +typedef struct { fe Yp; fe Ym; fe Z; fe T2; } ge_cached; +typedef struct { fe Yp; fe Ym; fe T2; } ge_precomp; + +static void ge_zero(ge *p) +{ + fe_0(p->X); + fe_1(p->Y); + fe_1(p->Z); + fe_0(p->T); +} + +static void ge_tobytes(u8 s[32], const ge *h) +{ + fe recip, x, y; + fe_invert(recip, h->Z); + fe_mul(x, h->X, recip); + fe_mul(y, h->Y, recip); + fe_tobytes(s, y); + s[31] ^= fe_isodd(x) << 7; + + WIPE_BUFFER(recip); + WIPE_BUFFER(x); + WIPE_BUFFER(y); +} + +// h = -s, where s is a point encoded in 32 bytes +// +// Variable time! Inputs must not be secret! +// => Use only to *check* signatures. +// +// From the specifications: +// The encoding of s contains y and the sign of x +// x = sqrt((y^2 - 1) / (d*y^2 + 1)) +// In extended coordinates: +// X = x, Y = y, Z = 1, T = x*y +// +// Note that num * den is a square iff num / den is a square +// If num * den is not a square, the point was not on the curve. +// From the above: +// Let num = y^2 - 1 +// Let den = d*y^2 + 1 +// x = sqrt((y^2 - 1) / (d*y^2 + 1)) +// x = sqrt(num / den) +// x = sqrt(num^2 / (num * den)) +// x = num * sqrt(1 / (num * den)) +// +// Therefore, we can just compute: +// num = y^2 - 1 +// den = d*y^2 + 1 +// isr = invsqrt(num * den) // abort if not square +// x = num * isr +// Finally, negate x if its sign is not as specified. +static int ge_frombytes_neg_vartime(ge *h, const u8 s[32]) +{ + fe_frombytes(h->Y, s); + fe_1(h->Z); + fe_sq (h->T, h->Y); // t = y^2 + fe_mul(h->X, h->T, d ); // x = d*y^2 + fe_sub(h->T, h->T, h->Z); // t = y^2 - 1 + fe_add(h->X, h->X, h->Z); // x = d*y^2 + 1 + fe_mul(h->X, h->T, h->X); // x = (y^2 - 1) * (d*y^2 + 1) + int is_square = invsqrt(h->X, h->X); + if (!is_square) { + return -1; // Not on the curve, abort + } + fe_mul(h->X, h->T, h->X); // x = sqrt((y^2 - 1) / (d*y^2 + 1)) + if (fe_isodd(h->X) == (s[31] >> 7)) { + fe_neg(h->X, h->X); + } + fe_mul(h->T, h->X, h->Y); + return 0; +} + +static void ge_cache(ge_cached *c, const ge *p) +{ + fe_add (c->Yp, p->Y, p->X); + fe_sub (c->Ym, p->Y, p->X); + fe_copy(c->Z , p->Z ); + fe_mul (c->T2, p->T, D2 ); +} + +// Internal buffers are not wiped! Inputs must not be secret! +// => Use only to *check* signatures. +static void ge_add(ge *s, const ge *p, const ge_cached *q) +{ + fe a, b; + fe_add(a , p->Y, p->X ); + fe_sub(b , p->Y, p->X ); + fe_mul(a , a , q->Yp); + fe_mul(b , b , q->Ym); + fe_add(s->Y, a , b ); + fe_sub(s->X, a , b ); + + fe_add(s->Z, p->Z, p->Z ); + fe_mul(s->Z, s->Z, q->Z ); + fe_mul(s->T, p->T, q->T2); + fe_add(a , s->Z, s->T ); + fe_sub(b , s->Z, s->T ); + + fe_mul(s->T, s->X, s->Y); + fe_mul(s->X, s->X, b ); + fe_mul(s->Y, s->Y, a ); + fe_mul(s->Z, a , b ); +} + +// Internal buffers are not wiped! Inputs must not be secret! +// => Use only to *check* signatures. +static void ge_sub(ge *s, const ge *p, const ge_cached *q) +{ + ge_cached neg; + fe_copy(neg.Ym, q->Yp); + fe_copy(neg.Yp, q->Ym); + fe_copy(neg.Z , q->Z ); + fe_neg (neg.T2, q->T2); + ge_add(s, p, &neg); +} + +static void ge_madd(ge *s, const ge *p, const ge_precomp *q, fe a, fe b) +{ + fe_add(a , p->Y, p->X ); + fe_sub(b , p->Y, p->X ); + fe_mul(a , a , q->Yp); + fe_mul(b , b , q->Ym); + fe_add(s->Y, a , b ); + fe_sub(s->X, a , b ); + + fe_add(s->Z, p->Z, p->Z ); + fe_mul(s->T, p->T, q->T2); + fe_add(a , s->Z, s->T ); + fe_sub(b , s->Z, s->T ); + + fe_mul(s->T, s->X, s->Y); + fe_mul(s->X, s->X, b ); + fe_mul(s->Y, s->Y, a ); + fe_mul(s->Z, a , b ); +} + +// Internal buffers are not wiped! Inputs must not be secret! +// => Use only to *check* signatures. +static void ge_msub(ge *s, const ge *p, const ge_precomp *q, fe a, fe b) +{ + ge_precomp neg; + fe_copy(neg.Ym, q->Yp); + fe_copy(neg.Yp, q->Ym); + fe_neg (neg.T2, q->T2); + ge_madd(s, p, &neg, a, b); +} + +static void ge_double(ge *s, const ge *p, ge *q) +{ + fe_sq (q->X, p->X); + fe_sq (q->Y, p->Y); + fe_sq (q->Z, p->Z); // qZ = pZ^2 + fe_mul_small(q->Z, q->Z, 2); // qZ = pZ^2 * 2 + fe_add(q->T, p->X, p->Y); + fe_sq (s->T, q->T); + fe_add(q->T, q->Y, q->X); + fe_sub(q->Y, q->Y, q->X); + fe_sub(q->X, s->T, q->T); + fe_sub(q->Z, q->Z, q->Y); + + fe_mul(s->X, q->X , q->Z); + fe_mul(s->Y, q->T , q->Y); + fe_mul(s->Z, q->Y , q->Z); + fe_mul(s->T, q->X , q->T); +} + +// 5-bit signed window in cached format (Niels coordinates, Z=1) +static const ge_precomp b_window[8] = { + {{25967493,-14356035,29566456,3660896,-12694345, + 4014787,27544626,-11754271,-6079156,2047605,}, + {-12545711,934262,-2722910,3049990,-727428, + 9406986,12720692,5043384,19500929,-15469378,}, + {-8738181,4489570,9688441,-14785194,10184609, + -12363380,29287919,11864899,-24514362,-4438546,},}, + {{15636291,-9688557,24204773,-7912398,616977, + -16685262,27787600,-14772189,28944400,-1550024,}, + {16568933,4717097,-11556148,-1102322,15682896, + -11807043,16354577,-11775962,7689662,11199574,}, + {30464156,-5976125,-11779434,-15670865,23220365, + 15915852,7512774,10017326,-17749093,-9920357,},}, + {{10861363,11473154,27284546,1981175,-30064349, + 12577861,32867885,14515107,-15438304,10819380,}, + {4708026,6336745,20377586,9066809,-11272109, + 6594696,-25653668,12483688,-12668491,5581306,}, + {19563160,16186464,-29386857,4097519,10237984, + -4348115,28542350,13850243,-23678021,-15815942,},}, + {{5153746,9909285,1723747,-2777874,30523605, + 5516873,19480852,5230134,-23952439,-15175766,}, + {-30269007,-3463509,7665486,10083793,28475525, + 1649722,20654025,16520125,30598449,7715701,}, + {28881845,14381568,9657904,3680757,-20181635, + 7843316,-31400660,1370708,29794553,-1409300,},}, + {{-22518993,-6692182,14201702,-8745502,-23510406, + 8844726,18474211,-1361450,-13062696,13821877,}, + {-6455177,-7839871,3374702,-4740862,-27098617, + -10571707,31655028,-7212327,18853322,-14220951,}, + {4566830,-12963868,-28974889,-12240689,-7602672, + -2830569,-8514358,-10431137,2207753,-3209784,},}, + {{-25154831,-4185821,29681144,7868801,-6854661, + -9423865,-12437364,-663000,-31111463,-16132436,}, + {25576264,-2703214,7349804,-11814844,16472782, + 9300885,3844789,15725684,171356,6466918,}, + {23103977,13316479,9739013,-16149481,817875, + -15038942,8965339,-14088058,-30714912,16193877,},}, + {{-33521811,3180713,-2394130,14003687,-16903474, + -16270840,17238398,4729455,-18074513,9256800,}, + {-25182317,-4174131,32336398,5036987,-21236817, + 11360617,22616405,9761698,-19827198,630305,}, + {-13720693,2639453,-24237460,-7406481,9494427, + -5774029,-6554551,-15960994,-2449256,-14291300,},}, + {{-3151181,-5046075,9282714,6866145,-31907062, + -863023,-18940575,15033784,25105118,-7894876,}, + {-24326370,15950226,-31801215,-14592823,-11662737, + -5090925,1573892,-2625887,2198790,-15804619,}, + {-3099351,10324967,-2241613,7453183,-5446979, + -2735503,-13812022,-16236442,-32461234,-12290683,},}, +}; + +// Incremental sliding windows (left to right) +// Based on Roberto Maria Avanzi[2005] +typedef struct { + i16 next_index; // position of the next signed digit + i8 next_digit; // next signed digit (odd number below 2^window_width) + u8 next_check; // point at which we must check for a new window +} slide_ctx; + +static void slide_init(slide_ctx *ctx, const u8 scalar[32]) +{ + // scalar is guaranteed to be below L, either because we checked (s), + // or because we reduced it modulo L (h_ram). L is under 2^253, so + // so bits 253 to 255 are guaranteed to be zero. No need to test them. + // + // Note however that L is very close to 2^252, so bit 252 is almost + // always zero. If we were to start at bit 251, the tests wouldn't + // catch the off-by-one error (constructing one that does would be + // prohibitively expensive). + // + // We should still check bit 252, though. + int i = 252; + while (i > 0 && scalar_bit(scalar, i) == 0) { + i--; + } + ctx->next_check = (u8)(i + 1); + ctx->next_index = -1; + ctx->next_digit = -1; +} + +static int slide_step(slide_ctx *ctx, int width, int i, const u8 scalar[32]) +{ + if (i == ctx->next_check) { + if (scalar_bit(scalar, i) == scalar_bit(scalar, i - 1)) { + ctx->next_check--; + } else { + // compute digit of next window + int w = MIN(width, i + 1); + int v = -(scalar_bit(scalar, i) << (w-1)); + FOR_T (int, j, 0, w-1) { + v += scalar_bit(scalar, i-(w-1)+j) << j; + } + v += scalar_bit(scalar, i-w); + int lsb = v & (~v + 1); // smallest bit of v + int s = // log2(lsb) + (((lsb & 0xAA) != 0) << 0) | + (((lsb & 0xCC) != 0) << 1) | + (((lsb & 0xF0) != 0) << 2); + ctx->next_index = (i16)(i-(w-1)+s); + ctx->next_digit = (i8) (v >> s ); + ctx->next_check -= (u8) w; + } + } + return i == ctx->next_index ? ctx->next_digit: 0; +} + +#define P_W_WIDTH 3 // Affects the size of the stack +#define B_W_WIDTH 5 // Affects the size of the binary +#define P_W_SIZE (1<<(P_W_WIDTH-2)) + +int crypto_eddsa_check_equation(const u8 signature[64], const u8 public_key[32], + const u8 h[32]) +{ + ge minus_A; // -public_key + ge minus_R; // -first_half_of_signature + const u8 *s = signature + 32; + + // Check that A and R are on the curve + // Check that 0 <= S < L (prevents malleability) + // *Allow* non-cannonical encoding for A and R + { + u32 s32[8]; + load32_le_buf(s32, s, 8); + if (ge_frombytes_neg_vartime(&minus_A, public_key) || + ge_frombytes_neg_vartime(&minus_R, signature) || + is_above_l(s32)) { + return -1; + } + } + + // look-up table for minus_A + ge_cached lutA[P_W_SIZE]; + { + ge minus_A2, tmp; + ge_double(&minus_A2, &minus_A, &tmp); + ge_cache(&lutA[0], &minus_A); + FOR (i, 1, P_W_SIZE) { + ge_add(&tmp, &minus_A2, &lutA[i-1]); + ge_cache(&lutA[i], &tmp); + } + } + + // sum = [s]B - [h]A + // Merged double and add ladder, fused with sliding + slide_ctx h_slide; slide_init(&h_slide, h); + slide_ctx s_slide; slide_init(&s_slide, s); + int i = MAX(h_slide.next_check, s_slide.next_check); + ge *sum = &minus_A; // reuse minus_A for the sum + ge_zero(sum); + while (i >= 0) { + ge tmp; + ge_double(sum, sum, &tmp); + int h_digit = slide_step(&h_slide, P_W_WIDTH, i, h); + int s_digit = slide_step(&s_slide, B_W_WIDTH, i, s); + if (h_digit > 0) { ge_add(sum, sum, &lutA[ h_digit / 2]); } + if (h_digit < 0) { ge_sub(sum, sum, &lutA[-h_digit / 2]); } + fe t1, t2; + if (s_digit > 0) { ge_madd(sum, sum, b_window + s_digit/2, t1, t2); } + if (s_digit < 0) { ge_msub(sum, sum, b_window + -s_digit/2, t1, t2); } + i--; + } + + // Compare [8](sum-R) and the zero point + // The multiplication by 8 eliminates any low-order component + // and ensures consistency with batched verification. + ge_cached cached; + u8 check[32]; + static const u8 zero_point[32] = {1}; // Point of order 1 + ge_cache(&cached, &minus_R); + ge_add(sum, sum, &cached); + ge_double(sum, sum, &minus_R); // reuse minus_R as temporary + ge_double(sum, sum, &minus_R); // reuse minus_R as temporary + ge_double(sum, sum, &minus_R); // reuse minus_R as temporary + ge_tobytes(check, sum); + return crypto_verify32(check, zero_point); +} + +// 5-bit signed comb in cached format (Niels coordinates, Z=1) +static const ge_precomp b_comb_low[8] = { + {{-6816601,-2324159,-22559413,124364,18015490, + 8373481,19993724,1979872,-18549925,9085059,}, + {10306321,403248,14839893,9633706,8463310, + -8354981,-14305673,14668847,26301366,2818560,}, + {-22701500,-3210264,-13831292,-2927732,-16326337, + -14016360,12940910,177905,12165515,-2397893,},}, + {{-12282262,-7022066,9920413,-3064358,-32147467, + 2927790,22392436,-14852487,2719975,16402117,}, + {-7236961,-4729776,2685954,-6525055,-24242706, + -15940211,-6238521,14082855,10047669,12228189,}, + {-30495588,-12893761,-11161261,3539405,-11502464, + 16491580,-27286798,-15030530,-7272871,-15934455,},}, + {{17650926,582297,-860412,-187745,-12072900, + -10683391,-20352381,15557840,-31072141,-5019061,}, + {-6283632,-2259834,-4674247,-4598977,-4089240, + 12435688,-31278303,1060251,6256175,10480726,}, + {-13871026,2026300,-21928428,-2741605,-2406664, + -8034988,7355518,15733500,-23379862,7489131,},}, + {{6883359,695140,23196907,9644202,-33430614, + 11354760,-20134606,6388313,-8263585,-8491918,}, + {-7716174,-13605463,-13646110,14757414,-19430591, + -14967316,10359532,-11059670,-21935259,12082603,}, + {-11253345,-15943946,10046784,5414629,24840771, + 8086951,-6694742,9868723,15842692,-16224787,},}, + {{9639399,11810955,-24007778,-9320054,3912937, + -9856959,996125,-8727907,-8919186,-14097242,}, + {7248867,14468564,25228636,-8795035,14346339, + 8224790,6388427,-7181107,6468218,-8720783,}, + {15513115,15439095,7342322,-10157390,18005294, + -7265713,2186239,4884640,10826567,7135781,},}, + {{-14204238,5297536,-5862318,-6004934,28095835, + 4236101,-14203318,1958636,-16816875,3837147,}, + {-5511166,-13176782,-29588215,12339465,15325758, + -15945770,-8813185,11075932,-19608050,-3776283,}, + {11728032,9603156,-4637821,-5304487,-7827751, + 2724948,31236191,-16760175,-7268616,14799772,},}, + {{-28842672,4840636,-12047946,-9101456,-1445464, + 381905,-30977094,-16523389,1290540,12798615,}, + {27246947,-10320914,14792098,-14518944,5302070, + -8746152,-3403974,-4149637,-27061213,10749585,}, + {25572375,-6270368,-15353037,16037944,1146292, + 32198,23487090,9585613,24714571,-1418265,},}, + {{19844825,282124,-17583147,11004019,-32004269, + -2716035,6105106,-1711007,-21010044,14338445,}, + {8027505,8191102,-18504907,-12335737,25173494, + -5923905,15446145,7483684,-30440441,10009108,}, + {-14134701,-4174411,10246585,-14677495,33553567, + -14012935,23366126,15080531,-7969992,7663473,},}, +}; + +static const ge_precomp b_comb_high[8] = { + {{33055887,-4431773,-521787,6654165,951411, + -6266464,-5158124,6995613,-5397442,-6985227,}, + {4014062,6967095,-11977872,3960002,8001989, + 5130302,-2154812,-1899602,-31954493,-16173976,}, + {16271757,-9212948,23792794,731486,-25808309, + -3546396,6964344,-4767590,10976593,10050757,},}, + {{2533007,-4288439,-24467768,-12387405,-13450051, + 14542280,12876301,13893535,15067764,8594792,}, + {20073501,-11623621,3165391,-13119866,13188608, + -11540496,-10751437,-13482671,29588810,2197295,}, + {-1084082,11831693,6031797,14062724,14748428, + -8159962,-20721760,11742548,31368706,13161200,},}, + {{2050412,-6457589,15321215,5273360,25484180, + 124590,-18187548,-7097255,-6691621,-14604792,}, + {9938196,2162889,-6158074,-1711248,4278932, + -2598531,-22865792,-7168500,-24323168,11746309,}, + {-22691768,-14268164,5965485,9383325,20443693, + 5854192,28250679,-1381811,-10837134,13717818,},}, + {{-8495530,16382250,9548884,-4971523,-4491811, + -3902147,6182256,-12832479,26628081,10395408,}, + {27329048,-15853735,7715764,8717446,-9215518, + -14633480,28982250,-5668414,4227628,242148,}, + {-13279943,-7986904,-7100016,8764468,-27276630, + 3096719,29678419,-9141299,3906709,11265498,},}, + {{11918285,15686328,-17757323,-11217300,-27548967, + 4853165,-27168827,6807359,6871949,-1075745,}, + {-29002610,13984323,-27111812,-2713442,28107359, + -13266203,6155126,15104658,3538727,-7513788,}, + {14103158,11233913,-33165269,9279850,31014152, + 4335090,-1827936,4590951,13960841,12787712,},}, + {{1469134,-16738009,33411928,13942824,8092558, + -8778224,-11165065,1437842,22521552,-2792954,}, + {31352705,-4807352,-25327300,3962447,12541566, + -9399651,-27425693,7964818,-23829869,5541287,}, + {-25732021,-6864887,23848984,3039395,-9147354, + 6022816,-27421653,10590137,25309915,-1584678,},}, + {{-22951376,5048948,31139401,-190316,-19542447, + -626310,-17486305,-16511925,-18851313,-12985140,}, + {-9684890,14681754,30487568,7717771,-10829709, + 9630497,30290549,-10531496,-27798994,-13812825,}, + {5827835,16097107,-24501327,12094619,7413972, + 11447087,28057551,-1793987,-14056981,4359312,},}, + {{26323183,2342588,-21887793,-1623758,-6062284, + 2107090,-28724907,9036464,-19618351,-13055189,}, + {-29697200,14829398,-4596333,14220089,-30022969, + 2955645,12094100,-13693652,-5941445,7047569,}, + {-3201977,14413268,-12058324,-16417589,-9035655, + -7224648,9258160,1399236,30397584,-5684634,},}, +}; + +static void lookup_add(ge *p, ge_precomp *tmp_c, fe tmp_a, fe tmp_b, + const ge_precomp comb[8], const u8 scalar[32], int i) +{ + u8 teeth = (u8)((scalar_bit(scalar, i) ) + + (scalar_bit(scalar, i + 32) << 1) + + (scalar_bit(scalar, i + 64) << 2) + + (scalar_bit(scalar, i + 96) << 3)); + u8 high = teeth >> 3; + u8 index = (teeth ^ (high - 1)) & 7; + FOR (j, 0, 8) { + i32 select = 1 & (((j ^ index) - 1) >> 8); + fe_ccopy(tmp_c->Yp, comb[j].Yp, select); + fe_ccopy(tmp_c->Ym, comb[j].Ym, select); + fe_ccopy(tmp_c->T2, comb[j].T2, select); + } + fe_neg(tmp_a, tmp_c->T2); + fe_cswap(tmp_c->T2, tmp_a , high ^ 1); + fe_cswap(tmp_c->Yp, tmp_c->Ym, high ^ 1); + ge_madd(p, p, tmp_c, tmp_a, tmp_b); +} + +// p = [scalar]B, where B is the base point +static void ge_scalarmult_base(ge *p, const u8 scalar[32]) +{ + // twin 4-bits signed combs, from Mike Hamburg's + // Fast and compact elliptic-curve cryptography (2012) + // 1 / 2 modulo L + static const u8 half_mod_L[32] = { + 247,233,122,46,141,49,9,44,107,206,123,81,239,124,111,10, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8, + }; + // (2^256 - 1) / 2 modulo L + static const u8 half_ones[32] = { + 142,74,204,70,186,24,118,107,184,231,190,57,250,173,119,99, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7, + }; + + // All bits set form: 1 means 1, 0 means -1 + u8 s_scalar[32]; + crypto_eddsa_mul_add(s_scalar, scalar, half_mod_L, half_ones); + + // Double and add ladder + fe tmp_a, tmp_b; // temporaries for addition + ge_precomp tmp_c; // temporary for comb lookup + ge tmp_d; // temporary for doubling + fe_1(tmp_c.Yp); + fe_1(tmp_c.Ym); + fe_0(tmp_c.T2); + + // Save a double on the first iteration + ge_zero(p); + lookup_add(p, &tmp_c, tmp_a, tmp_b, b_comb_low , s_scalar, 31); + lookup_add(p, &tmp_c, tmp_a, tmp_b, b_comb_high, s_scalar, 31+128); + // Regular double & add for the rest + for (int i = 30; i >= 0; i--) { + ge_double(p, p, &tmp_d); + lookup_add(p, &tmp_c, tmp_a, tmp_b, b_comb_low , s_scalar, i); + lookup_add(p, &tmp_c, tmp_a, tmp_b, b_comb_high, s_scalar, i+128); + } + // Note: we could save one addition at the end if we assumed the + // scalar fit in 252 bits. Which it does in practice if it is + // selected at random. However, non-random, non-hashed scalars + // *can* overflow 252 bits in practice. Better account for that + // than leaving that kind of subtle corner case. + + WIPE_BUFFER(tmp_a); WIPE_CTX(&tmp_d); + WIPE_BUFFER(tmp_b); WIPE_CTX(&tmp_c); + WIPE_BUFFER(s_scalar); +} + +void crypto_eddsa_scalarbase(u8 point[32], const u8 scalar[32]) +{ + ge P; + ge_scalarmult_base(&P, scalar); + ge_tobytes(point, &P); + WIPE_CTX(&P); +} + +void crypto_eddsa_key_pair(u8 secret_key[64], u8 public_key[32], u8 seed[32]) +{ + // To allow overlaps, observable writes happen in this order: + // 1. seed + // 2. secret_key + // 3. public_key + u8 a[64]; + COPY(a, seed, 32); + crypto_wipe(seed, 32); + COPY(secret_key, a, 32); + crypto_blake2b(a, 64, a, 32); + crypto_eddsa_trim_scalar(a, a); + crypto_eddsa_scalarbase(secret_key + 32, a); + COPY(public_key, secret_key + 32, 32); + WIPE_BUFFER(a); +} + +static void hash_reduce(u8 h[32], + const u8 *a, size_t a_size, + const u8 *b, size_t b_size, + const u8 *c, size_t c_size) +{ + u8 hash[64]; + crypto_blake2b_ctx ctx; + crypto_blake2b_init (&ctx, 64); + crypto_blake2b_update(&ctx, a, a_size); + crypto_blake2b_update(&ctx, b, b_size); + crypto_blake2b_update(&ctx, c, c_size); + crypto_blake2b_final (&ctx, hash); + crypto_eddsa_reduce(h, hash); +} + +// Digital signature of a message with from a secret key. +// +// The secret key comprises two parts: +// - The seed that generates the key (secret_key[ 0..31]) +// - The public key (secret_key[32..63]) +// +// The seed and the public key are bundled together to make sure users +// don't use mismatched seeds and public keys, which would instantly +// leak the secret scalar and allow forgeries (allowing this to happen +// has resulted in critical vulnerabilities in the wild). +// +// The seed is hashed to derive the secret scalar and a secret prefix. +// The sole purpose of the prefix is to generate a secret random nonce. +// The properties of that nonce must be as follows: +// - Unique: we need a different one for each message. +// - Secret: third parties must not be able to predict it. +// - Random: any detectable bias would break all security. +// +// There are two ways to achieve these properties. The obvious one is +// to simply generate a random number. Here that would be a parameter +// (Monocypher doesn't have an RNG). It works, but then users may reuse +// the nonce by accident, which _also_ leaks the secret scalar and +// allows forgeries. This has happened in the wild too. +// +// This is no good, so instead we generate that nonce deterministically +// by reducing modulo L a hash of the secret prefix and the message. +// The secret prefix makes the nonce unpredictable, the message makes it +// unique, and the hash/reduce removes all bias. +// +// The cost of that safety is hashing the message twice. If that cost +// is unacceptable, there are two alternatives: +// +// - Signing a hash of the message instead of the message itself. This +// is fine as long as the hash is collision resistant. It is not +// compatible with existing "pure" signatures, but at least it's safe. +// +// - Using a random nonce. Please exercise **EXTREME CAUTION** if you +// ever do that. It is absolutely **critical** that the nonce is +// really an unbiased random number between 0 and L-1, never reused, +// and wiped immediately. +// +// To lower the likelihood of complete catastrophe if the RNG is +// either flawed or misused, you can hash the RNG output together with +// the secret prefix and the beginning of the message, and use the +// reduction of that hash instead of the RNG output itself. It's not +// foolproof (you'd need to hash the whole message) but it helps. +// +// Signing a message involves the following operations: +// +// scalar, prefix = HASH(secret_key) +// r = HASH(prefix || message) % L +// R = [r]B +// h = HASH(R || public_key || message) % L +// S = ((h * a) + r) % L +// signature = R || S +void crypto_eddsa_sign(u8 signature [64], const u8 secret_key[64], + const u8 *message, size_t message_size) +{ + u8 a[64]; // secret scalar and prefix + u8 r[32]; // secret deterministic "random" nonce + u8 h[32]; // publically verifiable hash of the message (not wiped) + u8 R[32]; // first half of the signature (allows overlapping inputs) + + crypto_blake2b(a, 64, secret_key, 32); + crypto_eddsa_trim_scalar(a, a); + hash_reduce(r, a + 32, 32, message, message_size, 0, 0); + crypto_eddsa_scalarbase(R, r); + hash_reduce(h, R, 32, secret_key + 32, 32, message, message_size); + COPY(signature, R, 32); + crypto_eddsa_mul_add(signature + 32, h, a, r); + + WIPE_BUFFER(a); + WIPE_BUFFER(r); +} + +// To check the signature R, S of the message M with the public key A, +// there are 3 steps: +// +// compute h = HASH(R || A || message) % L +// check that A is on the curve. +// check that R == [s]B - [h]A +// +// The last two steps are done in crypto_eddsa_check_equation() +int crypto_eddsa_check(const u8 signature[64], const u8 public_key[32], + const u8 *message, size_t message_size) +{ + u8 h[32]; + hash_reduce(h, signature, 32, public_key, 32, message, message_size); + return crypto_eddsa_check_equation(signature, public_key, h); +} + +///////////////////////// +/// EdDSA <--> X25519 /// +///////////////////////// +void crypto_eddsa_to_x25519(u8 x25519[32], const u8 eddsa[32]) +{ + // (u, v) = ((1+y)/(1-y), sqrt(-486664)*u/x) + // Only converting y to u, the sign of x is ignored. + fe t1, t2; + fe_frombytes(t2, eddsa); + fe_add(t1, fe_one, t2); + fe_sub(t2, fe_one, t2); + fe_invert(t2, t2); + fe_mul(t1, t1, t2); + fe_tobytes(x25519, t1); + WIPE_BUFFER(t1); + WIPE_BUFFER(t2); +} + +void crypto_x25519_to_eddsa(u8 eddsa[32], const u8 x25519[32]) +{ + // (x, y) = (sqrt(-486664)*u/v, (u-1)/(u+1)) + // Only converting u to y, x is assumed positive. + fe t1, t2; + fe_frombytes(t2, x25519); + fe_sub(t1, t2, fe_one); + fe_add(t2, t2, fe_one); + fe_invert(t2, t2); + fe_mul(t1, t1, t2); + fe_tobytes(eddsa, t1); + WIPE_BUFFER(t1); + WIPE_BUFFER(t2); +} + +///////////////////////////////////////////// +/// Dirty ephemeral public key generation /// +///////////////////////////////////////////// + +// Those functions generates a public key, *without* clearing the +// cofactor. Sending that key over the network leaks 3 bits of the +// private key. Use only to generate ephemeral keys that will be hidden +// with crypto_curve_to_hidden(). +// +// The public key is otherwise compatible with crypto_x25519(), which +// properly clears the cofactor. +// +// Note that the distribution of the resulting public keys is almost +// uniform. Flipping the sign of the v coordinate (not provided by this +// function), covers the entire key space almost perfectly, where +// "almost" means a 2^-128 bias (undetectable). This uniformity is +// needed to ensure the proper randomness of the resulting +// representatives (once we apply crypto_curve_to_hidden()). +// +// Recall that Curve25519 has order C = 2^255 + e, with e < 2^128 (not +// to be confused with the prime order of the main subgroup, L, which is +// 8 times less than that). +// +// Generating all points would require us to multiply a point of order C +// (the base point plus any point of order 8) by all scalars from 0 to +// C-1. Clamping limits us to scalars between 2^254 and 2^255 - 1. But +// by negating the resulting point at random, we also cover scalars from +// -2^255 + 1 to -2^254 (which modulo C is congruent to e+1 to 2^254 + e). +// +// In practice: +// - Scalars from 0 to e + 1 are never generated +// - Scalars from 2^255 to 2^255 + e are never generated +// - Scalars from 2^254 + 1 to 2^254 + e are generated twice +// +// Since e < 2^128, detecting this bias requires observing over 2^100 +// representatives from a given source (this will never happen), *and* +// recovering enough of the private key to determine that they do, or do +// not, belong to the biased set (this practically requires solving +// discrete logarithm, which is conjecturally intractable). +// +// In practice, this means the bias is impossible to detect. + +// s + (x*L) % 8*L +// Guaranteed to fit in 256 bits iff s fits in 255 bits. +// L < 2^253 +// x%8 < 2^3 +// L * (x%8) < 2^255 +// s < 2^255 +// s + L * (x%8) < 2^256 +static void add_xl(u8 s[32], u8 x) +{ + u64 mod8 = x & 7; + u64 carry = 0; + FOR (i , 0, 8) { + carry = carry + load32_le(s + 4*i) + L[i] * mod8; + store32_le(s + 4*i, (u32)carry); + carry >>= 32; + } +} + +// "Small" dirty ephemeral key. +// Use if you need to shrink the size of the binary, and can afford to +// slow down by a factor of two (compared to the fast version) +// +// This version works by decoupling the cofactor from the main factor. +// +// - The trimmed scalar determines the main factor +// - The clamped bits of the scalar determine the cofactor. +// +// Cofactor and main factor are combined into a single scalar, which is +// then multiplied by a point of order 8*L (unlike the base point, which +// has prime order). That "dirty" base point is the addition of the +// regular base point (9), and a point of order 8. +void crypto_x25519_dirty_small(u8 public_key[32], const u8 secret_key[32]) +{ + // Base point of order 8*L + // Raw scalar multiplication with it does not clear the cofactor, + // and the resulting public key will reveal 3 bits of the scalar. + // + // The low order component of this base point has been chosen + // to yield the same results as crypto_x25519_dirty_fast(). + static const u8 dirty_base_point[32] = { + 0xd8, 0x86, 0x1a, 0xa2, 0x78, 0x7a, 0xd9, 0x26, + 0x8b, 0x74, 0x74, 0xb6, 0x82, 0xe3, 0xbe, 0xc3, + 0xce, 0x36, 0x9a, 0x1e, 0x5e, 0x31, 0x47, 0xa2, + 0x6d, 0x37, 0x7c, 0xfd, 0x20, 0xb5, 0xdf, 0x75, + }; + // separate the main factor & the cofactor of the scalar + u8 scalar[32]; + crypto_eddsa_trim_scalar(scalar, secret_key); + + // Separate the main factor and the cofactor + // + // The scalar is trimmed, so its cofactor is cleared. The three + // least significant bits however still have a main factor. We must + // remove it for X25519 compatibility. + // + // cofactor = lsb * L (modulo 8*L) + // combined = scalar + cofactor (modulo 8*L) + add_xl(scalar, secret_key[0]); + scalarmult(public_key, scalar, dirty_base_point, 256); + WIPE_BUFFER(scalar); +} + +// Select low order point +// We're computing the [cofactor]lop scalar multiplication, where: +// +// cofactor = tweak & 7. +// lop = (lop_x, lop_y) +// lop_x = sqrt((sqrt(d + 1) + 1) / d) +// lop_y = -lop_x * sqrtm1 +// +// The low order point has order 8. There are 4 such points. We've +// chosen the one whose both coordinates are positive (below p/2). +// The 8 low order points are as follows: +// +// [0]lop = ( 0 , 1 ) +// [1]lop = ( lop_x , lop_y) +// [2]lop = ( sqrt(-1), -0 ) +// [3]lop = ( lop_x , -lop_y) +// [4]lop = (-0 , -1 ) +// [5]lop = (-lop_x , -lop_y) +// [6]lop = (-sqrt(-1), 0 ) +// [7]lop = (-lop_x , lop_y) +// +// The x coordinate is either 0, sqrt(-1), lop_x, or their opposite. +// The y coordinate is either 0, -1 , lop_y, or their opposite. +// The pattern for both is the same, except for a rotation of 2 (modulo 8) +// +// This helper function captures the pattern, and we can use it thus: +// +// select_lop(x, lop_x, sqrtm1, cofactor); +// select_lop(y, lop_y, fe_one, cofactor + 2); +// +// This is faster than an actual scalar multiplication, +// and requires less code than naive constant time look up. +static void select_lop(fe out, const fe x, const fe k, u8 cofactor) +{ + fe tmp; + fe_0(out); + fe_ccopy(out, k , (cofactor >> 1) & 1); // bit 1 + fe_ccopy(out, x , (cofactor >> 0) & 1); // bit 0 + fe_neg (tmp, out); + fe_ccopy(out, tmp, (cofactor >> 2) & 1); // bit 2 + WIPE_BUFFER(tmp); +} + +// "Fast" dirty ephemeral key +// We use this one by default. +// +// This version works by performing a regular scalar multiplication, +// then add a low order point. The scalar multiplication is done in +// Edwards space for more speed (*2 compared to the "small" version). +// The cost is a bigger binary for programs that don't also sign messages. +void crypto_x25519_dirty_fast(u8 public_key[32], const u8 secret_key[32]) +{ + // Compute clean scalar multiplication + u8 scalar[32]; + ge pk; + crypto_eddsa_trim_scalar(scalar, secret_key); + ge_scalarmult_base(&pk, scalar); + + // Compute low order point + fe t1, t2; + select_lop(t1, lop_x, sqrtm1, secret_key[0]); + select_lop(t2, lop_y, fe_one, secret_key[0] + 2); + ge_precomp low_order_point; + fe_add(low_order_point.Yp, t2, t1); + fe_sub(low_order_point.Ym, t2, t1); + fe_mul(low_order_point.T2, t2, t1); + fe_mul(low_order_point.T2, low_order_point.T2, D2); + + // Add low order point to the public key + ge_madd(&pk, &pk, &low_order_point, t1, t2); + + // Convert to Montgomery u coordinate (we ignore the sign) + fe_add(t1, pk.Z, pk.Y); + fe_sub(t2, pk.Z, pk.Y); + fe_invert(t2, t2); + fe_mul(t1, t1, t2); + + fe_tobytes(public_key, t1); + + WIPE_BUFFER(t1); WIPE_CTX(&pk); + WIPE_BUFFER(t2); WIPE_CTX(&low_order_point); + WIPE_BUFFER(scalar); +} + +/////////////////// +/// Elligator 2 /// +/////////////////// +static const fe A = {486662}; + +// Elligator direct map +// +// Computes the point corresponding to a representative, encoded in 32 +// bytes (little Endian). Since positive representatives fits in 254 +// bits, The two most significant bits are ignored. +// +// From the paper: +// w = -A / (fe(1) + non_square * r^2) +// e = chi(w^3 + A*w^2 + w) +// u = e*w - (fe(1)-e)*(A//2) +// v = -e * sqrt(u^3 + A*u^2 + u) +// +// We ignore v because we don't need it for X25519 (the Montgomery +// ladder only uses u). +// +// Note that e is either 0, 1 or -1 +// if e = 0 u = 0 and v = 0 +// if e = 1 u = w +// if e = -1 u = -w - A = w * non_square * r^2 +// +// Let r1 = non_square * r^2 +// Let r2 = 1 + r1 +// Note that r2 cannot be zero, -1/non_square is not a square. +// We can (tediously) verify that: +// w^3 + A*w^2 + w = (A^2*r1 - r2^2) * A / r2^3 +// Therefore: +// chi(w^3 + A*w^2 + w) = chi((A^2*r1 - r2^2) * (A / r2^3)) +// chi(w^3 + A*w^2 + w) = chi((A^2*r1 - r2^2) * (A / r2^3)) * 1 +// chi(w^3 + A*w^2 + w) = chi((A^2*r1 - r2^2) * (A / r2^3)) * chi(r2^6) +// chi(w^3 + A*w^2 + w) = chi((A^2*r1 - r2^2) * (A / r2^3) * r2^6) +// chi(w^3 + A*w^2 + w) = chi((A^2*r1 - r2^2) * A * r2^3) +// Corollary: +// e = 1 if (A^2*r1 - r2^2) * A * r2^3) is a non-zero square +// e = -1 if (A^2*r1 - r2^2) * A * r2^3) is not a square +// Note that w^3 + A*w^2 + w (and therefore e) can never be zero: +// w^3 + A*w^2 + w = w * (w^2 + A*w + 1) +// w^3 + A*w^2 + w = w * (w^2 + A*w + A^2/4 - A^2/4 + 1) +// w^3 + A*w^2 + w = w * (w + A/2)^2 - A^2/4 + 1) +// which is zero only if: +// w = 0 (impossible) +// (w + A/2)^2 = A^2/4 - 1 (impossible, because A^2/4-1 is not a square) +// +// Let isr = invsqrt((A^2*r1 - r2^2) * A * r2^3) +// isr = sqrt(1 / ((A^2*r1 - r2^2) * A * r2^3)) if e = 1 +// isr = sqrt(sqrt(-1) / ((A^2*r1 - r2^2) * A * r2^3)) if e = -1 +// +// if e = 1 +// let u1 = -A * (A^2*r1 - r2^2) * A * r2^2 * isr^2 +// u1 = w +// u1 = u +// +// if e = -1 +// let ufactor = -non_square * sqrt(-1) * r^2 +// let vfactor = sqrt(ufactor) +// let u2 = -A * (A^2*r1 - r2^2) * A * r2^2 * isr^2 * ufactor +// u2 = w * -1 * -non_square * r^2 +// u2 = w * non_square * r^2 +// u2 = u +void crypto_elligator_map(u8 curve[32], const u8 hidden[32]) +{ + fe r, u, t1, t2, t3; + fe_frombytes_mask(r, hidden, 2); // r is encoded in 254 bits. + fe_sq(r, r); + fe_add(t1, r, r); + fe_add(u, t1, fe_one); + fe_sq (t2, u); + fe_mul(t3, A2, t1); + fe_sub(t3, t3, t2); + fe_mul(t3, t3, A); + fe_mul(t1, t2, u); + fe_mul(t1, t3, t1); + int is_square = invsqrt(t1, t1); + fe_mul(u, r, ufactor); + fe_ccopy(u, fe_one, is_square); + fe_sq (t1, t1); + fe_mul(u, u, A); + fe_mul(u, u, t3); + fe_mul(u, u, t2); + fe_mul(u, u, t1); + fe_neg(u, u); + fe_tobytes(curve, u); + + WIPE_BUFFER(t1); WIPE_BUFFER(r); + WIPE_BUFFER(t2); WIPE_BUFFER(u); + WIPE_BUFFER(t3); +} + +// Elligator inverse map +// +// Computes the representative of a point, if possible. If not, it does +// nothing and returns -1. Note that the success of the operation +// depends only on the point (more precisely its u coordinate). The +// tweak parameter is used only upon success +// +// The tweak should be a random byte. Beyond that, its contents are an +// implementation detail. Currently, the tweak comprises: +// - Bit 1 : sign of the v coordinate (0 if positive, 1 if negative) +// - Bit 2-5: not used +// - Bits 6-7: random padding +// +// From the paper: +// Let sq = -non_square * u * (u+A) +// if sq is not a square, or u = -A, there is no mapping +// Assuming there is a mapping: +// if v is positive: r = sqrt(-u / (non_square * (u+A))) +// if v is negative: r = sqrt(-(u+A) / (non_square * u )) +// +// We compute isr = invsqrt(-non_square * u * (u+A)) +// if it wasn't a square, abort. +// else, isr = sqrt(-1 / (non_square * u * (u+A)) +// +// If v is positive, we return isr * u: +// isr * u = sqrt(-1 / (non_square * u * (u+A)) * u +// isr * u = sqrt(-u / (non_square * (u+A)) +// +// If v is negative, we return isr * (u+A): +// isr * (u+A) = sqrt(-1 / (non_square * u * (u+A)) * (u+A) +// isr * (u+A) = sqrt(-(u+A) / (non_square * u) +int crypto_elligator_rev(u8 hidden[32], const u8 public_key[32], u8 tweak) +{ + fe t1, t2, t3; + fe_frombytes(t1, public_key); // t1 = u + + fe_add(t2, t1, A); // t2 = u + A + fe_mul(t3, t1, t2); + fe_mul_small(t3, t3, -2); + int is_square = invsqrt(t3, t3); // t3 = sqrt(-1 / non_square * u * (u+A)) + if (is_square) { + // The only variable time bit. This ultimately reveals how many + // tries it took us to find a representable key. + // This does not affect security as long as we try keys at random. + + fe_ccopy (t1, t2, tweak & 1); // multiply by u if v is positive, + fe_mul (t3, t1, t3); // multiply by u+A otherwise + fe_mul_small(t1, t3, 2); + fe_neg (t2, t3); + fe_ccopy (t3, t2, fe_isodd(t1)); + fe_tobytes(hidden, t3); + + // Pad with two random bits + hidden[31] |= tweak & 0xc0; + } + + WIPE_BUFFER(t1); + WIPE_BUFFER(t2); + WIPE_BUFFER(t3); + return is_square - 1; +} + +void crypto_elligator_key_pair(u8 hidden[32], u8 secret_key[32], u8 seed[32]) +{ + u8 pk [32]; // public key + u8 buf[64]; // seed + representative + COPY(buf + 32, seed, 32); + do { + crypto_chacha20_djb(buf, 0, 64, buf+32, zero, 0); + crypto_x25519_dirty_fast(pk, buf); // or the "small" version + } while(crypto_elligator_rev(buf+32, pk, buf[32])); + // Note that the return value of crypto_elligator_rev() is + // independent from its tweak parameter. + // Therefore, buf[32] is not actually reused. Either we loop one + // more time and buf[32] is used for the new seed, or we succeeded, + // and buf[32] becomes the tweak parameter. + + crypto_wipe(seed, 32); + COPY(hidden , buf + 32, 32); + COPY(secret_key, buf , 32); + WIPE_BUFFER(buf); + WIPE_BUFFER(pk); +} + +/////////////////////// +/// Scalar division /// +/////////////////////// + +// Montgomery reduction. +// Divides x by (2^256), and reduces the result modulo L +// +// Precondition: +// x < L * 2^256 +// Constants: +// r = 2^256 (makes division by r trivial) +// k = (r * (1/r) - 1) // L (1/r is computed modulo L ) +// Algorithm: +// s = (x * k) % r +// t = x + s*L (t is always a multiple of r) +// u = (t/r) % L (u is always below 2*L, conditional subtraction is enough) +static void redc(u32 u[8], u32 x[16]) +{ + static const u32 k[8] = { + 0x12547e1b, 0xd2b51da3, 0xfdba84ff, 0xb1a206f2, + 0xffa36bea, 0x14e75438, 0x6fe91836, 0x9db6c6f2, + }; + + // s = x * k (modulo 2^256) + // This is cheaper than the full multiplication. + u32 s[8] = {0}; + FOR (i, 0, 8) { + u64 carry = 0; + FOR (j, 0, 8-i) { + carry += s[i+j] + (u64)x[i] * k[j]; + s[i+j] = (u32)carry; + carry >>= 32; + } + } + u32 t[16] = {0}; + multiply(t, s, L); + + // t = t + x + u64 carry = 0; + FOR (i, 0, 16) { + carry += (u64)t[i] + x[i]; + t[i] = (u32)carry; + carry >>= 32; + } + + // u = (t / 2^256) % L + // Note that t / 2^256 is always below 2*L, + // So a constant time conditional subtraction is enough + remove_l(u, t+8); + + WIPE_BUFFER(s); + WIPE_BUFFER(t); +} + +void crypto_x25519_inverse(u8 blind_salt [32], const u8 private_key[32], + const u8 curve_point[32]) +{ + static const u8 Lm2[32] = { // L - 2 + 0xeb, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, + 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, + }; + // 1 in Montgomery form + u32 m_inv [8] = { + 0x8d98951d, 0xd6ec3174, 0x737dcf70, 0xc6ef5bf4, + 0xfffffffe, 0xffffffff, 0xffffffff, 0x0fffffff, + }; + + u8 scalar[32]; + crypto_eddsa_trim_scalar(scalar, private_key); + + // Convert the scalar in Montgomery form + // m_scl = scalar * 2^256 (modulo L) + u32 m_scl[8]; + { + u32 tmp[16]; + ZERO(tmp, 8); + load32_le_buf(tmp+8, scalar, 8); + mod_l(scalar, tmp); + load32_le_buf(m_scl, scalar, 8); + WIPE_BUFFER(tmp); // Wipe ASAP to save stack space + } + + // Compute the inverse + u32 product[16]; + for (int i = 252; i >= 0; i--) { + ZERO(product, 16); + multiply(product, m_inv, m_inv); + redc(m_inv, product); + if (scalar_bit(Lm2, i)) { + ZERO(product, 16); + multiply(product, m_inv, m_scl); + redc(m_inv, product); + } + } + // Convert the inverse *out* of Montgomery form + // scalar = m_inv / 2^256 (modulo L) + COPY(product, m_inv, 8); + ZERO(product + 8, 8); + redc(m_inv, product); + store32_le_buf(scalar, m_inv, 8); // the *inverse* of the scalar + + // Clear the cofactor of scalar: + // cleared = scalar * (3*L + 1) (modulo 8*L) + // cleared = scalar + scalar * 3 * L (modulo 8*L) + // Note that (scalar * 3) is reduced modulo 8, so we only need the + // first byte. + add_xl(scalar, scalar[0] * 3); + + // Recall that 8*L < 2^256. However it is also very close to + // 2^255. If we spanned the ladder over 255 bits, random tests + // wouldn't catch the off-by-one error. + scalarmult(blind_salt, scalar, curve_point, 256); + + WIPE_BUFFER(scalar); WIPE_BUFFER(m_scl); + WIPE_BUFFER(product); WIPE_BUFFER(m_inv); +} + +//////////////////////////////// +/// Authenticated encryption /// +//////////////////////////////// +static void lock_auth(u8 mac[16], const u8 auth_key[32], + const u8 *ad , size_t ad_size, + const u8 *cipher_text, size_t text_size) +{ + u8 sizes[16]; // Not secret, not wiped + store64_le(sizes + 0, ad_size); + store64_le(sizes + 8, text_size); + crypto_poly1305_ctx poly_ctx; // auto wiped... + crypto_poly1305_init (&poly_ctx, auth_key); + crypto_poly1305_update(&poly_ctx, ad , ad_size); + crypto_poly1305_update(&poly_ctx, zero , gap(ad_size, 16)); + crypto_poly1305_update(&poly_ctx, cipher_text, text_size); + crypto_poly1305_update(&poly_ctx, zero , gap(text_size, 16)); + crypto_poly1305_update(&poly_ctx, sizes , 16); + crypto_poly1305_final (&poly_ctx, mac); // ...here +} + +void crypto_aead_init_x(crypto_aead_ctx *ctx, + u8 const key[32], const u8 nonce[24]) +{ + crypto_chacha20_h(ctx->key, key, nonce); + COPY(ctx->nonce, nonce + 16, 8); + ctx->counter = 0; +} + +void crypto_aead_init_djb(crypto_aead_ctx *ctx, + const u8 key[32], const u8 nonce[8]) +{ + COPY(ctx->key , key , 32); + COPY(ctx->nonce, nonce, 8); + ctx->counter = 0; +} + +void crypto_aead_init_ietf(crypto_aead_ctx *ctx, + const u8 key[32], const u8 nonce[12]) +{ + COPY(ctx->key , key , 32); + COPY(ctx->nonce, nonce + 4, 8); + ctx->counter = (u64)load32_le(nonce) << 32; +} + +void crypto_aead_write(crypto_aead_ctx *ctx, u8 *cipher_text, u8 mac[16], + const u8 *ad, size_t ad_size, + const u8 *plain_text, size_t text_size) +{ + u8 auth_key[64]; // the last 32 bytes are used for rekeying. + crypto_chacha20_djb(auth_key, 0, 64, ctx->key, ctx->nonce, ctx->counter); + crypto_chacha20_djb(cipher_text, plain_text, text_size, + ctx->key, ctx->nonce, ctx->counter + 1); + lock_auth(mac, auth_key, ad, ad_size, cipher_text, text_size); + COPY(ctx->key, auth_key + 32, 32); + WIPE_BUFFER(auth_key); +} + +int crypto_aead_read(crypto_aead_ctx *ctx, u8 *plain_text, const u8 mac[16], + const u8 *ad, size_t ad_size, + const u8 *cipher_text, size_t text_size) +{ + u8 auth_key[64]; // the last 32 bytes are used for rekeying. + u8 real_mac[16]; + crypto_chacha20_djb(auth_key, 0, 64, ctx->key, ctx->nonce, ctx->counter); + lock_auth(real_mac, auth_key, ad, ad_size, cipher_text, text_size); + int mismatch = crypto_verify16(mac, real_mac); + if (!mismatch) { + crypto_chacha20_djb(plain_text, cipher_text, text_size, + ctx->key, ctx->nonce, ctx->counter + 1); + COPY(ctx->key, auth_key + 32, 32); + } + WIPE_BUFFER(auth_key); + WIPE_BUFFER(real_mac); + return mismatch; +} + +void crypto_aead_lock(u8 *cipher_text, u8 mac[16], const u8 key[32], + const u8 nonce[24], const u8 *ad, size_t ad_size, + const u8 *plain_text, size_t text_size) +{ + crypto_aead_ctx ctx; + crypto_aead_init_x(&ctx, key, nonce); + crypto_aead_write(&ctx, cipher_text, mac, ad, ad_size, + plain_text, text_size); + crypto_wipe(&ctx, sizeof(ctx)); +} + +int crypto_aead_unlock(u8 *plain_text, const u8 mac[16], const u8 key[32], + const u8 nonce[24], const u8 *ad, size_t ad_size, + const u8 *cipher_text, size_t text_size) +{ + crypto_aead_ctx ctx; + crypto_aead_init_x(&ctx, key, nonce); + int mismatch = crypto_aead_read(&ctx, plain_text, mac, ad, ad_size, + cipher_text, text_size); + crypto_wipe(&ctx, sizeof(ctx)); + return mismatch; +} + +#ifdef MONOCYPHER_CPP_NAMESPACE +} +#endif diff --git a/third_party/monocypher/monocypher.h b/third_party/monocypher/monocypher.h new file mode 100644 index 000000000..765a07ff3 --- /dev/null +++ b/third_party/monocypher/monocypher.h @@ -0,0 +1,321 @@ +// Monocypher version 4.0.2 +// +// This file is dual-licensed. Choose whichever licence you want from +// the two licences listed below. +// +// The first licence is a regular 2-clause BSD licence. The second licence +// is the CC-0 from Creative Commons. It is intended to release Monocypher +// to the public domain. The BSD licence serves as a fallback option. +// +// SPDX-License-Identifier: BSD-2-Clause OR CC0-1.0 +// +// ------------------------------------------------------------------------ +// +// Copyright (c) 2017-2019, Loup Vaillant +// All rights reserved. +// +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// ------------------------------------------------------------------------ +// +// Written in 2017-2019 by Loup Vaillant +// +// To the extent possible under law, the author(s) have dedicated all copyright +// and related neighboring rights to this software to the public domain +// worldwide. This software is distributed without any warranty. +// +// You should have received a copy of the CC0 Public Domain Dedication along +// with this software. If not, see +// + +#ifndef MONOCYPHER_H +#define MONOCYPHER_H + +#include +#include + +#ifdef MONOCYPHER_CPP_NAMESPACE +namespace MONOCYPHER_CPP_NAMESPACE { +#elif defined(__cplusplus) +extern "C" { +#endif + +// Constant time comparisons +// ------------------------- + +// Return 0 if a and b are equal, -1 otherwise +int crypto_verify16(const uint8_t a[16], const uint8_t b[16]); +int crypto_verify32(const uint8_t a[32], const uint8_t b[32]); +int crypto_verify64(const uint8_t a[64], const uint8_t b[64]); + + +// Erase sensitive data +// -------------------- +void crypto_wipe(void *secret, size_t size); + + +// Authenticated encryption +// ------------------------ +void crypto_aead_lock(uint8_t *cipher_text, + uint8_t mac [16], + const uint8_t key [32], + const uint8_t nonce[24], + const uint8_t *ad, size_t ad_size, + const uint8_t *plain_text, size_t text_size); +int crypto_aead_unlock(uint8_t *plain_text, + const uint8_t mac [16], + const uint8_t key [32], + const uint8_t nonce[24], + const uint8_t *ad, size_t ad_size, + const uint8_t *cipher_text, size_t text_size); + +// Authenticated stream +// -------------------- +typedef struct { + uint64_t counter; + uint8_t key[32]; + uint8_t nonce[8]; +} crypto_aead_ctx; + +void crypto_aead_init_x(crypto_aead_ctx *ctx, + const uint8_t key[32], const uint8_t nonce[24]); +void crypto_aead_init_djb(crypto_aead_ctx *ctx, + const uint8_t key[32], const uint8_t nonce[8]); +void crypto_aead_init_ietf(crypto_aead_ctx *ctx, + const uint8_t key[32], const uint8_t nonce[12]); + +void crypto_aead_write(crypto_aead_ctx *ctx, + uint8_t *cipher_text, + uint8_t mac[16], + const uint8_t *ad , size_t ad_size, + const uint8_t *plain_text, size_t text_size); +int crypto_aead_read(crypto_aead_ctx *ctx, + uint8_t *plain_text, + const uint8_t mac[16], + const uint8_t *ad , size_t ad_size, + const uint8_t *cipher_text, size_t text_size); + + +// General purpose hash (BLAKE2b) +// ------------------------------ + +// Direct interface +void crypto_blake2b(uint8_t *hash, size_t hash_size, + const uint8_t *message, size_t message_size); + +void crypto_blake2b_keyed(uint8_t *hash, size_t hash_size, + const uint8_t *key, size_t key_size, + const uint8_t *message, size_t message_size); + +// Incremental interface +typedef struct { + // Do not rely on the size or contents of this type, + // for they may change without notice. + uint64_t hash[8]; + uint64_t input_offset[2]; + uint64_t input[16]; + size_t input_idx; + size_t hash_size; +} crypto_blake2b_ctx; + +void crypto_blake2b_init(crypto_blake2b_ctx *ctx, size_t hash_size); +void crypto_blake2b_keyed_init(crypto_blake2b_ctx *ctx, size_t hash_size, + const uint8_t *key, size_t key_size); +void crypto_blake2b_update(crypto_blake2b_ctx *ctx, + const uint8_t *message, size_t message_size); +void crypto_blake2b_final(crypto_blake2b_ctx *ctx, uint8_t *hash); + + +// Password key derivation (Argon2) +// -------------------------------- +#define CRYPTO_ARGON2_D 0 +#define CRYPTO_ARGON2_I 1 +#define CRYPTO_ARGON2_ID 2 + +typedef struct { + uint32_t algorithm; // Argon2d, Argon2i, Argon2id + uint32_t nb_blocks; // memory hardness, >= 8 * nb_lanes + uint32_t nb_passes; // CPU hardness, >= 1 (>= 3 recommended for Argon2i) + uint32_t nb_lanes; // parallelism level (single threaded anyway) +} crypto_argon2_config; + +typedef struct { + const uint8_t *pass; + const uint8_t *salt; + uint32_t pass_size; + uint32_t salt_size; // 16 bytes recommended +} crypto_argon2_inputs; + +typedef struct { + const uint8_t *key; // may be NULL if no key + const uint8_t *ad; // may be NULL if no additional data + uint32_t key_size; // 0 if no key (32 bytes recommended otherwise) + uint32_t ad_size; // 0 if no additional data +} crypto_argon2_extras; + +extern const crypto_argon2_extras crypto_argon2_no_extras; + +void crypto_argon2(uint8_t *hash, uint32_t hash_size, void *work_area, + crypto_argon2_config config, + crypto_argon2_inputs inputs, + crypto_argon2_extras extras); + + +// Key exchange (X-25519) +// ---------------------- + +// Shared secrets are not quite random. +// Hash them to derive an actual shared key. +void crypto_x25519_public_key(uint8_t public_key[32], + const uint8_t secret_key[32]); +void crypto_x25519(uint8_t raw_shared_secret[32], + const uint8_t your_secret_key [32], + const uint8_t their_public_key [32]); + +// Conversion to EdDSA +void crypto_x25519_to_eddsa(uint8_t eddsa[32], const uint8_t x25519[32]); + +// scalar "division" +// Used for OPRF. Be aware that exponential blinding is less secure +// than Diffie-Hellman key exchange. +void crypto_x25519_inverse(uint8_t blind_salt [32], + const uint8_t private_key[32], + const uint8_t curve_point[32]); + +// "Dirty" versions of x25519_public_key(). +// Use with crypto_elligator_rev(). +// Leaks 3 bits of the private key. +void crypto_x25519_dirty_small(uint8_t pk[32], const uint8_t sk[32]); +void crypto_x25519_dirty_fast (uint8_t pk[32], const uint8_t sk[32]); + + +// Signatures +// ---------- + +// EdDSA with curve25519 + BLAKE2b +void crypto_eddsa_key_pair(uint8_t secret_key[64], + uint8_t public_key[32], + uint8_t seed[32]); +void crypto_eddsa_sign(uint8_t signature [64], + const uint8_t secret_key[64], + const uint8_t *message, size_t message_size); +int crypto_eddsa_check(const uint8_t signature [64], + const uint8_t public_key[32], + const uint8_t *message, size_t message_size); + +// Conversion to X25519 +void crypto_eddsa_to_x25519(uint8_t x25519[32], const uint8_t eddsa[32]); + +// EdDSA building blocks +void crypto_eddsa_trim_scalar(uint8_t out[32], const uint8_t in[32]); +void crypto_eddsa_reduce(uint8_t reduced[32], const uint8_t expanded[64]); +void crypto_eddsa_mul_add(uint8_t r[32], + const uint8_t a[32], + const uint8_t b[32], + const uint8_t c[32]); +void crypto_eddsa_scalarbase(uint8_t point[32], const uint8_t scalar[32]); +int crypto_eddsa_check_equation(const uint8_t signature[64], + const uint8_t public_key[32], + const uint8_t h_ram[32]); + + +// Chacha20 +// -------- + +// Specialised hash. +// Used to hash X25519 shared secrets. +void crypto_chacha20_h(uint8_t out[32], + const uint8_t key[32], + const uint8_t in [16]); + +// Unauthenticated stream cipher. +// Don't forget to add authentication. +uint64_t crypto_chacha20_djb(uint8_t *cipher_text, + const uint8_t *plain_text, + size_t text_size, + const uint8_t key[32], + const uint8_t nonce[8], + uint64_t ctr); +uint32_t crypto_chacha20_ietf(uint8_t *cipher_text, + const uint8_t *plain_text, + size_t text_size, + const uint8_t key[32], + const uint8_t nonce[12], + uint32_t ctr); +uint64_t crypto_chacha20_x(uint8_t *cipher_text, + const uint8_t *plain_text, + size_t text_size, + const uint8_t key[32], + const uint8_t nonce[24], + uint64_t ctr); + + +// Poly 1305 +// --------- + +// This is a *one time* authenticator. +// Disclosing the mac reveals the key. +// See crypto_lock() on how to use it properly. + +// Direct interface +void crypto_poly1305(uint8_t mac[16], + const uint8_t *message, size_t message_size, + const uint8_t key[32]); + +// Incremental interface +typedef struct { + // Do not rely on the size or contents of this type, + // for they may change without notice. + uint8_t c[16]; // chunk of the message + size_t c_idx; // How many bytes are there in the chunk. + uint32_t r [4]; // constant multiplier (from the secret key) + uint32_t pad[4]; // random number added at the end (from the secret key) + uint32_t h [5]; // accumulated hash +} crypto_poly1305_ctx; + +void crypto_poly1305_init (crypto_poly1305_ctx *ctx, const uint8_t key[32]); +void crypto_poly1305_update(crypto_poly1305_ctx *ctx, + const uint8_t *message, size_t message_size); +void crypto_poly1305_final (crypto_poly1305_ctx *ctx, uint8_t mac[16]); + + +// Elligator 2 +// ----------- + +// Elligator mappings proper +void crypto_elligator_map(uint8_t curve [32], const uint8_t hidden[32]); +int crypto_elligator_rev(uint8_t hidden[32], const uint8_t curve [32], + uint8_t tweak); + +// Easy to use key pair generation +void crypto_elligator_key_pair(uint8_t hidden[32], uint8_t secret_key[32], + uint8_t seed[32]); + +#ifdef __cplusplus +} +#endif + +#endif // MONOCYPHER_H diff --git a/tools/nightly_publish.sh b/tools/nightly_publish.sh index 343ce3649..dca6847f2 100755 --- a/tools/nightly_publish.sh +++ b/tools/nightly_publish.sh @@ -2,6 +2,9 @@ # Puts one platform's nightly file on the rolling "nightly" pre-release (.github/workflows/nightly.yml), replacing that # platform's older nightly file. Each platform's job calls it as soon as its own build is done, so a platform that is # slow or fails never holds the others back. +# The platform's update manifest (build/dist/update-.txt, tools/update_manifest.sh) goes up right after the +# file and before the older file goes, so it always names a file that is there; without one (no signing key) the old +# manifest is removed, so the start screen's Update never fetches a file of an older round. # Usage: tools/nightly_publish.sh (GH_TOKEN, GH_REPO set) set -euo pipefail f=$1 @@ -10,6 +13,10 @@ suffix=$2 new=$(basename "$f" | tr ' ' .) # (GitHub stores "LAS Recomp-..." as "LAS.Recomp-...") case $new in LAS.Recomp-nightly-*-"$suffix") ;; *) echo "nightly_publish.sh: $new is not a nightly $suffix file" >&2; exit 1 ;; esac gh release upload nightly "$f" --clobber +platform=${suffix%.*} # (windows.zip -> windows, linux-x86_64.AppImage -> linux-x86_64) +manifest=$(dirname "$f")/update-$platform.txt +if [ -f "$manifest" ]; then gh release upload nightly "$manifest" --clobber +else gh release delete-asset nightly "update-$platform.txt" -y 2>/dev/null || true; fi # (this platform's older nightly files out, after the new one is up: the page never lacks this platform) gh release view nightly --json assets -q '.assets[].name' | while read -r old; do case $old in LAS.Recomp-nightly-*-"$suffix") [ "$old" = "$new" ] || gh release delete-asset nightly "$old" -y ;; esac diff --git a/tools/test_update.cpp b/tools/test_update.cpp new file mode 100644 index 000000000..684b9a740 --- /dev/null +++ b/tools/test_update.cpp @@ -0,0 +1,230 @@ +// The self-updater's core (runtime/update_core.h): the signed manifest, the files it may write, the swap, its journal +// and the rollback, including a swap killed halfway and a folder that can't be written. No game, no network. +// Build + run (from the repo root): +// c++ -std=c++17 -O1 -Iruntime tools/test_update.cpp -o build/test-update && build/test-update +#include +#include + +#include "update_core.h" +// (Monocypher's C compiled into this file as C++, so one command builds it on every platform) +#include "../third_party/monocypher/monocypher.c" +#undef FOR // (each file defines its own) +#include "../third_party/monocypher/monocypher-ed25519.c" + +static int fails; +#define CHECK(c, ...) do { if (!(c)) { fails++; printf("FAIL %s:%d: ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } } while (0) + +static uint8_t g_sk[64], g_pk[32], g_other_pk[32]; +static std::string sign(const std::string &t) { + uint8_t sig[64]; + crypto_ed25519_sign(sig, g_sk, (const uint8_t *)t.data(), t.size()); + std::string s = t + "signature "; + char b[3]; + for (uint8_t c : sig) snprintf(b, 3, "%02x", c), s += b; + return s + "\n"; +} +static std::string sha_of(const std::string &data) { + CacheSha256 h; + h.add(data.data(), data.size()); + return h.finish(); +} +static void write(const std::string &p, const std::string &data) { + upd_mkdirs_for(p); + FILE *f = fopen(p.c_str(), "wb"); + fwrite(data.data(), 1, data.size(), f); + fclose(f); +} +static std::string read(const std::string &p) { + std::string s; + FILE *f = fopen(p.c_str(), "rb"); + if (!f) return ""; + char b[4096]; + size_t n; + while ((n = fread(b, 1, sizeof b, f)) > 0) s.append(b, n); + fclose(f); + return s; +} + +static void manifest_tests() { + UpdManifest m; + m.version = "nightly-202611161000-abc1234", m.platform = "windows"; + m.asset = "LAS.Recomp-nightly-202611161000-abc1234-windows.zip", m.asset_size = 5, m.asset_sha256 = sha_of("hello"); + m.files = {{"lasrecomp.exe", 3, sha_of("new")}, {"zig/lib/a b.h", 1, sha_of("x")}}; + std::string good = sign(upd_manifest_text(m)), why; + UpdManifest r; + CHECK(upd_parse_manifest(good, g_pk, &r, &why), "good manifest: %s", why.c_str()); + CHECK(r.version == m.version && r.platform == "windows" && r.asset == m.asset && r.asset_size == 5 && + r.files.size() == 2 && r.files[1].path == "zig/lib/a b.h", "fields read back"); + CHECK(!upd_parse_manifest(good, g_other_pk, &r, &why) && why == "signature does not match", "another key: %s", why.c_str()); + std::string t = good; + t[t.find("windows")] = 'W'; + CHECK(!upd_parse_manifest(t, g_pk, &r, &why), "a changed byte"); + t = good; + t[t.size() - 3] = t[t.size() - 3] == '0' ? '1' : '0'; + CHECK(!upd_parse_manifest(t, g_pk, &r, &why), "a changed signature"); + CHECK(!upd_parse_manifest(good.substr(0, good.size() / 2), g_pk, &r, &why), "truncated"); + CHECK(!upd_parse_manifest("", g_pk, &r, &why), "empty"); + CHECK(!upd_parse_manifest(good + "file 1 " + sha_of("x") + " extra\n", g_pk, &r, &why), "a line after the signature"); + // signed, but wrong inside: every one refused + const char *bad[] = { + "LAS Recomp update 2\nversion v\nplatform p\nasset 1 %s a\n", // a newer format + "LAS Recomp update 1\nversion v\nplatform p\n", // no asset + "LAS Recomp update 1\nversion v\nplatform p\nasset 1 %s a/b\n", // asset with a folder + "LAS Recomp update 1\nversion v\nplatform p\nasset x %s a\n", // size not a number + "LAS Recomp update 1\nversion v\nplatform p\nasset 1 %s a\nwhat 1\n", // unknown line + "LAS Recomp update 1\nversion v\nplatform p\nasset 1 %s a\nfile 1 %s ../evil.dll\n", + "LAS Recomp update 1\nversion v\nplatform p\nasset 1 %s a\nfile 1 %s /etc/passwd\n", + "LAS Recomp update 1\nversion v\nplatform p\nasset 1 %s a\nfile 1 %s save/system.bin\n", + "LAS Recomp update 1\nversion v\nplatform p\nasset 1 %s a\nfile 1 %s Larecomp.ini\n", + "LAS Recomp update 1\nversion v\nplatform p\nasset 1 %s a\nfile 1 %s extracted/exefs/main\n", + "LAS Recomp update 1\nversion v\nplatform p\nasset 1 %s a\nfile 1 %s lasrecomp.log\n", + "LAS Recomp update 1\nversion v\nplatform p\nasset 1 %s a\nfile 1 %s a.exe\nfile 1 %s A.EXE\n", // twice + "LAS Recomp update 1\r\nversion v\nplatform p\nasset 1 %s a\n", + }; + std::string h = sha_of("x"); + for (const char *b : bad) { + char buf[1024]; + snprintf(buf, sizeof buf, b, h.c_str(), h.c_str(), h.c_str()); + CHECK(!upd_parse_manifest(sign(buf), g_pk, &r, &why), "refused: %s", buf); + } + // paths + const char *ok_paths[] = {"lasrecomp.exe", "zig/lib/std/a.zig", "rando-gen/_internal/x.pyd", "README.md", "saves.txt"}; + for (const char *p : ok_paths) CHECK(upd_safe_path(p), "app path %s", p); + const char *no_paths[] = {"", "/abs", "a//b", "a/./b", "a/../b", "C:/x", "a\\b", "dir/", "rando/x", "SAVE/x", + "cache/pipelines", "fonts/a.ttf", "data_root.txt", "lasrecomp-backup-1.log", ".lasrecomp-update/x", + "gamecontrollerdb.txt", "x.", "x "}; + for (const char *p : no_paths) CHECK(!upd_safe_path(p), "not an app path: '%s'", p); +} + +// An app folder with old files, data next to them (Windows: the data folder is the app's), new files staged +static std::string g_root; +static UpdPaths make_app(const char *name, std::vector *files) { + UpdPaths p{g_root + "/" + name}; + upd_remove_tree(p.app); + write(p.app + "/lasrecomp.exe", "old exe"); + write(p.app + "/SDL3.dll", "old sdl"); + write(p.app + "/zig/lib/a.h", "old a"); + write(p.app + "/save/system.bin", "SAVE"); // data: never touched + write(p.app + "/larecomp.ini", "settings"); + write(p.app + "/extracted/exefs/main", "game"); + write(p.app + "/old-only.dll", "a file the new version doesn't list"); + *files = {{"lasrecomp.exe", 7, sha_of("new exe")}, {"SDL3.dll", 7, sha_of("new sdl")}, + {"zig/lib/a.h", 5, sha_of("new a")}, {"zig/lib/added.h", 9, sha_of("new added")}}; + write(p.new_dir() + "/lasrecomp.exe", "new exe"); + write(p.new_dir() + "/SDL3.dll", "new sdl"); + write(p.new_dir() + "/zig/lib/a.h", "new a"); + write(p.new_dir() + "/zig/lib/added.h", "new added"); + return p; +} +static bool is_old(const UpdPaths &p) { + return read(p.app + "/lasrecomp.exe") == "old exe" && read(p.app + "/SDL3.dll") == "old sdl" && + read(p.app + "/zig/lib/a.h") == "old a" && !upd_exists(p.app + "/zig/lib/added.h"); +} +static bool is_new(const UpdPaths &p) { + return read(p.app + "/lasrecomp.exe") == "new exe" && read(p.app + "/SDL3.dll") == "new sdl" && + read(p.app + "/zig/lib/a.h") == "new a" && read(p.app + "/zig/lib/added.h") == "new added"; +} +static bool data_intact(const UpdPaths &p) { + return read(p.app + "/save/system.bin") == "SAVE" && read(p.app + "/larecomp.ini") == "settings" && + read(p.app + "/extracted/exefs/main") == "game" && upd_exists(p.app + "/old-only.dll"); +} + +static void swap_tests() { + std::vector files; + std::string why; + { // the normal way: swap, first start, start screen + UpdPaths p = make_app("normal", &files); + CHECK(upd_check_staged(p.new_dir(), files, &why), "staged: %s", why.c_str()); + CHECK(upd_swap(p, files, "v2", "v1", &why), "swap: %s", why.c_str()); + CHECK(is_new(p) && data_intact(p), "new files in place, data untouched"); + CHECK(read(p.old_dir() + "/lasrecomp.exe") == "old exe", "old kept"); + CHECK(upd_boot(p, "v2") == UPD_BOOT_STARTED, "first start"); + CHECK(is_new(p), "still new"); + upd_commit(p); + CHECK(is_new(p) && data_intact(p) && !upd_exists(p.work()), "committed: work folder gone"); + CHECK(upd_boot(p, "v2") == UPD_BOOT_NOTHING, "later starts: nothing"); + } + { // the new version starts but never reaches the start screen: the next start restores + UpdPaths p = make_app("crashy", &files); + CHECK(upd_swap(p, files, "v2", "v1", &why), "swap: %s", why.c_str()); + CHECK(upd_boot(p, "v2") == UPD_BOOT_STARTED, "first start"); + CHECK(upd_boot(p, "v2") == UPD_BOOT_RESTORED, "second start without the start screen: restored"); + CHECK(is_old(p) && data_intact(p) && !upd_exists(p.work()), "old files back, data untouched"); + } + for (int k = 0; k <= 4; k++) { // killed after k files (k = 4: before the journal said installed) + UpdPaths p = make_app(("killed" + std::to_string(k)).c_str(), &files); + CHECK(!upd_swap(p, files, "v2", "v1", &why, k), "stopped after %d", k); + UpdJournal j; + CHECK(upd_read_journal(p, &j) && j.state == "swapping", "journal says swapping"); + CHECK(upd_boot(p, "v1") == UPD_BOOT_RESTORED, "killed after %d: restored", k); + CHECK(is_old(p) && data_intact(p) && !upd_exists(p.work()), "killed after %d: old files back", k); + } + { // killed between "moved" written and the move (the journal names a file still in place) + UpdPaths p = make_app("journaled", &files); + write(p.state(), "state swapping \nversion v2\nfrom v1\nmoved lasrecomp.exe\n"); + CHECK(upd_boot(p, "v1") == UPD_BOOT_RESTORED && is_old(p) && data_intact(p), "nothing moved: unchanged"); + } + { // killed after the move aside, before the new file went in + UpdPaths p = make_app("halfmove", &files); + upd_mkdirs_for(p.old_dir() + "/lasrecomp.exe"); + upd_move(p.app + "/lasrecomp.exe", p.old_dir() + "/lasrecomp.exe"); + write(p.state(), "state swapping \nversion v2\nfrom v1\nmoved lasrecomp.exe\n"); + CHECK(upd_boot(p, "v1") == UPD_BOOT_RESTORED && is_old(p), "moved aside only: put back"); + } + { // a half-written journal line (killed while writing it) + UpdPaths p = make_app("halfline", &files); + CHECK(!upd_swap(p, files, "v2", "v1", &why, 2), "stopped"); + FILE *f = fopen(p.state().c_str(), "ab"); + fputs("moved zig/li", f); + fclose(f); + CHECK(upd_boot(p, "v1") == UPD_BOOT_RESTORED && is_old(p) && data_intact(p), "half line: restored"); + } + { // a staged file damaged or missing: refused before anything moves + UpdPaths p = make_app("damaged", &files); + write(p.new_dir() + "/SDL3.dll", "new sdX"); + CHECK(!upd_check_staged(p.new_dir(), files, &why), "damaged file refused"); + remove((p.new_dir() + "/zig/lib/a.h").c_str()); + CHECK(!upd_check_staged(p.new_dir(), files, &why), "missing file refused"); + CHECK(is_old(p), "nothing changed"); + } + { // a download left behind without a journal: cleaned at start + UpdPaths p = make_app("leftover", &files); + CHECK(upd_boot(p, "v1") == UPD_BOOT_NOTHING && !upd_exists(p.work()) && is_old(p), "leftover removed"); + } + { // installed, but another version runs (put back by hand): the old files go, nothing else changes + UpdPaths p = make_app("byhand", &files); + CHECK(upd_swap(p, files, "v2", "v1", &why), "swap"); + CHECK(upd_boot(p, "v1") == UPD_BOOT_NOTHING && !upd_exists(p.work()) && is_new(p), "other version: kept as is"); + } +#ifndef _WIN32 + if (geteuid() != 0) { // a folder that can't be written: Update is off (Download remains) + UpdPaths p = make_app("readonly", &files); + CHECK(upd_dir_writable(p.app), "writable before"); + chmod(p.app.c_str(), 0555); + CHECK(!upd_dir_writable(p.app), "read-only folder detected"); + CHECK(!upd_swap(p, files, "v2", "v1", &why), "swap into a read-only folder fails"); + chmod(p.app.c_str(), 0755); + UpdJournal j; + if (upd_read_journal(p, &j)) upd_restore(p, j); + CHECK(is_old(p) && data_intact(p), "read-only: unchanged"); + } +#endif +} + +int main() { + uint8_t seed[32], seed2[32], sk2[64]; + for (int i = 0; i < 32; i++) seed[i] = (uint8_t)(i * 7 + 1), seed2[i] = (uint8_t)(i * 13 + 5); + crypto_ed25519_key_pair(g_sk, g_pk, seed); + crypto_ed25519_key_pair(sk2, g_other_pk, seed2); + const char *tmp = getenv("TMPDIR"); + if (!tmp || !*tmp) tmp = getenv("TEMP"); + g_root = std::string(tmp && *tmp ? tmp : "/tmp") + "/lasrecomp-test-update"; + for (char &c : g_root) if (c == '\\') c = '/'; + upd_remove_tree(g_root); + upd_mkdir(g_root.c_str()); + manifest_tests(); + swap_tests(); + upd_remove_tree(g_root); + printf(fails ? "%d FAILED\n" : "all passed\n", fails); + return fails != 0; +} diff --git a/tools/update_manifest.sh b/tools/update_manifest.sh new file mode 100755 index 000000000..c0275f622 --- /dev/null +++ b/tools/update_manifest.sh @@ -0,0 +1,21 @@ +#!/bin/bash +# The self-updater's signed manifest for one release file (runtime/update_core.h): build/dist/update-.txt. +# release.yml and nightly.yml run it after each platform's build, with the UPDATE_SIGNING_KEY secret in the +# environment. Without the key (a fork, or a run before the key existed) it only warns: the release still ships, and +# the start screen's Update needs the manifest, so players there use Download. +# Usage: tools/update_manifest.sh [] +set -euo pipefail +cd "$(dirname "$0")/.." +[ $# -ge 3 ] || { echo "usage: tools/update_manifest.sh []" >&2; exit 2; } +out=build/dist/update-$2.txt +rm -f "$out" +if [ -z "${UPDATE_SIGNING_KEY:-}" ]; then + echo "::warning::UPDATE_SIGNING_KEY is not set: no update manifest for $2 (players there update with Download)" + exit 0 +fi +mkdir -p build +"${CXX_UPDATE:-clang++}" -std=c++17 -O2 -Iruntime tools/update_sign.cpp -o build/update_sign +build/update_sign manifest "$@" > "$out.part" +mv "$out.part" "$out" +head -4 "$out" +echo "$(grep -c '^file ' "$out" || true) files; $out" diff --git a/tools/update_sign.cpp b/tools/update_sign.cpp new file mode 100644 index 000000000..af2ab0ac5 --- /dev/null +++ b/tools/update_sign.cpp @@ -0,0 +1,155 @@ +// Signs the self-updater's manifests (runtime/update_core.h) and the macOS update's Sparkle signature, with one +// Ed25519 key (Monocypher, CC0). Used by release.yml and nightly.yml; the private key is the UPDATE_SIGNING_KEY secret +// (base64 of the 32-byte seed, the format Sparkle's own tools use), never on disk in the repo. +// Build: c++ -std=c++17 -O2 -Iruntime tools/update_sign.cpp -o build/update_sign +// update_sign keygen a new key: the seed (base64) into the file, the public key printed +// update_sign public the public key of $UPDATE_SIGNING_KEY (hex, then base64) +// update_sign manifest [] > update-.txt +// the signed manifest for a release file; : what a zip holds +// (its top folder), every file in it listed +// update_sign sparkle the file's signature for a Sparkle appcast (base64) +// update_sign verify checks a manifest (exit 0: good) +#include +#include + +#include +#include +#include + +#include "update_core.h" +// (Monocypher's C compiled into this file as C++, so one command builds it on every platform) +#include "../third_party/monocypher/monocypher.c" +#undef FOR // (each file defines its own) +#include "../third_party/monocypher/monocypher-ed25519.c" + +namespace fs = std::filesystem; + +static const char B64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +static std::string b64(const uint8_t *p, size_t n) { + std::string o; + for (size_t i = 0; i < n; i += 3) { + uint32_t v = p[i] << 16 | (i + 1 < n ? p[i + 1] << 8 : 0) | (i + 2 < n ? p[i + 2] : 0); + o += B64[v >> 18 & 63], o += B64[v >> 12 & 63]; + o += i + 1 < n ? B64[v >> 6 & 63] : '='; + o += i + 2 < n ? B64[v & 63] : '='; + } + return o; +} +static bool unb64(const std::string &s, std::vector *out) { + uint32_t v = 0; + int bits = 0; + for (char c : s) { + if (c == '=' || c == '\n' || c == '\r' || c == ' ') continue; + const char *k = strchr(B64, c); + if (!k || !c) return false; + v = v << 6 | (uint32_t)(k - B64), bits += 6; + if (bits >= 8) bits -= 8, out->push_back((uint8_t)(v >> bits)); + } + return true; +} +static std::string hex(const uint8_t *p, size_t n) { + std::string o; + char b[3]; + for (size_t i = 0; i < n; i++) snprintf(b, 3, "%02x", p[i]), o += b; + return o; +} +static void die(const char *m) { + fprintf(stderr, "update_sign: %s\n", m); + exit(1); +} + +// $UPDATE_SIGNING_KEY -> the 64-byte Monocypher secret key and the public key +static void key(uint8_t sk[64], uint8_t pk[32]) { + const char *e = getenv("UPDATE_SIGNING_KEY"); + std::vector seed; + if (!e || !*e) die("UPDATE_SIGNING_KEY is not set"); + if (!unb64(e, &seed) || seed.size() != 32) die("UPDATE_SIGNING_KEY: not a base64 32-byte seed"); + crypto_ed25519_key_pair(sk, pk, seed.data()); // (wipes the seed) +} +static bool read_file(const char *path, std::string *out) { + FILE *f = fopen(path, "rb"); + if (!f) return false; + char b[1 << 16]; + size_t n; + while ((n = fread(b, 1, sizeof b, f)) > 0) out->append(b, n); + bool ok = !ferror(f); + fclose(f); + return ok; +} + +int main(int argc, char **argv) { + std::string cmd = argc > 1 ? argv[1] : ""; + if (cmd == "keygen" && argc == 3) { + uint8_t seed[32], sk[64], pk[32]; + FILE *r = fopen("/dev/urandom", "rb"); + if (!r || fread(seed, 1, 32, r) != 32) die("no /dev/urandom"); + fclose(r); + if (upd_exists(argv[2])) die("the key file exists already: never replace a published key"); + std::string s = b64(seed, 32); + crypto_ed25519_key_pair(sk, pk, seed); + FILE *f = fopen(argv[2], "wx"); + if (!f || fprintf(f, "%s\n", s.c_str()) < 0 || fclose(f) != 0) die("can't write the key file"); + printf("public %s\npublic-base64 %s\n", hex(pk, 32).c_str(), b64(pk, 32).c_str()); + return 0; + } + if (cmd == "public" && argc == 2) { + uint8_t sk[64], pk[32]; + key(sk, pk); + printf("public %s\npublic-base64 %s\n", hex(pk, 32).c_str(), b64(pk, 32).c_str()); + return 0; + } + if (cmd == "sparkle" && argc == 3) { + uint8_t sk[64], pk[32], sig[64]; + key(sk, pk); + std::string data; + if (!read_file(argv[2], &data)) die("can't read the file"); + crypto_ed25519_sign(sig, sk, (const uint8_t *)data.data(), data.size()); + printf("%s\n", b64(sig, 64).c_str()); + return 0; + } + if (cmd == "manifest" && (argc == 5 || argc == 6)) { + uint8_t sk[64], pk[32], sig[64]; + key(sk, pk); + UpdManifest m; + m.version = argv[2], m.platform = argv[3]; + m.asset = fs::path(argv[4]).filename().string(); + std::replace(m.asset.begin(), m.asset.end(), ' ', '.'); // (GitHub stores "LAS Recomp-..." as "LAS.Recomp-...") + m.asset_sha256 = upd_file_sha256(argv[4], &m.asset_size); + if (m.asset_sha256.empty()) die("can't read the file"); + if (argc == 6) { + fs::path top(argv[5]); + for (auto &e : fs::recursive_directory_iterator(top)) { + if (e.is_symlink()) die("a link inside the folder (zips can't hold them)"); + if (!e.is_regular_file()) continue; + UpdFile f; + f.path = fs::relative(e.path(), top).generic_string(); + if (!upd_safe_path(f.path)) { fprintf(stderr, "%s\n", f.path.c_str()); die("a file the updater may not write"); } + f.sha256 = upd_file_sha256(e.path().string(), &f.size); + if (f.sha256.empty()) die("can't read a file in the folder"); + m.files.push_back(f); + } + std::sort(m.files.begin(), m.files.end(), [](const UpdFile &a, const UpdFile &b) { return a.path < b.path; }); + if (m.files.empty()) die("an empty folder"); + } + std::string t = upd_manifest_text(m); + crypto_ed25519_sign(sig, sk, (const uint8_t *)t.data(), t.size()); + t += "signature " + hex(sig, 64) + "\n"; + UpdManifest back; // (it must read back as the app will read it) + std::string why; + if (!upd_parse_manifest(t, pk, &back, &why)) die(why.c_str()); + fwrite(t.data(), 1, t.size(), stdout); + return 0; + } + if (cmd == "verify" && argc == 4) { + std::string t, why; + uint8_t pk[32]; + if (!read_file(argv[2], &t)) die("can't read the manifest"); + if (!upd_hex(argv[3], pk, 32)) die("not a public key (64 hex)"); + UpdManifest m; + if (!upd_parse_manifest(t, pk, &m, &why)) die(why.c_str()); + printf("%s %s: %s, %zu files\n", m.version.c_str(), m.platform.c_str(), m.asset.c_str(), m.files.size()); + return 0; + } + fprintf(stderr, "usage: see the top of tools/update_sign.cpp\n"); + return 2; +} From 73f3747e06332a21ab571c8e2a63baad451b18b9 Mon Sep 17 00:00:00 2001 From: Peiikai <339721950+peiikai@users.noreply.github.com> Date: Sun, 15 Nov 2026 18:16:41 -0600 Subject: [PATCH 2/8] Self-update for the Windows zip and the Linux AppImage runtime/update.cpp downloads the platform's manifest and file, checks the signature and every sha256, then swaps only the files the manifest lists (on Windows the data folder is the exe's folder: saves, seeds, settings and game files are never touched), journaled so a swap cut off halfway is undone on the next start. The app restarts into the new version; the old files stay until it reaches the start screen (or boots the game), and a new version that never gets there is rolled back on the next start. Not writable, or not run as an AppImage: Update is off, Download remains. Tests: tools/test_update_e2e.sh runs the AppImage path against a local web server (update, restart, keep, rollback; bad signature, truncated and damaged downloads, wrong platform or version, missing files, read-only folder). Both tests run in CI, the unit test on Windows too. The real public key is still a placeholder until the signing key exists. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 23 +++ CONTRIBUTING.md | 3 + runtime/main.c | 4 + runtime/update.cpp | 325 ++++++++++++++++++++++++++++++++ runtime/update.h | 55 ++++++ runtime/update_crypto.c | 12 ++ runtime/update_crypto_ed25519.c | 10 + tools/test_update_e2e.cpp | 60 ++++++ tools/test_update_e2e.sh | 107 +++++++++++ 9 files changed, 599 insertions(+) create mode 100644 runtime/update.cpp create mode 100644 runtime/update.h create mode 100644 runtime/update_crypto.c create mode 100644 runtime/update_crypto_ed25519.c create mode 100644 tools/test_update_e2e.cpp create mode 100755 tools/test_update_e2e.sh diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2cd606208..4a56c3d62 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -129,6 +129,11 @@ jobs: run: | clang++ -std=c++17 -O1 tools/test_update_tags.cpp -o build/test-update-tags build/test-update-tags + - name: Self-updater (manifest, signature, swap and rollback) + run: | + clang++ -std=c++17 -O1 -Iruntime tools/test_update.cpp -o build/test-update + build/test-update + tools/test_update_e2e.sh - name: Controller rumble (HID bridge to SDL, fake gamepad) run: | clang -std=gnu11 -O2 -I"$HOME/sdl3/include" tools/test_rumble.c -L"$HOME/sdl3/lib" -Wl,-rpath,"$HOME/sdl3/lib" -lSDL3 -lm -o build/test-rumble @@ -265,6 +270,11 @@ jobs: run: | clang++ -std=c++17 -O1 tools/test_update_tags.cpp -o build/test-update-tags build/test-update-tags + - name: Self-updater (manifest, signature, swap and rollback) + run: | + clang++ -std=c++17 -O1 -Iruntime tools/test_update.cpp -o build/test-update + build/test-update + tools/test_update_e2e.sh - name: Controller rumble (HID bridge to SDL, fake gamepad) run: | clang -std=gnu11 -O2 -I"$HOME/sdl3/include" tools/test_rumble.c -L"$HOME/sdl3/lib" -Wl,-rpath,"$HOME/sdl3/lib" -lSDL3 -lm -o build/test-rumble @@ -351,6 +361,11 @@ jobs: run: | clang++ -std=c++17 -O1 tools/test_update_tags.cpp -o build/test-update-tags build/test-update-tags + - name: Self-updater (manifest, signature, swap and rollback) + run: | + clang++ -std=c++17 -O1 -Iruntime tools/test_update.cpp -o build/test-update + build/test-update + tools/test_update_e2e.sh - name: Controller rumble (HID bridge to SDL, fake gamepad) run: | clang -std=gnu11 -O2 -I"$(brew --prefix sdl3)/include" -L"$(brew --prefix sdl3)/lib" tools/test_rumble.c -lSDL3 -o build/test-rumble @@ -507,6 +522,10 @@ jobs: run: python3 tools/test_delete_guard.py - name: Data folder move (cut off at every step) run: python3 tools/test_data_move.py + - name: Self-updater (manifest, signature, swap and rollback; Windows file rules) + run: | + clang++ -std=c++17 -O1 -Iruntime tools/test_update.cpp -o build/test-update.exe + build/test-update.exe - name: Movie extractor lifecycle regression run: | clang -std=gnu11 -O1 tools/test_movie_extractor.c -lavformat -lavcodec -lavutil -lswscale -o build/test-movie-extractor.exe @@ -611,6 +630,10 @@ jobs: run: python3 tools/test_delete_guard.py - name: Data folder move (cut off at every step) run: python3 tools/test_data_move.py + - name: Self-updater (manifest, signature, swap and rollback; Windows file rules) + run: | + clang++ -std=c++17 -O1 -Iruntime tools/test_update.cpp -o build/test-update.exe + build/test-update.exe - name: Movie extractor lifecycle regression run: | clang -pthread -std=gnu11 -O1 tools/test_movie_extractor.c -lavformat -lavcodec -lavutil -lswscale -o build/test-movie-extractor.exe diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index b172fac58..0bdd10878 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -132,6 +132,9 @@ items picked up anywhere, floor key spots included, get a message naming their d `python tools/test_text_speed.py` checks the Text speed hooks (Normal, Fast, Instant) without game data. +The updater: `tools/test_update.cpp` (manifest, signature, the swap and its rollback; build line at its top) and +`tools/test_update_e2e.sh` (download, check, swap and restart against a local web server), without game data or network. + Build-cache regression tests use synthetic inputs and the production scheduler: `python tools/test_build_cache.py` and `python tools/test_gamebuild_resume.py`. On Windows, also run `python tools/test_windows_processes.py` to check independent diff --git a/runtime/main.c b/runtime/main.c index 9250ac43d..f16975836 100644 --- a/runtime/main.c +++ b/runtime/main.c @@ -16,6 +16,7 @@ #include "hle.h" #include "kernel.h" #include "rando.h" +#include "update.h" const char *g_romfs_dir; @@ -324,6 +325,8 @@ int main(int argc, char **argv) { #else setvbuf(stderr, NULL, _IOLBF, 0); #endif + update_boot(); // (an update's swap that was cut off, or a new version that never reached the start screen: the + // old one back, and started instead of this process. runtime/update.h) const char *root = "extracted"; // (in the data root) // LARECOMP_NO_LAUNCHER=1 (tools/game_slot.sh sets it for every test run): never the start screen - it can // delete game files, and a test's extracted/ may be a link to someone else's. Where it would come up (a forced @@ -368,6 +371,7 @@ int main(int argc, char **argv) { launcher_run(root); } boot(root); + update_reached_start_screen(); // (--play skips the start screen: the game booting counts the same) int kind = ui_run(); // window and input on the main thread; returns when a reboot is requested teardown(); title = kind == RT_REBOOT_TITLE; diff --git a/runtime/update.cpp b/runtime/update.cpp new file mode 100644 index 000000000..84713c808 --- /dev/null +++ b/runtime/update.cpp @@ -0,0 +1,325 @@ +// Self-update for the Windows zip and the Linux AppImage: see update.h (what it does) and update_core.h (the manifest, +// the swap and its journal). +#include "update.h" + +#if !LARECOMP_SELF_UPDATE +void update_boot(void) {} +void update_reached_start_screen(void) {} +int update_available(const char **why) { if (why) *why = "not on this platform"; return 0; } +void update_start(const char *, const char *, long long) {} +void update_cancel(void) {} +int update_status(double *frac, char *msg, int n) { if (frac) *frac = -1; if (n > 0) msg[0] = 0; return UPDATE_IDLE; } +void update_restart(void) {} +#else + +#include +#include +#include +#include + +#include +#include + +#include "platform.h" +#include "update_core.h" +#ifdef _WIN32 +#include "zipfile.h" +#else +#include +#endif + +extern "C" const char *larecomp_version(void); // runtime/ui/launcher.mm (LARECOMP_VERSION) + +// The public half of the key that signs every manifest (the UPDATE_SIGNING_KEY secret; tools/update_sign.cpp). The +// same key signs the macOS updates for Sparkle (SUPublicEDKey in tools/bundle_macos.sh, base64 there). Never change +// it: builds out there only accept manifests signed by this one. +#define UPDATE_PUBLIC_KEY "0000000000000000000000000000000000000000000000000000000000000000" +#define DOWNLOAD_URL "https://github.com/peiikai/LASRecomp/releases/download" + +// Where the app is: the folder whose files the manifest lists (Windows), or the AppImage's folder and its name +static bool app_location(std::string *dir, std::string *appimage_name, const char **why) { +#ifdef _WIN32 + if (const char *t = getenv("LARECOMP_UPDATE_APP")) { *dir = t; return true; } +#ifndef LARECOMP_ZIP_BUILD + if (why) *why = "not the release zip (a build from source)"; + return false; +#endif + char exe[1100]; + if (!plat_exe_path(exe, sizeof exe)) { if (why) *why = "can't find the exe"; return false; } + std::string e = exe; + for (char &c : e) if (c == '\\') c = '/'; + size_t sl = e.rfind('/'); + if (sl == std::string::npos) { if (why) *why = "can't find the exe"; return false; } + *dir = e.substr(0, sl); + (void)appimage_name; + return true; +#else + const char *a = getenv("APPIMAGE"); + if (!a || a[0] != '/') { if (why) *why = "not run as an AppImage"; return false; } + std::string p = a; + size_t sl = p.rfind('/'); + *dir = sl == 0 ? "/" : p.substr(0, sl); + *appimage_name = p.substr(sl + 1); + return !appimage_name->empty(); +#endif +} + +static void end_process(void) { +#if defined(_WIN32) || defined(__linux__) + plat_terminate(); +#else + _exit(0); // (the end-to-end test on macOS) +#endif +} + +// ---- start and start screen +static void restart_app(const std::string &dir, const std::string &appimage_name); + +void update_boot(void) { + std::string dir, name; + if (!app_location(&dir, &name, NULL)) return; + UpdPaths p{dir}; + if (!upd_exists(p.work())) return; + int r = upd_boot(p, larecomp_version()); + if (r == UPD_BOOT_RESTORED) { + fprintf(stderr, "[update] the update didn't finish or the new version never reached the start screen: the " + "previous version is back\n"); + restart_app(dir, name); + } else if (r == UPD_BOOT_STARTED) fprintf(stderr, "[update] first start of %s after the update\n", larecomp_version()); +} + +void update_reached_start_screen(void) { + static bool once; + if (once) return; + once = true; + std::string dir, name; + if (!app_location(&dir, &name, NULL)) return; + UpdPaths p{dir}; + if (upd_exists(p.work())) upd_commit(p); +} + +int update_available(const char **why) { + std::string dir, name; + if (!app_location(&dir, &name, why)) return 0; + if (!upd_dir_writable(dir)) { if (why) *why = "the app's folder isn't writable"; return 0; } +#ifndef _WIN32 + if (access((dir + "/" + name).c_str(), W_OK) != 0) { if (why) *why = "the AppImage isn't writable"; return 0; } +#endif + return 1; +} + +// ---- the update itself (one background thread) +static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER; +static int g_state = UPDATE_IDLE; +static std::string g_msg; +static std::atomic g_total{0}; +static std::string g_part; // the file being downloaded (its size is the progress) +static std::atomic g_cancel{false}; +static PlatProc g_curl; +static std::string g_dir, g_name; + +static void set_status(int st, const std::string &msg) { + pthread_mutex_lock(&g_lock); + g_state = st, g_msg = msg; + pthread_mutex_unlock(&g_lock); + fprintf(stderr, "[update] %s\n", msg.c_str()); +} + +// url -> path with curl (the update check's: macOS and Windows 10+ ship it; Linux: the system's). false: not there. +static bool fetch(const std::string &url, const std::string &path, int max_secs) { +#ifdef _WIN32 + const char *sr = getenv("SystemRoot"); + std::string curl = std::string(sr ? sr : "C:\\Windows") + "\\System32\\curl.exe"; +#else + std::string curl = "/usr/bin/curl"; +#endif + std::string secs = std::to_string(max_secs), ua = std::string("LASRecomp/") + larecomp_version(); + const char *av[] = {curl.c_str(), "-fsSL", "--retry", "2", "--max-time", secs.c_str(), "-A", ua.c_str(), "-o", + path.c_str(), url.c_str(), NULL}; + remove(path.c_str()); + PlatProc pr = plat_spawn(av, NULL, false); + if (!pr) return false; + pthread_mutex_lock(&g_lock); + g_curl = pr; + pthread_mutex_unlock(&g_lock); + int rc = plat_proc_wait(pr, true); + pthread_mutex_lock(&g_lock); + g_curl = 0; + pthread_mutex_unlock(&g_lock); + return rc == 0 && !g_cancel; +} + +static bool read_text(const std::string &path, std::string *out, size_t max) { + FILE *f = fopen(path.c_str(), "rb"); + if (!f) return false; + char b[8192]; + size_t n; + while ((n = fread(b, 1, sizeof b, f)) > 0 && out->size() <= max) out->append(b, n); + fclose(f); + return out->size() <= max; +} + +struct Job { std::string tag, platform; long long min_stamp; }; + +static void *update_thread(void *arg) { + Job job = *(Job *)arg; + delete (Job *)arg; + UpdPaths p{g_dir}; + auto fail = [&](const std::string &why) { + upd_remove_tree(p.work()); + set_status(UPDATE_FAILED, g_cancel ? std::string("Cancelled.") : why); + return (void *)NULL; + }; + upd_remove_tree(p.work()); // (an earlier attempt's leftovers) + if (upd_mkdir(p.work().c_str()) != 0) return fail("Can't write in the app's folder."); + const char *base = getenv("LARECOMP_UPDATE_URL"); + std::string url = std::string(base && *base ? base : DOWNLOAD_URL) + "/" + job.tag + "/"; + + // the manifest: signed by our key, for this platform, the version that was offered + set_status(UPDATE_RUNNING, "Checking the update"); + std::string mpath = upd_join(p.work(), "manifest.txt"), text, why; + if (!fetch(url + "update-" + job.platform + ".txt", mpath, 60) || !read_text(mpath, &text, 1 << 20)) + return fail("Couldn't get the update's details."); + uint8_t pub[32]; + const char *k = base && *base ? getenv("LARECOMP_UPDATE_KEY") : NULL; // (tests: their own key, own server) + upd_hex(k && *k ? k : UPDATE_PUBLIC_KEY, pub, 32); + UpdManifest m; + if (!upd_parse_manifest(text, pub, &m, &why)) return fail("The update's details failed the check (" + why + ")."); + if (m.platform != job.platform) return fail("The update is for another platform."); + if (job.tag == "nightly") { + long long stamp = 0; // nightly-- + if (m.version.compare(0, 8, "nightly-") || sscanf(m.version.c_str() + 8, "%12lld", &stamp) != 1 || + stamp <= job.min_stamp) + return fail("The update isn't newer than this version."); + } else if (m.version != job.tag) return fail("The update's details are for another version."); +#ifdef _WIN32 + if (m.files.empty()) return fail("The update lists no files."); +#else + if (!m.files.empty()) return fail("The update isn't an AppImage."); +#endif + + // the file + set_status(UPDATE_RUNNING, "Downloading"); + std::string dl = upd_join(p.work(), "download"); + pthread_mutex_lock(&g_lock); + g_part = dl, g_total = m.asset_size; + pthread_mutex_unlock(&g_lock); + bool got = fetch(url + m.asset, dl, 3600); + pthread_mutex_lock(&g_lock); + g_part.clear(); + pthread_mutex_unlock(&g_lock); + if (!got) return fail("The download didn't finish."); + set_status(UPDATE_RUNNING, "Checking the download"); + uint64_t size = 0; + if (upd_file_sha256(dl, &size) != m.asset_sha256 || size != m.asset_size) return fail("The download is damaged."); + + // staged in new/, every file checked, then swapped + std::vector files = m.files; +#ifdef _WIN32 + set_status(UPDATE_RUNNING, "Unpacking"); + char zwhy[256] = ""; + ZipReader *z = zip_open(dl.c_str(), zwhy, sizeof zwhy); + if (!z) return fail(std::string("Can't open the download (") + zwhy + ")."); + bool ok = zip_extract(z, "LAS Recomp", p.new_dir().c_str(), zwhy, sizeof zwhy, NULL); + zip_close(z); + if (!ok) return fail(std::string("Can't unpack the download (") + zwhy + ")."); +#else + upd_mkdir(p.new_dir().c_str()); + if (!upd_move(dl, upd_join(p.new_dir(), g_name)) || chmod(upd_join(p.new_dir(), g_name).c_str(), 0755) != 0) + return fail("Can't prepare the AppImage."); + files = {UpdFile{g_name, m.asset_size, m.asset_sha256}}; +#endif + if (!upd_check_staged(p.new_dir(), files, &why)) return fail("The update is damaged (" + why + ")."); + if (g_cancel) return fail("Cancelled."); + set_status(UPDATE_RUNNING, "Installing"); + if (!upd_swap(p, files, m.version, larecomp_version(), &why)) { + UpdJournal j; + if (upd_read_journal(p, &j)) upd_restore(p, j); // (back to how it was) + return fail("The update couldn't be installed (" + why + "). Nothing was changed."); + } + remove(dl.c_str()); + upd_remove_tree(p.new_dir()); + set_status(UPDATE_DONE, "Installed " + m.version); + return NULL; +} + +void update_start(const char *tag, const char *platform, long long min_nightly_stamp) { + pthread_mutex_lock(&g_lock); + bool busy = g_state == UPDATE_RUNNING; + pthread_mutex_unlock(&g_lock); + if (busy) return; + const char *why = NULL; + if (!update_available(&why)) { set_status(UPDATE_FAILED, std::string("Update isn't possible here: ") + why + "."); return; } + app_location(&g_dir, &g_name, NULL); + g_cancel = false; + set_status(UPDATE_RUNNING, std::string("Updating to ") + tag); + pthread_t t; + if (pthread_create(&t, NULL, update_thread, new Job{tag, platform, min_nightly_stamp}) == 0) pthread_detach(t); + else set_status(UPDATE_FAILED, "Couldn't start the update."); +} + +void update_cancel(void) { + g_cancel = true; + pthread_mutex_lock(&g_lock); + if (g_curl) plat_proc_kill(g_curl); + pthread_mutex_unlock(&g_lock); +} + +int update_status(double *frac, char *msg, int n) { + pthread_mutex_lock(&g_lock); + int st = g_state; + if (n > 0) snprintf(msg, (size_t)n, "%s", g_msg.c_str()); + std::string part = g_part; + pthread_mutex_unlock(&g_lock); + if (frac) { + *frac = -1; + struct stat s; + if (!part.empty() && g_total && stat(part.c_str(), &s) == 0) *frac = fmin(1.0, (double)s.st_size / (double)g_total); + } + return st; +} + +static void restart_app(const std::string &dir, const std::string &appimage_name) { + if (getenv("LARECOMP_UPDATE_NO_RESTART")) { fprintf(stderr, "[update] not restarting (test)\n"); fflush(stderr); end_process(); } + fflush(stdout), fflush(stderr); +#ifdef _WIN32 + (void)appimage_name; + char exe[1100]; + std::string path = getenv("LARECOMP_UPDATE_APP") || !plat_exe_path(exe, sizeof exe) ? dir + "/lasrecomp.exe" : exe; + std::string cmd = "\"" + path + "\""; + wchar_t wpath[1100], wcmd[1200]; + MultiByteToWideChar(CP_UTF8, 0, path.c_str(), -1, wpath, 1100); + MultiByteToWideChar(CP_UTF8, 0, cmd.c_str(), -1, wcmd, 1200); + STARTUPINFOW si = {}; + si.cb = sizeof si; + PROCESS_INFORMATION pi; + // (started on its own, not waited for: this process ends now, so nothing keeps the old files open) + if (CreateProcessW(wpath, wcmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) { + CloseHandle(pi.hThread), CloseHandle(pi.hProcess); + end_process(); + } + fprintf(stderr, "[update] can't start %s (%lu)\n", path.c_str(), GetLastError()); +#else + std::string path = upd_join(dir, appimage_name); + pid_t pid = fork(); + if (pid == 0) { + setsid(); + // (the new AppImage's runtime sets its own; these name the old one's mount) + unsetenv("APPIMAGE"), unsetenv("APPDIR"), unsetenv("ARGV0"); + if (const char *owd = getenv("OWD")) { if (chdir(owd) != 0) {} } + unsetenv("OWD"); + execl(path.c_str(), path.c_str(), (char *)NULL); + _exit(127); + } + if (pid > 0) end_process(); + fprintf(stderr, "[update] can't start %s: %s\n", path.c_str(), strerror(errno)); +#endif +} + +void update_restart(void) { + pthread_mutex_lock(&g_lock); + bool done = g_state == UPDATE_DONE; + pthread_mutex_unlock(&g_lock); + if (done) restart_app(g_dir, g_name); +} +#endif diff --git a/runtime/update.h b/runtime/update.h new file mode 100644 index 000000000..9e441acc0 --- /dev/null +++ b/runtime/update.h @@ -0,0 +1,55 @@ +// Self-update for the Windows zip (x64 and ARM64) and the Linux AppImage (runtime/update.cpp, the core in +// update_core.h). The start screen's update dialog (runtime/ui/launcher.mm) runs it; macOS uses Sparkle instead +// (runtime/ui/sparkle.mm), Android and iOS have only the Download button. +// +// Update: the platform's signed manifest (update-.txt on the release page) is fetched and checked, the file +// downloaded and checked against it, the zip unpacked and every file checked, the app's files swapped (only the ones +// the manifest lists: on Windows the data folder is the exe's folder by default, and saves, seeds, settings and the +// game files there are never touched), and the app started again. Anything failing leaves the app as it was, and +// the dialog's Download button (the release page) always works. +// +// Test switches (docs/debug-hooks.md): +// LARECOMP_UPDATE_URL where releases are instead of GitHub's download URL: // (http://127.0.0.1:..., +// file:///...) +// LARECOMP_UPDATE_KEY the public key (64 hex) manifests are checked with; only with LARECOMP_UPDATE_URL +// LARECOMP_UPDATE_APP Windows: the app folder to update (default: the exe's); Linux: $APPIMAGE stands for it +// LARECOMP_UPDATE_NO_RESTART=1 quit after the swap instead of starting the new version +#pragma once +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// The platforms that update themselves (others: Download only) +// (LARECOMP_SELF_UPDATE_TEST: tools/test_update_e2e.sh builds the AppImage path on any POSIX desktop) +#if defined(_WIN32) || (defined(__linux__) && !defined(__ANDROID__)) || defined(LARECOMP_SELF_UPDATE_TEST) +#define LARECOMP_SELF_UPDATE 1 +#else +#define LARECOMP_SELF_UPDATE 0 +#endif + +// main(), first thing after plat_init: finishes or undoes an update. A swap that was cut off, or a new version that +// started before and never reached the start screen, gets the old files back and the old version started (no return). +void update_boot(void); +// The start screen is up: an update that got this far is kept (the old files go). +void update_reached_start_screen(void); + +// Whether Update can work here: 1 yes; 0 no (why: a short reason for the log - not this kind of build, the app's +// folder isn't writable, not run as an AppImage). +int update_available(const char **why); + +// Starts the update in the background. tag: the release's tag, or "nightly" (then the manifest's version must be a +// nightly newer than min_nightly_stamp); platform: LARECOMP_PLATFORM. +void update_start(const char *tag, const char *platform, long long min_nightly_stamp); +void update_cancel(void); // (while downloading) +enum { UPDATE_IDLE, UPDATE_RUNNING, UPDATE_FAILED, UPDATE_DONE }; +// state; *frac the download's share done (-1: unknown); msg: what it's doing, or why it failed (English, short) +int update_status(double *frac, char *msg, int n); +// UPDATE_DONE: starts the new version and ends this process (returns only if the restart failed) +void update_restart(void); + +#ifdef __cplusplus +} +#endif diff --git a/runtime/update_crypto.c b/runtime/update_crypto.c new file mode 100644 index 000000000..26064d657 --- /dev/null +++ b/runtime/update_crypto.c @@ -0,0 +1,12 @@ +// Ed25519 for the self-updater's signed manifests (runtime/update_core.h): Monocypher 4.0.2, used under its CC0 +// licence (third_party/monocypher/LICENCE.md). Only the desktops that update themselves need it. Two files, as +// Monocypher's two (each has static helpers of the same name): this one and update_crypto_ed25519.c. +#include "update.h" +#if LARECOMP_SELF_UPDATE +#if defined(__clang__) +#pragma clang diagnostic ignored "-Weverything" +#elif defined(__GNUC__) +#pragma GCC diagnostic ignored "-Wall" +#endif +#include "../third_party/monocypher/monocypher.c" +#endif diff --git a/runtime/update_crypto_ed25519.c b/runtime/update_crypto_ed25519.c new file mode 100644 index 000000000..aef907d00 --- /dev/null +++ b/runtime/update_crypto_ed25519.c @@ -0,0 +1,10 @@ +// Ed25519 (SHA-512 based, as Sparkle and OpenSSL use it) for the self-updater: see update_crypto.c. +#include "update.h" +#if LARECOMP_SELF_UPDATE +#if defined(__clang__) +#pragma clang diagnostic ignored "-Weverything" +#elif defined(__GNUC__) +#pragma GCC diagnostic ignored "-Wall" +#endif +#include "../third_party/monocypher/monocypher-ed25519.c" +#endif diff --git a/tools/test_update_e2e.cpp b/tools/test_update_e2e.cpp new file mode 100644 index 000000000..fda679742 --- /dev/null +++ b/tools/test_update_e2e.cpp @@ -0,0 +1,60 @@ +// The self-updater's AppImage path end to end (runtime/update.cpp, built with LARECOMP_SELF_UPDATE_TEST), driven by +// tools/test_update_e2e.sh against a local web server: fetch the manifest, check it, download, check, swap, restart, +// first start, keep or roll back. This file stands in for the platform layer (curl as a child process, the exe path). +// Usage: test-update-e2e start [restart] | boot | commit | available +// (TEST_VERSION: the version this "build" is; APPIMAGE: the file it updates) +#include +#include +#include +#include +#include +#include +#include + +#include "platform.h" +#include "update.h" + +extern char **environ; +extern "C" { +const char *larecomp_version(void) { return getenv("TEST_VERSION") ? getenv("TEST_VERSION") : "v1"; } +PlatProc plat_spawn(const char *const argv[], const char *log_path, bool append_log) { + (void)log_path, (void)append_log; + pid_t pid; + return posix_spawn(&pid, argv[0], NULL, NULL, (char *const *)argv, environ) == 0 ? (PlatProc)pid : 0; +} +int plat_proc_wait(PlatProc p, bool block) { + int st; + if (waitpid((pid_t)p, &st, block ? 0 : WNOHANG) <= 0) return -1; + return WIFEXITED(st) ? WEXITSTATUS(st) : PLAT_PROC_SIGNALED + WTERMSIG(st); +} +void plat_proc_kill(PlatProc p) { kill((pid_t)p, SIGTERM); } +bool plat_exe_path(char *buf, size_t size) { return snprintf(buf, size, "/nonexistent") > 0; } +#ifdef __linux__ +void plat_terminate(void) { _exit(0); } +#endif +} + +int main(int argc, char **argv) { + const char *cmd = argc > 1 ? argv[1] : ""; + if (!strcmp(cmd, "available")) { + const char *why = ""; + int a = update_available(&why); + printf("available %d %s\n", a, a ? "" : why); + return a ? 0 : 1; + } + if (!strcmp(cmd, "boot")) { update_boot(); printf("boot: continued\n"); return 0; } + if (!strcmp(cmd, "commit")) { update_reached_start_screen(); printf("committed\n"); return 0; } + if (!strcmp(cmd, "start") && argc >= 5) { + update_start(argv[2], argv[3], atoll(argv[4])); + char msg[256]; + double frac; + int st; + while ((st = update_status(&frac, msg, sizeof msg)) == UPDATE_RUNNING) usleep(20000); + printf("%s: %s\n", st == UPDATE_DONE ? "done" : "failed", msg); + fflush(stdout); + if (st == UPDATE_DONE && argc > 5 && !strcmp(argv[5], "restart")) update_restart(); + return st == UPDATE_DONE ? 0 : 1; + } + fprintf(stderr, "usage: see the top of tools/test_update_e2e.cpp\n"); + return 2; +} diff --git a/tools/test_update_e2e.sh b/tools/test_update_e2e.sh new file mode 100755 index 000000000..050e836cd --- /dev/null +++ b/tools/test_update_e2e.sh @@ -0,0 +1,107 @@ +#!/bin/bash +# The self-updater end to end on its AppImage path (runtime/update.cpp), on macOS or Linux, with no network beyond +# this machine: a throwaway signing key, a local web server (python3 -m http.server) holding a signed manifest and a +# fake AppImage (a shell script), and tools/test_update_e2e.cpp standing in for the app. Covers: an update and its +# restart, the first start and the start screen keeping it, a new version that never gets there (rolled back), and +# the failures that must leave the app as it was: bad signature, truncated or damaged download, a manifest for +# another platform or an older nightly, no manifest, a folder that can't be written. +# Usage: tools/test_update_e2e.sh (from anywhere; prints "all passed" and exits 0) +set -uo pipefail +cd "$(dirname "$0")/.." +ROOT=$(pwd) +T=$(mktemp -d "${TMPDIR:-/tmp}/lasrecomp-e2e.XXXXXX") +PORT=$((20000 + RANDOM % 20000)) +SERVER= +cleanup() { [ -n "$SERVER" ] && kill "$SERVER" 2>/dev/null; chmod -R u+w "$T" 2>/dev/null; rm -rf "$T"; } +trap cleanup EXIT +fails=0 +check() { if eval "$2"; then echo "ok $1"; else echo "FAIL $1"; fails=$((fails + 1)); fi; } + +CXX=${CXX:-clang++} +CC=${CC:-clang} +mkdir -p "$T/obj" +$CXX -std=c++17 -O1 -Iruntime -o "$T/update_sign" tools/update_sign.cpp || exit 1 +for f in update_crypto update_crypto_ed25519; do + $CC -O1 -DLARECOMP_SELF_UPDATE_TEST -Iruntime -c runtime/$f.c -o "$T/obj/$f.o" || exit 1 +done +$CXX -std=c++17 -O1 -DLARECOMP_SELF_UPDATE_TEST -Iruntime -Iruntime/nvn -o "$T/app" tools/test_update_e2e.cpp \ + runtime/update.cpp "$T/obj/update_crypto.o" "$T/obj/update_crypto_ed25519.o" -lpthread || exit 1 +"$T/update_sign" keygen "$T/key" > "$T/pub" || exit 1 +export UPDATE_SIGNING_KEY=$(cat "$T/key") +export LARECOMP_UPDATE_KEY=$(awk '/^public /{print $2}' "$T/pub") +export LARECOMP_UPDATE_URL=http://127.0.0.1:$PORT +export LARECOMP_UPDATE_NO_RESTART=1 +PLAT=linux-x86_64 +NEW=nightly-202611171000-abc1234 + +# the "AppImages": scripts that say which version they are (and leave a mark when started) +appimage() { printf '#!/bin/sh\necho %s > "%s/started"\n' "$1" "$T"; } +mkdir -p "$T/srv/nightly" "$T/app1" +appimage v2 > "$T/srv/nightly/LAS.Recomp-$NEW-$PLAT.AppImage" +manifest() { # -> srv/nightly/update-.txt + "$T/update_sign" manifest "$1" "$2" "$T/srv/nightly/LAS.Recomp-$NEW-$PLAT.AppImage" > "$T/srv/nightly/update-$2.txt" +} +manifest "$NEW" "$PLAT" +(cd "$T/srv" && exec python3 -m http.server "$PORT" --bind 127.0.0.1 >/dev/null 2>&1) & +SERVER=$! +for _ in $(seq 50); do curl -fs "http://127.0.0.1:$PORT/nightly/update-$PLAT.txt" >/dev/null && break; sleep 0.1; done + +fresh() { rm -rf "$T/app1"; mkdir -p "$T/app1"; appimage v1 > "$T/app1/LAS.AppImage"; chmod 755 "$T/app1/LAS.AppImage"; rm -f "$T/started"; } +export APPIMAGE=$T/app1/LAS.AppImage +is_v1() { grep -q 'echo v1' "$APPIMAGE"; } +is_v2() { grep -q 'echo v2' "$APPIMAGE"; } +app() { TEST_VERSION=${V:-nightly-202611151000-0000000} "$T/app" "$@" > "$T/out" 2>&1; } + +# an update, its restart into the new file, the first start, the start screen +fresh +check "update available" 'app available' +check "update installs" 'app start nightly $PLAT 202611151000 && grep -q "^done" "$T/out"' +check "new AppImage in place, executable" 'is_v2 && [ -x "$APPIMAGE" ]' +check "old AppImage kept" '[ -f "$T/app1/.lasrecomp-update/old/LAS.AppImage" ]' +check "first start of the new version" 'V=$NEW app boot && grep -q "first start" "$T/out"' +check "start screen keeps it, old gone" 'V=$NEW app commit && is_v2 && [ ! -e "$T/app1/.lasrecomp-update" ]' +fresh +unset LARECOMP_UPDATE_NO_RESTART +check "restart starts the new file" 'app start nightly $PLAT 202611151000 restart; sleep 0.5; [ "$(cat "$T/started" 2>/dev/null)" = v2 ]' +export LARECOMP_UPDATE_NO_RESTART=1 +# the new version starts once and never reaches the start screen: the next start puts the old one back +fresh +app start nightly $PLAT 202611151000 +V=$NEW app boot +check "never reached the start screen: rolled back" 'V=$NEW app boot; grep -q "previous version is back" "$T/out" && is_v1 && [ ! -e "$T/app1/.lasrecomp-update" ]' + +# failures: nothing changes, nothing left behind +fails_clean() { ! app "$@" && grep -q "^failed" "$T/out" && is_v1 && [ ! -e "$T/app1/.lasrecomp-update" ]; } +fresh +check "older nightly refused" 'fails_clean start nightly $PLAT 202611180000' +check "same nightly refused" 'fails_clean start nightly $PLAT 202611171000' +check "no manifest for the platform" 'fails_clean start nightly linux-aarch64 202611151000' +cp "$T/srv/nightly/update-$PLAT.txt" "$T/srv/nightly/update-linux-aarch64.txt" +check "manifest for another platform" 'fails_clean start nightly linux-aarch64 202611151000 && grep -q "another platform" "$T/out"' +check "a release tag gets no nightly" 'fails_clean start v0.7.0 $PLAT 0' +mkdir -p "$T/srv/v0.7.0" && cp "$T/srv/nightly/"* "$T/srv/v0.7.0/" +check "a release whose manifest names another version" 'fails_clean start v0.7.0 $PLAT 0 && grep -q "another version" "$T/out"' +cp "$T/srv/nightly/update-$PLAT.txt" "$T/good" +sed 's/^version .*/version nightly-202611171001-abc1234/' "$T/good" > "$T/srv/nightly/update-$PLAT.txt" +check "changed manifest (bad signature)" 'fails_clean start nightly $PLAT 202611151000 && grep -q "signature does not match" "$T/out"' +LARECOMP_UPDATE_KEY=$(printf '%064d' 1) check "another key" 'fails_clean start nightly $PLAT 202611151000' +cp "$T/good" "$T/srv/nightly/update-$PLAT.txt" +cp "$T/srv/nightly/LAS.Recomp-$NEW-$PLAT.AppImage" "$T/full" +head -c 20 "$T/full" > "$T/srv/nightly/LAS.Recomp-$NEW-$PLAT.AppImage" +check "truncated download" 'fails_clean start nightly $PLAT 202611151000 && grep -q "damaged" "$T/out"' +sed 's/v2/v3/' "$T/full" > "$T/srv/nightly/LAS.Recomp-$NEW-$PLAT.AppImage" +check "damaged download (same size)" 'fails_clean start nightly $PLAT 202611151000 && grep -q "damaged" "$T/out"' +rm "$T/srv/nightly/LAS.Recomp-$NEW-$PLAT.AppImage" +check "download missing" 'fails_clean start nightly $PLAT 202611151000' +cp "$T/full" "$T/srv/nightly/LAS.Recomp-$NEW-$PLAT.AppImage" +if [ "$(id -u)" != 0 ]; then + chmod 555 "$T/app1" + check "read-only folder: Update off" '! app available && grep -q "writable" "$T/out"' + check "read-only folder: refused, unchanged" '! app start nightly $PLAT 202611151000 && is_v1' + chmod 755 "$T/app1" +fi +unset APPIMAGE +check "not an AppImage: Update off" '! app available && grep -q "AppImage" "$T/out"' + +[ $fails = 0 ] && echo "all passed" || echo "$fails FAILED" +exit $((fails != 0)) From fda2470fb2e39afc250bbe7a40802fe74dc26040 Mon Sep 17 00:00:00 2001 From: Peiikai <339721950+peiikai@users.noreply.github.com> Date: Sun, 15 Nov 2026 18:16:41 -0600 Subject: [PATCH 3/8] Start screen: update dialog with the changelog The update link looks as before; clicking it opens a dialog with what's new since this build: the notes of every release skipped (without the warning banner, "Built from" line and sha256 table), or for nightlies the Changes rounds newer than this build. Buttons: Update (Windows and Linux nightlies for now; release builds get it with LARECOMP_UPDATE_RELEASES), Download (the release page, always there) and Back. Phones and tablets: Download only. Test hooks LARECOMP_UPDATE_JSON / LARECOMP_UPDATE_OPEN; changelog tests in tools/test_update_tags.cpp. New strings translated in every table. Co-Authored-By: Claude Opus 5.5 --- docs/debug-hooks.md | 6 ++ runtime/ui/lang/de.inc | 10 ++ runtime/ui/lang/es.inc | 10 ++ runtime/ui/lang/fr.inc | 10 ++ runtime/ui/lang/it.inc | 10 ++ runtime/ui/lang/ja.inc | 10 ++ runtime/ui/lang/ko.inc | 10 ++ runtime/ui/lang/nl.inc | 10 ++ runtime/ui/lang/pt-BR.inc | 10 ++ runtime/ui/lang/ru.inc | 10 ++ runtime/ui/lang/zh-Hans.inc | 10 ++ runtime/ui/lang/zh-Hant.inc | 10 ++ runtime/ui/launcher.mm | 162 +++++++++++++++++++++++++++- runtime/ui/update_notes.h | 204 ++++++++++++++++++++++++++++++++++++ tools/test_update_tags.cpp | 59 ++++++++++- 15 files changed, 535 insertions(+), 6 deletions(-) create mode 100644 runtime/ui/update_notes.h diff --git a/docs/debug-hooks.md b/docs/debug-hooks.md index 2706b2f1d..2f24fe864 100644 --- a/docs/debug-hooks.md +++ b/docs/debug-hooks.md @@ -154,6 +154,12 @@ Use it with `LARECOMP_INPUT` (to get into a save) and `LARECOMP_SAVE_DIR` (so th | `LARECOMP_MENU_BAR` | entry number | Open the menu bar alone, its cursor on that entry: `0` Settings, `1` Cosmetics, `2` Randomizer, `3` Warp, `4` Save Editor, `5` Cheats, `6` Reset, `7` Quit, `8` the close button. | | `LARECOMP_TOUCH_SHOW_INPUT` | 0 / 1 | iPhone, iPad and Android: show scripted input (`LARECOMP_INPUT`) on the touch controls, the buttons lit and the stick moved. | | `LARECOMP_UPDATE_TAGS` | `tag,tag,...` | The update check sees these release tags instead of asking GitHub (no network). | +| `LARECOMP_UPDATE_JSON` | file | The update check reads this saved releases list instead of asking GitHub (the update dialog's changelog too). | +| `LARECOMP_UPDATE_OPEN` | `1` / `update` | The update dialog opens as soon as the update check finds one; `update` also presses Update. | +| `LARECOMP_UPDATE_URL` | URL | Update downloads `//update-.txt` and the file it names from here instead of GitHub (`http://127.0.0.1:...`, `file:///...`). | +| `LARECOMP_UPDATE_KEY` | 64 hex | With `LARECOMP_UPDATE_URL`: the public key manifests are checked with (a test key; `tools/update_sign.cpp keygen`). | +| `LARECOMP_UPDATE_APP` | folder | Windows: the app folder Update replaces files in (default: the exe's). Linux updates `$APPIMAGE`. | +| `LARECOMP_UPDATE_NO_RESTART` | `1` | After Update installs (or rolls back), quit instead of starting the app again. | | `LARECOMP_FONT` | font file | Use this file for the system fonts the game asks for (.ttf, .otf, .ttc, .bfttf). | ## Logging and diagnostics diff --git a/runtime/ui/lang/de.inc b/runtime/ui/lang/de.inc index 60c5acdcd..392a5fb5e 100644 --- a/runtime/ui/lang/de.inc +++ b/runtime/ui/lang/de.inc @@ -2147,3 +2147,13 @@ {"Dynamic resolution", "Dynamische Auflösung"}, {"Raises and lowers the resolution as needed to hold your FPS target, up to your screen's resolution. The Resolution setting is set aside while it's on.", "Hebt und senkt die Auflösung nach Bedarf, um deine Ziel-FPS zu halten, bis zur Auflösung deines Bildschirms. Die Einstellung „Auflösung“ ruht, solange es an ist."}, {"Does nothing unless the game renders below your screen's resolution: a lower Resolution, or Dynamic resolution.", "Wirkt nur, wenn das Spiel unter der Auflösung deines Bildschirms rendert: bei einer niedrigeren Auflösung oder mit dynamischer Auflösung."}, +{"Checking the update", "Update wird geprüft"}, +{"Downloading", "Wird heruntergeladen"}, +{"Checking the download", "Download wird geprüft"}, +{"Unpacking", "Wird entpackt"}, +{"Installing", "Wird installiert"}, +{"No details for this update.", "Keine Details zu diesem Update."}, +{"Update available", "Update verfügbar"}, +{"Update can't change the app's files here. Use Download.", "Update kann die Dateien der App hier nicht ändern. Nutze Herunterladen."}, +{"Update", "Aktualisieren"}, +{"Download", "Herunterladen"}, diff --git a/runtime/ui/lang/es.inc b/runtime/ui/lang/es.inc index fe37e4514..ae0bef743 100644 --- a/runtime/ui/lang/es.inc +++ b/runtime/ui/lang/es.inc @@ -2147,3 +2147,13 @@ {"Dynamic resolution", "Resolución dinámica"}, {"Raises and lowers the resolution as needed to hold your FPS target, up to your screen's resolution. The Resolution setting is set aside while it's on.", "Sube y baja la resolución según haga falta para mantener tus FPS objetivo, hasta la resolución de tu pantalla. El ajuste Resolución queda en pausa mientras está activada."}, {"Does nothing unless the game renders below your screen's resolution: a lower Resolution, or Dynamic resolution.", "Solo tiene efecto si el juego se renderiza por debajo de la resolución de tu pantalla: una Resolución más baja o la Resolución dinámica."}, +{"Checking the update", "Comprobando la actualización"}, +{"Downloading", "Descargando"}, +{"Checking the download", "Comprobando la descarga"}, +{"Unpacking", "Descomprimiendo"}, +{"Installing", "Instalando"}, +{"No details for this update.", "No hay detalles de esta actualización."}, +{"Update available", "Actualización disponible"}, +{"Update can't change the app's files here. Use Download.", "Actualizar no puede cambiar aquí los archivos de la app. Usa Descargar."}, +{"Update", "Actualizar"}, +{"Download", "Descargar"}, diff --git a/runtime/ui/lang/fr.inc b/runtime/ui/lang/fr.inc index 2dcb0d93d..0df49c403 100644 --- a/runtime/ui/lang/fr.inc +++ b/runtime/ui/lang/fr.inc @@ -2147,3 +2147,13 @@ {"Dynamic resolution", "Résolution dynamique"}, {"Raises and lowers the resolution as needed to hold your FPS target, up to your screen's resolution. The Resolution setting is set aside while it's on.", "Monte et baisse la résolution selon les besoins pour tenir tes FPS cibles, jusqu'à la résolution de ton écran. Le réglage Résolution est mis de côté tant que c'est activé."}, {"Does nothing unless the game renders below your screen's resolution: a lower Resolution, or Dynamic resolution.", "Sans effet sauf si le jeu est rendu sous la résolution de ton écran : une Résolution plus basse, ou la Résolution dynamique."}, +{"Checking the update", "Vérification de la mise à jour"}, +{"Downloading", "Téléchargement"}, +{"Checking the download", "Vérification du téléchargement"}, +{"Unpacking", "Décompression"}, +{"Installing", "Installation"}, +{"No details for this update.", "Aucun détail pour cette mise à jour."}, +{"Update available", "Mise à jour disponible"}, +{"Update can't change the app's files here. Use Download.", "Mettre à jour ne peut pas modifier les fichiers de l'app ici. Utilise Télécharger."}, +{"Update", "Mettre à jour"}, +{"Download", "Télécharger"}, diff --git a/runtime/ui/lang/it.inc b/runtime/ui/lang/it.inc index 5527dc096..e9e65eb2b 100644 --- a/runtime/ui/lang/it.inc +++ b/runtime/ui/lang/it.inc @@ -2147,3 +2147,13 @@ {"Dynamic resolution", "Risoluzione dinamica"}, {"Raises and lowers the resolution as needed to hold your FPS target, up to your screen's resolution. The Resolution setting is set aside while it's on.", "Alza e abbassa la risoluzione quanto serve per mantenere i tuoi FPS obiettivo, fino alla risoluzione del tuo schermo. L'impostazione Risoluzione viene messa da parte mentre è attiva."}, {"Does nothing unless the game renders below your screen's resolution: a lower Resolution, or Dynamic resolution.", "Non ha effetto a meno che il gioco non venga renderizzato sotto la risoluzione del tuo schermo: una Risoluzione più bassa o la Risoluzione dinamica."}, +{"Checking the update", "Verifica dell'aggiornamento"}, +{"Downloading", "Download in corso"}, +{"Checking the download", "Verifica del download"}, +{"Unpacking", "Estrazione"}, +{"Installing", "Installazione"}, +{"No details for this update.", "Nessun dettaglio per questo aggiornamento."}, +{"Update available", "Aggiornamento disponibile"}, +{"Update can't change the app's files here. Use Download.", "Aggiorna non può modificare qui i file dell'app. Usa Scarica."}, +{"Update", "Aggiorna"}, +{"Download", "Scarica"}, diff --git a/runtime/ui/lang/ja.inc b/runtime/ui/lang/ja.inc index f6d3366f3..533ffc57d 100644 --- a/runtime/ui/lang/ja.inc +++ b/runtime/ui/lang/ja.inc @@ -2147,3 +2147,13 @@ {"Dynamic resolution", "可変解像度"}, {"Raises and lowers the resolution as needed to hold your FPS target, up to your screen's resolution. The Resolution setting is set aside while it's on.", "目標FPSを保てるよう、必要に応じて解像度を上げ下げします(最大で画面の解像度まで)。オンの間は「解像度」の設定は使われません。"}, {"Does nothing unless the game renders below your screen's resolution: a lower Resolution, or Dynamic resolution.", "ゲームが画面の解像度より低く描画されるとき(低い「解像度」か「可変解像度」)だけ効果があります。"}, +{"Checking the update", "アップデートを確認中"}, +{"Downloading", "ダウンロード中"}, +{"Checking the download", "ダウンロードを確認中"}, +{"Unpacking", "展開中"}, +{"Installing", "インストール中"}, +{"No details for this update.", "このアップデートの詳細はありません。"}, +{"Update available", "アップデートがあります"}, +{"Update can't change the app's files here. Use Download.", "ここではアップデートでアプリのファイルを変更できません。ダウンロードを使ってください。"}, +{"Update", "アップデート"}, +{"Download", "ダウンロード"}, diff --git a/runtime/ui/lang/ko.inc b/runtime/ui/lang/ko.inc index 98006d04c..04eff6e78 100644 --- a/runtime/ui/lang/ko.inc +++ b/runtime/ui/lang/ko.inc @@ -2147,3 +2147,13 @@ {"Dynamic resolution", "동적 해상도"}, {"Raises and lowers the resolution as needed to hold your FPS target, up to your screen's resolution. The Resolution setting is set aside while it's on.", "목표 FPS를 유지하도록 필요에 따라 해상도를 올리고 내립니다(최대 화면 해상도까지). 켜져 있는 동안 '해상도' 설정은 쓰이지 않습니다."}, {"Does nothing unless the game renders below your screen's resolution: a lower Resolution, or Dynamic resolution.", "게임이 화면 해상도보다 낮게 렌더링될 때(낮은 '해상도' 또는 '동적 해상도')만 효과가 있습니다."}, +{"Checking the update", "업데이트 확인 중"}, +{"Downloading", "다운로드 중"}, +{"Checking the download", "다운로드 확인 중"}, +{"Unpacking", "압축 해제 중"}, +{"Installing", "설치 중"}, +{"No details for this update.", "이 업데이트에 대한 정보가 없습니다."}, +{"Update available", "업데이트 가능"}, +{"Update can't change the app's files here. Use Download.", "여기서는 업데이트로 앱 파일을 바꿀 수 없습니다. 다운로드를 사용하세요."}, +{"Update", "업데이트"}, +{"Download", "다운로드"}, diff --git a/runtime/ui/lang/nl.inc b/runtime/ui/lang/nl.inc index db379ba53..f2241747a 100644 --- a/runtime/ui/lang/nl.inc +++ b/runtime/ui/lang/nl.inc @@ -2147,3 +2147,13 @@ {"Dynamic resolution", "Dynamische resolutie"}, {"Raises and lowers the resolution as needed to hold your FPS target, up to your screen's resolution. The Resolution setting is set aside while it's on.", "Verhoogt en verlaagt de resolutie waar nodig om je FPS-doel te halen, tot de resolutie van je scherm. De instelling Resolutie wordt genegeerd zolang dit aan staat."}, {"Does nothing unless the game renders below your screen's resolution: a lower Resolution, or Dynamic resolution.", "Doet alleen iets als het spel onder de resolutie van je scherm rendert: een lagere Resolutie, of Dynamische resolutie."}, +{"Checking the update", "Update controleren"}, +{"Downloading", "Downloaden"}, +{"Checking the download", "Download controleren"}, +{"Unpacking", "Uitpakken"}, +{"Installing", "Installeren"}, +{"No details for this update.", "Geen details voor deze update."}, +{"Update available", "Update beschikbaar"}, +{"Update can't change the app's files here. Use Download.", "Bijwerken kan de bestanden van de app hier niet wijzigen. Gebruik Downloaden."}, +{"Update", "Bijwerken"}, +{"Download", "Downloaden"}, diff --git a/runtime/ui/lang/pt-BR.inc b/runtime/ui/lang/pt-BR.inc index b8b434d81..d34343597 100644 --- a/runtime/ui/lang/pt-BR.inc +++ b/runtime/ui/lang/pt-BR.inc @@ -2147,3 +2147,13 @@ {"Dynamic resolution", "Resolução dinâmica"}, {"Raises and lowers the resolution as needed to hold your FPS target, up to your screen's resolution. The Resolution setting is set aside while it's on.", "Aumenta e reduz a resolução conforme necessário para manter sua meta de FPS, até a resolução da sua tela. A opção Resolução fica de lado enquanto estiver ligado."}, {"Does nothing unless the game renders below your screen's resolution: a lower Resolution, or Dynamic resolution.", "Só tem efeito quando o jogo renderiza abaixo da resolução da sua tela: uma Resolução menor ou a Resolução dinâmica."}, +{"Checking the update", "Verificando a atualização"}, +{"Downloading", "Baixando"}, +{"Checking the download", "Verificando o download"}, +{"Unpacking", "Descompactando"}, +{"Installing", "Instalando"}, +{"No details for this update.", "Sem detalhes para esta atualização."}, +{"Update available", "Atualização disponível"}, +{"Update can't change the app's files here. Use Download.", "Atualizar não pode alterar os arquivos do app aqui. Use Baixar."}, +{"Update", "Atualizar"}, +{"Download", "Baixar"}, diff --git a/runtime/ui/lang/ru.inc b/runtime/ui/lang/ru.inc index 64bae57be..ff600a246 100644 --- a/runtime/ui/lang/ru.inc +++ b/runtime/ui/lang/ru.inc @@ -2147,3 +2147,13 @@ {"Dynamic resolution", "Динамическое разрешение"}, {"Raises and lowers the resolution as needed to hold your FPS target, up to your screen's resolution. The Resolution setting is set aside while it's on.", "Повышает и понижает разрешение по мере необходимости, чтобы держать целевой FPS, вплоть до разрешения экрана. Пока включено, настройка «Разрешение» не используется."}, {"Does nothing unless the game renders below your screen's resolution: a lower Resolution, or Dynamic resolution.", "Действует, только если игра рендерится ниже разрешения экрана: при меньшем «Разрешении» или с «Динамическим разрешением»."}, +{"Checking the update", "Проверка обновления"}, +{"Downloading", "Загрузка"}, +{"Checking the download", "Проверка загрузки"}, +{"Unpacking", "Распаковка"}, +{"Installing", "Установка"}, +{"No details for this update.", "Нет сведений об этом обновлении."}, +{"Update available", "Доступно обновление"}, +{"Update can't change the app's files here. Use Download.", "Обновить не может изменить файлы приложения здесь. Используйте Скачать."}, +{"Update", "Обновить"}, +{"Download", "Скачать"}, diff --git a/runtime/ui/lang/zh-Hans.inc b/runtime/ui/lang/zh-Hans.inc index c77efb838..5ecca24e9 100644 --- a/runtime/ui/lang/zh-Hans.inc +++ b/runtime/ui/lang/zh-Hans.inc @@ -2147,3 +2147,13 @@ {"Dynamic resolution", "动态分辨率"}, {"Raises and lowers the resolution as needed to hold your FPS target, up to your screen's resolution. The Resolution setting is set aside while it's on.", "按需升降分辨率以保持目标帧率,最高到屏幕的分辨率。开启时不使用“分辨率”设置。"}, {"Does nothing unless the game renders below your screen's resolution: a lower Resolution, or Dynamic resolution.", "只有在游戏以低于屏幕的分辨率渲染时才有作用:较低的“分辨率”或“动态分辨率”。"}, +{"Checking the update", "正在检查更新"}, +{"Downloading", "正在下载"}, +{"Checking the download", "正在检查下载"}, +{"Unpacking", "正在解压"}, +{"Installing", "正在安装"}, +{"No details for this update.", "此更新没有详细信息。"}, +{"Update available", "有可用更新"}, +{"Update can't change the app's files here. Use Download.", "此处无法通过更新修改应用文件。请使用下载。"}, +{"Update", "更新"}, +{"Download", "下载"}, diff --git a/runtime/ui/lang/zh-Hant.inc b/runtime/ui/lang/zh-Hant.inc index e7e2225f5..11c560d56 100644 --- a/runtime/ui/lang/zh-Hant.inc +++ b/runtime/ui/lang/zh-Hant.inc @@ -2147,3 +2147,13 @@ {"Dynamic resolution", "動態解析度"}, {"Raises and lowers the resolution as needed to hold your FPS target, up to your screen's resolution. The Resolution setting is set aside while it's on.", "依需要升降解析度以維持目標影格率,最高到螢幕的解析度。開啟時不使用「解析度」設定。"}, {"Does nothing unless the game renders below your screen's resolution: a lower Resolution, or Dynamic resolution.", "只有在遊戲以低於螢幕的解析度繪製時才有作用:較低的「解析度」或「動態解析度」。"}, +{"Checking the update", "正在檢查更新"}, +{"Downloading", "正在下載"}, +{"Checking the download", "正在檢查下載"}, +{"Unpacking", "正在解壓縮"}, +{"Installing", "正在安裝"}, +{"No details for this update.", "此更新沒有詳細資訊。"}, +{"Update available", "有可用更新"}, +{"Update can't change the app's files here. Use Download.", "此處無法透過更新修改應用程式檔案。請使用下載。"}, +{"Update", "更新"}, +{"Download", "下載"}, diff --git a/runtime/ui/launcher.mm b/runtime/ui/launcher.mm index 52655c230..17a1b5ce5 100644 --- a/runtime/ui/launcher.mm +++ b/runtime/ui/launcher.mm @@ -125,6 +125,9 @@ static void save_png(id tex, const char *path) { // Nightly builds (.github/workflows/nightly.yml sets this): the build's time (YYYYMMDDHHMM, UTC; 0: not a nightly). // They only look for a newer nightly build of their own platform, never a release or an experimental build. #define LARECOMP_NIGHTLY_STAMP 0LL +// Update in the update dialog (runtime/update.h; macOS: Sparkle): nightlies have it; release builds only once this +// is 1, after it has worked on nightlies for a while on every platform. Until then they offer Download only. +#define LARECOMP_UPDATE_RELEASES 0 // An experimental platform that joins the normal releases: from this release on, its experimental builds offer it // (and any later one) ahead of a newer experimental build. Android ships in Beta 6. #ifdef __ANDROID__ @@ -159,14 +162,23 @@ static void save_png(id tex, const char *path) { #define RELEASES_URL "https://api.github.com/repos/peiikai/LASRecomp/releases?per_page=100" #define RELEASE_PAGE "https://github.com/peiikai/LASRecomp/releases/tag/" -#include "update_tags.h" // tag_rank, tag_label +#include "update_notes.h" // tag_rank, tag_label; the update dialog's changelog +#include "update.h" -static std::string g_update_tag; // a newer release's tag (g_update_lock) +static std::string g_update_tag; // a newer release's tag (g_update_lock) +static std::string g_update_json; // the releases list it came from (the dialog's changelog) static pthread_mutex_t g_update_lock = PTHREAD_MUTEX_INITIALIZER; static void *update_thread(void *) { std::string body; - if (const char *t = getenv("LARECOMP_UPDATE_TAGS")) { // (test) "beta_2,v1.0.0": these releases, no network + if (const char *t = getenv("LARECOMP_UPDATE_JSON")) { // (test) a saved releases list instead of GitHub's + if (FILE *f = fopen(t, "rb")) { + char buf[8192]; + size_t n; + while ((n = fread(buf, 1, sizeof buf, f)) > 0) body.append(buf, n); + fclose(f); + } + } else if (const char *t = getenv("LARECOMP_UPDATE_TAGS")) { // (test) "beta_2,v1.0.0": these releases, no network for (const char *p = t; *p;) { const char *c = strchr(p, ','); std::string t(p, c ? c - p : strlen(p)); // (LAS.Recomp-*: an asset name) @@ -239,6 +251,7 @@ static void save_png(id tex, const char *path) { if (!best.empty()) fprintf(stderr, "[launcher] update available: %s (this build %s)\n", best.c_str(), LARECOMP_VERSION); pthread_mutex_lock(&g_update_lock); g_update_tag = best; + if (!best.empty()) g_update_json.swap(body); pthread_mutex_unlock(&g_update_lock); return NULL; } @@ -1047,6 +1060,132 @@ static void notice_popup(float s) { ImGui::PopFont(); ImGui::EndPopup(); } +// ------------------------------------------------------------------ update dialog +// The start screen's update link opens it: what's new since this build, then Update (this platform updates itself: +// runtime/update.h; macOS: Sparkle), Download (the release page: always there, also if Update ever fails) and Back. +// Phones and tablets: no Update. Release builds: no Update until LARECOMP_UPDATE_RELEASES. +static bool g_update_open; +static std::string g_update_notes, g_update_title; +// (the updater's steps, for the translation tables: runtime/update.cpp sets them in English) +static const char *const UPDATE_STEPS[] = {LN("Checking the update"), LN("Downloading"), LN("Checking the download"), + LN("Unpacking"), LN("Installing")}; +static bool update_button_shown(const std::string &tag) { + (void)UPDATE_STEPS; + if (PLAT_TOUCH || !(LARECOMP_SELF_UPDATE)) return false; + if (!LARECOMP_NIGHTLY_STAMP && !LARECOMP_UPDATE_RELEASES) return false; + return LARECOMP_NIGHTLY_STAMP ? tag == "nightly" : tag_rank(tag) >= 0; +} +static void update_open(const std::string &tag) { + pthread_mutex_lock(&g_update_lock); + std::vector rel = json_releases(g_update_json); + pthread_mutex_unlock(&g_update_lock); + if (tag == "nightly") { + g_update_notes = nightly_changelog(rel, LARECOMP_NIGHTLY_STAMP); + g_update_title = tag_label("nightly", false); + } else { + long long own = strncmp(LARECOMP_VERSION, "test-", 5) ? tag_rank(LARECOMP_VERSION) : tag_rank(LARECOMP_TEST_OF) - 1; + g_update_notes = tag_rank(tag) >= 0 ? release_changelog(rel, own, tag) : ""; + g_update_title = tag_label(tag, false); + } + g_update_open = true; +} +// the changelog: headings in the title colour, list items with a bullet, the rest as paragraphs +static void update_notes_draw(float sc) { + const PlasticTheme &th = plastic_theme(); + if (g_update_notes.empty()) { + ImGui::TextColored(plastic_col(th.text_dim), "%s", L("No details for this update.")); + return; + } + ImGui::PushTextWrapPos(0); + for (size_t at = 0; at <= g_update_notes.size();) { + size_t nl = g_update_notes.find('\n', at); + if (nl == std::string::npos) nl = g_update_notes.size(); + std::string l = g_update_notes.substr(at, nl - at); + at = nl + 1; + size_t h = 0; + while (h < l.size() && l[h] == '#') h++; + if (l.empty()) ImGui::Dummy(ImVec2(0, 6 * sc)); + else if (h && h < l.size() && l[h] == ' ') { + if (h == 1) ImGui::PushFont(g_font_menu); + ImGui::TextColored(plastic_col(th.title), "%s", md_inline(l.substr(h + 1)).c_str()); + if (h == 1) ImGui::PopFont(); + } else if (l.size() > 2 && (l[0] == '-' || l[0] == '*') && l[1] == ' ') { + ImGui::Bullet(); + ImGui::TextUnformatted(md_inline(l.substr(2)).c_str()); + } else ImGui::TextUnformatted(md_inline(l).c_str()); + } + ImGui::PopTextWrapPos(); +} +static void update_dialog(float s) { + float sc = s * 720.0f / 1080.0f; + pthread_mutex_lock(&g_update_lock); + std::string tag = g_update_tag; + pthread_mutex_unlock(&g_update_lock); + if (g_update_open && !ImGui::IsPopupOpen("##update")) ImGui::OpenPopup("##update"); + ImVec2 ds = ImGui::GetIO().DisplaySize; + ImGui::SetNextWindowPos(ImVec2(ds.x * 0.5f, ds.y * 0.5f), ImGuiCond_Always, ImVec2(0.5f, 0.5f)); + ImGui::SetNextWindowSize(ImVec2(fminf(ds.x * 0.9f, 1300 * sc), 0)); + if (!ImGui::BeginPopupModal("##update", NULL, ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | + ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize)) + return; + const PlasticTheme &th = plastic_theme(); + double frac = -1; + char msg[256] = ""; + int st = update_status(&frac, msg, sizeof msg); + bool running = st == UPDATE_RUNNING || st == UPDATE_DONE; + ImGui::PushFont(g_font_small); + ImGui::PushFont(g_font_menu); + ImGui::TextColored(plastic_col(th.title), "%s", L("Update available")); + ImGui::PopFont(); + ImGui::TextColored(plastic_col(th.text_dim), "%s", g_update_title.c_str()); // (the release's name stays English) + ImGui::Spacing(); + ImGui::BeginChild("##notes", ImVec2(0, fminf(ds.y * 0.55f, 900 * sc)), ImGuiChildFlags_FrameStyle); + update_notes_draw(sc); + ImGui::EndChild(); + ImGui::Spacing(); + bool updater = update_button_shown(tag); + const char *why = NULL; + bool can = updater && update_available(&why); + if (updater && !can && st == UPDATE_IDLE) { + static std::string logged; + if (logged != tag) logged = tag, fprintf(stderr, "[launcher] Update off here: %s\n", why ? why : "?"); + ImGui::TextColored(plastic_col(th.text_dim), "%s", L("Update can't change the app's files here. Use Download.")); + } + if (running) { + ImGui::TextUnformatted(st == UPDATE_DONE ? L("Restarting...") : L(msg)); + plastic_progress_bar(st == UPDATE_DONE ? 1.0f : frac < 0 ? 0.0f : (float)frac, ImVec2(-1, 0), NULL, sc); + } else if (st == UPDATE_FAILED) ImGui::TextColored(plastic_col(th.warn), "%s", L(msg)); + ImGui::Spacing(); + bool esc = ImGui::IsKeyPressed(ImGuiKey_GamepadFaceRight, false) || ImGui::IsKeyPressed(ImGuiKey_Escape, false); + ImVec2 bw(300 * sc, 0); + if (running) { + ImGui::BeginDisabled(st == UPDATE_DONE); + if (ImGui::Button(L("Cancel"), bw) || esc) update_cancel(); + ImGui::EndDisabled(); + } else { + if (updater) { + ImGui::BeginDisabled(!can); + ImGui::SetItemDefaultFocus(); + if (ImGui::Button(L("Update"), bw)) { + long long own = LARECOMP_NIGHTLY_STAMP; + update_start(tag.c_str(), LARECOMP_PLATFORM, own); + } + ImGui::EndDisabled(); + ImGui::SameLine(); + } + if (!updater || !can) ImGui::SetItemDefaultFocus(); + if (ImGui::Button(L("Download"), bw)) SDL_OpenURL((RELEASE_PAGE + tag).c_str()); + ImGui::SameLine(); + if (ImGui::Button(L("Back"), bw) || esc) g_update_open = false, ImGui::CloseCurrentPopup(); + } + ImGui::PopFont(); + ImGui::EndPopup(); + if (st == UPDATE_DONE) { // (one frame of "Restarting..." first) + static int frames; + if (++frames > 2) settings_save(), update_restart(); + } +} + // First PLAY ever, before the menu note: authentic 16:9 or the unlocked (fill the window) aspect ratio. static bool aspect_prompt(float s) { bool done = false; @@ -2354,8 +2493,22 @@ static void load_fonts(void) { const char *play_at_env = getenv("LARECOMP_LAUNCHER_PLAY_AT"), *skip_at_env = getenv("LARECOMP_LAUNCHER_SKIP_AT"); uint64_t loop_t0 = SDL_GetTicks(), last_frame = loop_t0, bg_gap = 0, bg_frames = 0; bool bg_logged = false; + update_reached_start_screen(); // (a new version after an update got this far: it's kept. runtime/update.h) + // (test) LARECOMP_UPDATE_OPEN=1: the update dialog opens as soon as the check found one; =update: and Update is + // pressed + const char *upd_open_env = getenv("LARECOMP_UPDATE_OPEN"); for (;;) { uint64_t now = SDL_GetTicks(); + if (upd_open_env && !g_update_open) { + pthread_mutex_lock(&g_update_lock); + std::string t = g_update_tag; + pthread_mutex_unlock(&g_update_lock); + if (!t.empty()) { + update_open(t); + if (!strcmp(upd_open_env, "update") && update_button_shown(t)) update_start(t.c_str(), LARECOMP_PLATFORM, LARECOMP_NIGHTLY_STAMP); + upd_open_env = NULL; + } + } if (g_bg_prep) bg_frames++, bg_gap = std::max(bg_gap, now - last_frame); else if (!bg_logged && bg_frames) { // (how the start screen kept up meanwhile) bg_logged = true; @@ -3124,7 +3277,7 @@ static void load_fonts(void) { dl->AddLine(ImVec2(lp.x, lp.y + lsz.y), ImVec2(lp.x + lsz.x, lp.y + lsz.y), col, 1.5f * s); ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); } - if (click) SDL_OpenURL((RELEASE_PAGE + upd).c_str()); + if (click) update_open(upd); } } ImGui::PopFont(); @@ -3135,6 +3288,7 @@ static void load_fonts(void) { menu_style_begin(ds.y / 1080.0f), plastic_widgets(true), pieces = true; data_folder_popup(s); notice_popup(s); + update_dialog(s); plastic_widgets(false), menu_style_end(); } ImGui::End(); diff --git a/runtime/ui/update_notes.h b/runtime/ui/update_notes.h new file mode 100644 index 000000000..16b4c581d --- /dev/null +++ b/runtime/ui/update_notes.h @@ -0,0 +1,204 @@ +// The update dialog's changelog (runtime/ui/launcher.mm), from the releases JSON the update check already fetched. +// Releases: the notes of every release between this build and the one offered, newest first, without the warning +// banner on top or the "Built from" line and sha256 table at the bottom (release.yml adds those). Nightlies: the +// rounds of the nightly page's "Changes" list newer than this build (nightly.yml writes one per round, each starting +// with a "" line). Test: tools/test_update_tags.cpp (no network). +#pragma once +#include +#include +#include + +#include + +#include +#include + +#include "update_tags.h" + +struct ReleaseInfo { + std::string tag, body; +}; + +// A JSON string starting at s[i] == '"' -> its text (\uXXXX as UTF-8); i ends after the closing quote. false: broken. +static inline bool json_string(const std::string &s, size_t &i, std::string *out) { + if (i >= s.size() || s[i] != '"') return false; + for (i++; i < s.size(); i++) { + char c = s[i]; + if (c == '"') { i++; return true; } + if (c != '\\') { if (out) *out += c; continue; } + if (++i >= s.size()) return false; + char e = s[i]; + if (e == 'u') { + if (i + 4 >= s.size()) return false; + unsigned v = (unsigned)strtoul(s.substr(i + 1, 4).c_str(), NULL, 16); + i += 4; + if (v >= 0xd800 && v < 0xdc00 && i + 6 < s.size() && s[i + 1] == '\\' && s[i + 2] == 'u') { // (a pair) + unsigned lo = (unsigned)strtoul(s.substr(i + 3, 4).c_str(), NULL, 16); + if (lo >= 0xdc00 && lo < 0xe000) v = 0x10000 + ((v - 0xd800) << 10) + (lo - 0xdc00), i += 6; + } + if (!out) continue; + if (v < 0x80) *out += (char)v; + else if (v < 0x800) *out += (char)(0xc0 | v >> 6), *out += (char)(0x80 | (v & 63)); + else if (v < 0x10000) *out += (char)(0xe0 | v >> 12), *out += (char)(0x80 | (v >> 6 & 63)), *out += (char)(0x80 | (v & 63)); + else *out += (char)(0xf0 | v >> 18), *out += (char)(0x80 | (v >> 12 & 63)), *out += (char)(0x80 | (v >> 6 & 63)), *out += (char)(0x80 | (v & 63)); + } else if (out) *out += e == 'n' ? '\n' : e == 't' ? '\t' : e == 'r' ? '\r' : e == 'b' ? '\b' : e == 'f' ? '\f' : e; + } + return false; +} +// Skips one JSON value at s[i] (whitespace first); false: broken +static inline bool json_skip(const std::string &s, size_t &i) { + while (i < s.size() && strchr(" \t\r\n", s[i])) i++; + if (i >= s.size()) return false; + if (s[i] == '"') return json_string(s, i, NULL); + if (s[i] == '{' || s[i] == '[') { + int depth = 0; + for (; i < s.size(); i++) { + if (s[i] == '"') { if (!json_string(s, i, NULL)) return false; i--; continue; } + if (s[i] == '{' || s[i] == '[') depth++; + else if ((s[i] == '}' || s[i] == ']') && --depth == 0) { i++; return true; } + } + return false; + } + while (i < s.size() && !strchr(",}] \t\r\n", s[i])) i++; // (number, true, false, null) + return true; +} +// The releases list (GitHub's /releases: an array of objects): each one's tag_name and body +static inline std::vector json_releases(const std::string &s) { + std::vector out; + size_t i = s.find('['); + if (i == std::string::npos) return out; + for (i++;;) { + while (i < s.size() && strchr(" \t\r\n,", s[i])) i++; + if (i >= s.size() || s[i] != '{') break; + ReleaseInfo r; + for (i++;;) { // the object's keys (nested objects, e.g. author and assets, skipped whole) + while (i < s.size() && strchr(" \t\r\n,", s[i])) i++; + if (i >= s.size()) return out; + if (s[i] == '}') { i++; break; } + std::string key; + if (!json_string(s, i, &key)) return out; + while (i < s.size() && strchr(" \t\r\n:", s[i])) i++; + if ((key == "tag_name" || key == "body") && i < s.size() && s[i] == '"') { + if (!json_string(s, i, key == "tag_name" ? &r.tag : &r.body)) return out; + } else if (!json_skip(s, i)) return out; + } + if (!r.tag.empty()) out.push_back(r); + } + return out; +} + +// A release's notes as the dialog shows them: no warning banner (a leading "> [!WARNING]" quote), nothing from the +// "Built from" line / "---" before it or the sha256 table on, no HTML comments, CRs gone, no blank lines at the ends. +static inline std::string clean_release_notes(std::string b) { + std::string out; + std::vector lines; + for (size_t at = 0; at <= b.size();) { + size_t nl = b.find('\n', at); + if (nl == std::string::npos) nl = b.size(); + std::string l = b.substr(at, nl - at); + if (!l.empty() && l.back() == '\r') l.pop_back(); + lines.push_back(l); + at = nl + 1; + } + size_t i = 0; + while (i < lines.size() && lines[i].empty()) i++; + if (i < lines.size() && !lines[i].compare(0, 4, "> [!")) { // (the banner: the quote's lines) + while (i < lines.size() && !lines[i].compare(0, 1, ">")) i++; + } + size_t end = lines.size(); + for (size_t k = i; k < lines.size(); k++) { + if (!lines[k].compare(0, 11, "Built from ") || !lines[k].compare(0, 9, "| File | ")) { + end = k; + while (end > i && (lines[end - 1].empty() || lines[end - 1] == "---")) end--; + break; + } + } + bool comment = false; + for (size_t k = i; k < end; k++) { + std::string l = lines[k]; + bool had = !l.empty(); + for (size_t c; ;) { // (HTML comments, also across lines) + if (comment) { + size_t e = l.find("-->"); + if (e == std::string::npos) { l.clear(); break; } + l.erase(0, e + 3), comment = false; + } + if ((c = l.find("", c); + if (e == std::string::npos) { l.erase(c), comment = true; break; } + l.erase(c, e + 3 - c); + } + if (l.empty() && had) continue; // (a comment's line) + if (l.empty() && (out.empty() || (out.size() >= 2 && !out.compare(out.size() - 2, 2, "\n\n")))) continue; + out += l + "\n"; + } + while (!out.empty() && out.back() == '\n') out.pop_back(); + return out; +} + +// The changelog from this build (rank own) up to and including the offered release, newest first: each release's +// clean notes under its name ("## Beta 7"). Releases without notes still get their heading. +static inline std::string release_changelog(const std::vector &rel, long long own, const std::string &offered) { + long long top = tag_rank(offered); + std::vector pick; + for (const ReleaseInfo &r : rel) { + long long k = tag_rank(r.tag); + if (k > own && k <= top) pick.push_back(&r); + } + for (size_t a = 1; a < pick.size(); a++) // (newest first) + for (size_t b = a; b > 0 && tag_rank(pick[b]->tag) > tag_rank(pick[b - 1]->tag); b--) std::swap(pick[b], pick[b - 1]); + std::string out; + for (const ReleaseInfo *r : pick) { + std::string notes = clean_release_notes(r->body); + // (the notes' own first heading names the release already: "# LAS Recomp Beta 6 Changelog") + if (notes.compare(0, 2, "# ")) out += "# " + tag_label(r->tag, false) + "\n\n"; + if (!notes.empty()) out += notes + "\n\n"; + } + while (!out.empty() && out.back() == '\n') out.pop_back(); + return out; +} + +// The nightly page's rounds newer than this build's stamp (each "" to the next) +static inline std::string nightly_changelog(const std::vector &rel, long long own_stamp) { + std::string body; + for (const ReleaseInfo &r : rel) + if (r.tag == "nightly") body = r.body; + const std::string key = "thing\r\n- Two\r\n\r\n---\r\n\r\nBuilt from abc.\r\n\r\n" + "| File | sha256 |\r\n|---|---|\r\n| `a` | `b` |\r\n"; + std::string c = clean_release_notes(b); + CHECK(c == "# LAS Recomp Beta 7 Changelog\n\n## New\n\n- One thing\n- Two", "clean: [%s]", c.c_str()); + CHECK(clean_release_notes("Release notes: (to be written)\n\nBuilt from x.\n\n| File | sha256 |") == + "Release notes: (to be written)", "draft notes"); + CHECK(clean_release_notes("a\n\nb") == "a\nb", "comment over lines: [%s]", + clean_release_notes("a\n\nb").c_str()); + } + { // every release skipped, newest first; nothing older than this build, nothing newer than the offer + std::vector r = {{"v0.6.1", "- fix one"}, {"beta_6", "# LAS Recomp Beta 6 Changelog\n\n- six"}, + {"v0.7.0", "# LAS Recomp Beta 7 Changelog\n\n- seven"}, {"v0.6.2", ""}, + {"test-x", "no"}, {"nightly", "no"}, {"v0.8.0", "not offered"}}; + std::string c = release_changelog(r, tag_rank("v0.6.0"), "v0.7.0"); + CHECK(c == "# LAS Recomp Beta 7 Changelog\n\n- seven\n\n# Beta 6.2\n\n# Beta 6.1\n\n- fix one", "changelog: [%s]", c.c_str()); + CHECK(release_changelog(r, tag_rank("v0.7.0"), "v0.7.0").empty(), "nothing newer"); + } + { // nightly rounds newer than this build + std::string body = "> [!WARNING]\n> x\n\n## Changes\n\n\n**2026-11-17**\n\n" + "- Third (#3)\n\n\n**2026-11-16**\n\n- Second (#2)\n- First (#1)\n\n" + "To report a problem, open an issue.\n\n\n"; + std::vector r = {{"beta_6", "x"}, {"nightly", body}}; + std::string c = nightly_changelog(r, 202611161000LL); + CHECK(c == "**2026-11-17**\n\n- Third (#3)", "one round: [%s]", c.c_str()); + c = nightly_changelog(r, 202611151000LL); + CHECK(c == "**2026-11-17**\n\n- Third (#3)\n\n**2026-11-16**\n\n- Second (#2)\n- First (#1)", "two rounds: [%s]", c.c_str()); + CHECK(nightly_changelog(r, 202611171000LL).empty() && nightly_changelog({}, 0).empty(), "none newer"); + } + { // inline Markdown out + CHECK(md_inline("**Bold** and `code`, [a link](https://x.y/z) \\*star\\*") == + "Bold and code, a link https://a.b *star*", "inline: [%s]", + md_inline("**Bold** and `code`, [a link](https://x.y/z) \\*star\\*").c_str()); + } if (fails) { printf("%d failed\n", fails); return 1; } printf("update tags: all passed\n"); return 0; From c0392f5d3a0d0d475846bf8ebfb59b7c85420a72 Mon Sep 17 00:00:00 2001 From: Peiikai <339721950+peiikai@users.noreply.github.com> Date: Sun, 15 Nov 2026 18:20:41 -0600 Subject: [PATCH 4/8] macOS: Sparkle 2 as the updater Sparkle 2.10.1 (MIT, tools/fetch_sparkle.sh, pinned sha256) goes into the app as released, its own ad-hoc signatures kept; the app loads it at the start screen and checks once in the background at launch (Sparkle's own schedule is off, so no rechecks while running and no permission prompt). The update dialog's Update button asks Sparkle to check now, which shows Sparkle's own window. Feeds per channel: releases/latest/download/appcast-macOS.xml for releases, releases/download/nightly/appcast-macOS.xml for nightlies, made and EdDSA-signed with the same key as the manifests (tools/sparkle_appcast.sh in release.yml and nightly.yml). Nightly bundle versions now carry their stamp so each round is newer to Sparkle. Until the key exists the app gets no feed and Sparkle stays off; release builds keep Download only (LARECOMP_UPDATE_RELEASES). Checked beforehand: Sparkle 2.10.1 installs an update into an ad-hoc signed app (EdDSA checked, a bad signature refused), dmg and zip archives. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/nightly.yml | 3 ++ .github/workflows/release.yml | 20 ++++++--- README.md | 3 +- docs/debug-hooks.md | 1 + runtime/ui/launcher.mm | 29 ++++++++++--- runtime/ui/sparkle.h | 9 +++++ runtime/ui/sparkle.mm | 76 +++++++++++++++++++++++++++++++++++ tools/bundle_macos.sh | 32 +++++++++++++-- tools/bundle_version.sh | 14 +++++-- tools/fetch_sparkle.sh | 25 ++++++++++++ tools/nightly_publish.sh | 14 ++++--- tools/sparkle_appcast.sh | 51 +++++++++++++++++++++++ tools/test_update_tags.cpp | 6 +++ 13 files changed, 258 insertions(+), 25 deletions(-) create mode 100644 runtime/ui/sparkle.h create mode 100644 runtime/ui/sparkle.mm create mode 100755 tools/fetch_sparkle.sh create mode 100755 tools/sparkle_appcast.sh diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 14f788400..a5a80a6f8 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -175,6 +175,9 @@ jobs: find "$A" -type f \( -perm +111 -o -name '*.dylib' -o -name '*.so' \) | while read -r f; do if nm "$f" 2>/dev/null | grep ' _\{0,1\}f_70' >/dev/null; then echo "::error::game code in $f"; exit 1; fi done + - name: Sparkle feed + env: { UPDATE_SIGNING_KEY: '${{ secrets.UPDATE_SIGNING_KEY }}' } + run: tools/sparkle_appcast.sh nightly build/dist/*-macOS.dmg - name: Publish env: { GH_TOKEN: '${{ github.token }}', GH_REPO: '${{ github.repository }}' } run: tools/nightly_publish.sh build/dist/*-macOS.dmg macOS.dmg diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 6c64f9a20..f9259a6af 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -150,10 +150,18 @@ jobs: if nm "$f" 2>/dev/null | grep ' _\{0,1\}f_70' >/dev/null; then echo "::error::game code in $f"; exit 1; fi done ls -la build/dist + # Sparkle's feed for the macOS app (tools/sparkle_appcast.sh; none without the key) + - name: Sparkle feed + env: + UPDATE_SIGNING_KEY: ${{ secrets.UPDATE_SIGNING_KEY }} + TAG: ${{ inputs.tag || github.event.release.tag_name }} + run: tools/sparkle_appcast.sh "$TAG" build/dist/*-macOS.dmg - uses: actions/upload-artifact@v4 with: name: macos - path: build/dist/*.dmg + path: | + build/dist/*.dmg + build/dist/appcast-*.xml if-no-files-found: error compression-level: 0 # (already compressed) @@ -483,7 +491,7 @@ jobs: GH_REPO: ${{ github.repository }} run: | cd dist - mkdir ../manifests && mv update-*.txt ../manifests/ 2>/dev/null || true # (the self-updater's, beside the files) + mkdir ../manifests && mv update-*.txt appcast-*.xml ../manifests/ 2>/dev/null || true # (the updaters', beside the files) ls -la . ../manifests [ "$(ls | wc -l)" = 6 ] || { echo "::error::expected 6 files"; exit 1; } # (a test build: only the platforms its fix targets ship; the others were built as a compile check) @@ -493,12 +501,12 @@ jobs: *) echo "::error::unknown file $f"; exit 1 ;; esac [[ " $PLATFORMS " == *" $p "* ]] || { echo "built, not shipped: $f"; rm "$f"; } done - for m in ../manifests/update-*.txt; do # (a manifest goes up only with its platform's file) + for m in ../manifests/*; do # (a manifest or feed goes up only with its platform's file) [ -f "$m" ] || continue - plat=$(basename "$m" .txt); plat=${plat#update-} - ls ./*-"$plat".zip ./*-"$plat".AppImage >/dev/null 2>&1 || rm "$m" + plat=$(basename "$m"); plat=${plat#update-}; plat=${plat#appcast-}; plat=${plat%.*} + ls ./*-"$plat".zip ./*-"$plat".AppImage ./*-"$plat".dmg >/dev/null 2>&1 || rm "$m" done - MANIFESTS=(); for m in ../manifests/update-*.txt; do [ -f "$m" ] && MANIFESTS+=("$m"); done + MANIFESTS=(); for m in ../manifests/*; do [ -f "$m" ] && MANIFESTS+=("$m"); done if [ "$EVENT" = release ]; then # (published on GitHub: attach the files, the notes get the sha256 table) gh release view "$TAG" --json body -q .body | grep -v '^> The download files are being built' > ../body.md || true { cat ../body.md; echo; echo "| File | sha256 |"; echo "|---|---|" diff --git a/README.md b/README.md index 2d34594c2..f8bc4dd5c 100644 --- a/README.md +++ b/README.md @@ -298,6 +298,7 @@ none of their files are used): - [Vulkan Memory Allocator](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator) - Windows and Linux renderer (MIT) - [Monocypher](https://monocypher.org) by Loup Vaillant and contributors - checks the signature of updates on Windows and Linux (CC0, `third_party/monocypher/LICENCE.md`) +- [Sparkle](https://sparkle-project.org) - the macOS app's updater (MIT, `Contents/Resources/Sparkle-LICENSE.txt` in the app) - [SMAA](https://github.com/iryoku/smaa) by Jorge Jimenez, Jose I. Echevarria, Belen Masia, Fernando Navarro and Diego Gutierrez - the anti-aliasing option (MIT, `third_party/smaa/LICENSE.txt`) - [AMD FidelityFX Super Resolution 1](https://github.com/GPUOpen-Effects/FidelityFX-FSR) - the Windows and Linux upscaler @@ -350,7 +351,7 @@ LAS Recomp's own code (the recompiler tools, the runtime, the randomizer additio Vulkan Memory Allocator (MIT), SMAA (MIT), AMD FSR 1 (MIT), the Baloo 2 and BIZ UDPGothic fonts (SIL OFL 1.1), the DejaVu Sans font (Bitstream Vera / DejaVu license), SDL 3 (zlib), FFmpeg (LGPL 2.1+, linked dynamically, and statically in the iOS app), the Zig compiler (MIT; its LLVM / Clang / LLD: Apache 2.0 with LLVM exceptions; its C library headers keep their own licenses), the iOS kit's Mach-O linker (LLD as built by the Rust project: Apache 2.0 with LLVM exceptions), miniz -(MIT: the iOS kit and the .ipa it makes), Monocypher (CC0: update signatures), and the generator helpers' bundled libraries listed under Credits (oead / evfl / Keystone in the seed +(MIT: the iOS kit and the .ipa it makes), Monocypher (CC0: update signatures), Sparkle (MIT: the macOS updater), and the generator helpers' bundled libraries listed under Credits (oead / evfl / Keystone in the seed generator and Unicorn in the game code generator are under the GPL, versions in the table below: each helper is a separate program the game runs, and its sources are this repository plus those projects' published sources). The iOS app is the exception: iOS runs no helper processes, so it embeds CPython and the seed generator's packages - oead, evfl and Keystone (GPL 2.0+ / GPL 2.0), diff --git a/docs/debug-hooks.md b/docs/debug-hooks.md index 2f24fe864..319aea95f 100644 --- a/docs/debug-hooks.md +++ b/docs/debug-hooks.md @@ -160,6 +160,7 @@ Use it with `LARECOMP_INPUT` (to get into a save) and `LARECOMP_SAVE_DIR` (so th | `LARECOMP_UPDATE_KEY` | 64 hex | With `LARECOMP_UPDATE_URL`: the public key manifests are checked with (a test key; `tools/update_sign.cpp keygen`). | | `LARECOMP_UPDATE_APP` | folder | Windows: the app folder Update replaces files in (default: the exe's). Linux updates `$APPIMAGE`. | | `LARECOMP_UPDATE_NO_RESTART` | `1` | After Update installs (or rolls back), quit instead of starting the app again. | +| `LARECOMP_SPARKLE_FEED` | URL | macOS: Sparkle reads this appcast instead of the build's, and runs even in builds whose channel has no Update yet. | | `LARECOMP_FONT` | font file | Use this file for the system fonts the game asks for (.ttf, .otf, .ttc, .bfttf). | ## Logging and diagnostics diff --git a/runtime/ui/launcher.mm b/runtime/ui/launcher.mm index 17a1b5ce5..bdb9460a8 100644 --- a/runtime/ui/launcher.mm +++ b/runtime/ui/launcher.mm @@ -164,6 +164,7 @@ static void save_png(id tex, const char *path) { #include "update_notes.h" // tag_rank, tag_label; the update dialog's changelog #include "update.h" +#include "sparkle.h" static std::string g_update_tag; // a newer release's tag (g_update_lock) static std::string g_update_json; // the releases list it came from (the dialog's changelog) @@ -1069,11 +1070,21 @@ static void notice_popup(float s) { // (the updater's steps, for the translation tables: runtime/update.cpp sets them in English) static const char *const UPDATE_STEPS[] = {LN("Checking the update"), LN("Downloading"), LN("Checking the download"), LN("Unpacking"), LN("Installing")}; +// this build's channel has Update at all: nightlies, and releases once LARECOMP_UPDATE_RELEASES is on (never test builds) +static bool update_channel_on(void) { + if (PLAT_TOUCH) return false; + return LARECOMP_NIGHTLY_STAMP || (LARECOMP_UPDATE_RELEASES && strncmp(LARECOMP_VERSION, "test-", 5)); +} static bool update_button_shown(const std::string &tag) { (void)UPDATE_STEPS; - if (PLAT_TOUCH || !(LARECOMP_SELF_UPDATE)) return false; - if (!LARECOMP_NIGHTLY_STAMP && !LARECOMP_UPDATE_RELEASES) return false; + if (!update_channel_on() && !getenv("LARECOMP_SPARKLE_FEED")) return false; +#if defined(__APPLE__) && !PLAT_IOS + (void)tag; + return sparkle_available(); // (Sparkle finds the newest of its channel itself) +#else + if (!LARECOMP_SELF_UPDATE) return false; return LARECOMP_NIGHTLY_STAMP ? tag == "nightly" : tag_rank(tag) >= 0; +#endif } static void update_open(const std::string &tag) { pthread_mutex_lock(&g_update_lock); @@ -1143,9 +1154,9 @@ static void update_dialog(float s) { update_notes_draw(sc); ImGui::EndChild(); ImGui::Spacing(); - bool updater = update_button_shown(tag); + bool updater = update_button_shown(tag), sparkle = updater && sparkle_available(); const char *why = NULL; - bool can = updater && update_available(&why); + bool can = updater && (sparkle || update_available(&why)); if (updater && !can && st == UPDATE_IDLE) { static std::string logged; if (logged != tag) logged = tag, fprintf(stderr, "[launcher] Update off here: %s\n", why ? why : "?"); @@ -1167,8 +1178,8 @@ static void update_dialog(float s) { ImGui::BeginDisabled(!can); ImGui::SetItemDefaultFocus(); if (ImGui::Button(L("Update"), bw)) { - long long own = LARECOMP_NIGHTLY_STAMP; - update_start(tag.c_str(), LARECOMP_PLATFORM, own); + if (sparkle) sparkle_check_now(), g_update_open = false, ImGui::CloseCurrentPopup(); // (its own window) + else update_start(tag.c_str(), LARECOMP_PLATFORM, LARECOMP_NIGHTLY_STAMP); } ImGui::EndDisabled(); ImGui::SameLine(); @@ -2494,6 +2505,12 @@ static void load_fonts(void) { uint64_t loop_t0 = SDL_GetTicks(), last_frame = loop_t0, bg_gap = 0, bg_frames = 0; bool bg_logged = false; update_reached_start_screen(); // (a new version after an update got this far: it's kept. runtime/update.h) + { // macOS: Sparkle, with its one check of this launch (not again after a "Title screen" reboot) + static bool sparkle_once; + if (!sparkle_once && (update_channel_on() || getenv("LARECOMP_SPARKLE_FEED")) && !getenv("LARECOMP_NO_UPDATE_CHECK")) + sparkle_start(true); + sparkle_once = true; + } // (test) LARECOMP_UPDATE_OPEN=1: the update dialog opens as soon as the check found one; =update: and Update is // pressed const char *upd_open_env = getenv("LARECOMP_UPDATE_OPEN"); diff --git a/runtime/ui/sparkle.h b/runtime/ui/sparkle.h new file mode 100644 index 000000000..80617c22b --- /dev/null +++ b/runtime/ui/sparkle.h @@ -0,0 +1,9 @@ +// macOS: the Sparkle updater (runtime/ui/sparkle.mm). Elsewhere these do nothing. +#pragma once +#include "../platform.h" + +// Loads Sparkle (when the app has it) and starts it; check_now: the one background check of this launch. false: none. +bool sparkle_start(bool check_now); +bool sparkle_available(void); +// The update dialog's Update: Sparkle checks now and shows its own window +void sparkle_check_now(void); diff --git a/runtime/ui/sparkle.mm b/runtime/ui/sparkle.mm new file mode 100644 index 000000000..70ff1aba6 --- /dev/null +++ b/runtime/ui/sparkle.mm @@ -0,0 +1,76 @@ +// macOS: Sparkle 2 (MIT, tools/fetch_sparkle.sh) is the app's updater, with its own windows. tools/bundle_macos.sh puts +// Sparkle.framework in the app with the feed of the build's channel (the releases' or the nightlies' appcast, made by +// tools/sparkle_appcast.sh) and the public key the appcast's EdDSA signatures are checked with: the same key as the +// Windows and Linux manifests (runtime/update.cpp). The framework is loaded when the start screen first comes up (a +// build from source has none: no Sparkle, the update dialog offers Download). It checks once, at launch, in the +// background: never again while the app runs. The update dialog's Update button asks it to check now, which shows +// Sparkle's own window with the update. +#include "sparkle.h" + +#if defined(__APPLE__) && !PLAT_IOS +#import + +#include + +// (Sparkle's classes by name: the app doesn't link the framework, it loads it when it's there) +@interface NSObject (LASSparkle) +- (instancetype)initWithStartingUpdater:(BOOL)start updaterDelegate:(id)d userDriverDelegate:(id)u; +- (id)updater; +- (void)checkForUpdates:(id)sender; +- (void)checkForUpdatesInBackground; +- (BOOL)canCheckForUpdates; +@end + +static id g_controller; + +// (test) LARECOMP_SPARKLE_FEED=: Sparkle reads this feed instead of the build's (a local server); with it Sparkle +// also runs in builds whose channel has no Update, and in a bundle without a feed in its Info.plist +@interface LASSparkleDelegate : NSObject +@end +@implementation LASSparkleDelegate +- (NSString *)feedURLStringForUpdater:(id)updater { + (void)updater; + const char *f = getenv("LARECOMP_SPARKLE_FEED"); + return f && *f ? [NSString stringWithUTF8String:f] : nil; +} +@end +static LASSparkleDelegate *g_delegate; + +bool sparkle_start(bool check_now) { + if (g_controller) return true; + NSBundle *app = [NSBundle mainBundle]; + const char *test_feed = getenv("LARECOMP_SPARKLE_FEED"); + if ((!test_feed && ![app objectForInfoDictionaryKey:@"SUFeedURL"]) || ![app objectForInfoDictionaryKey:@"SUPublicEDKey"]) { + fprintf(stderr, "[sparkle] not in this build (no feed or key)\n"); + return false; + } + NSString *path = [[app privateFrameworksPath] stringByAppendingPathComponent:@"Sparkle.framework"]; + NSBundle *fw = [NSBundle bundleWithPath:path]; + NSError *err = nil; + if (!fw || ![fw loadAndReturnError:&err]) { + fprintf(stderr, "[sparkle] can't load Sparkle.framework: %s\n", err ? err.localizedDescription.UTF8String : "missing"); + return false; + } + Class cls = NSClassFromString(@"SPUStandardUpdaterController"); + if (!cls) { fprintf(stderr, "[sparkle] no SPUStandardUpdaterController\n"); return false; } + // (Sparkle's own schedule is off - SUEnableAutomaticChecks false in Info.plist - so it never asks for permission + // and never checks while the app runs; this is the one check at launch) + g_delegate = [LASSparkleDelegate new]; + g_controller = [[cls alloc] initWithStartingUpdater:YES updaterDelegate:g_delegate userDriverDelegate:nil]; + if (!g_controller) { fprintf(stderr, "[sparkle] the updater didn't start\n"); return false; } + fprintf(stderr, "[sparkle] started, feed %s\n", test_feed ? test_feed : [[app objectForInfoDictionaryKey:@"SUFeedURL"] UTF8String]); + if (check_now) [[g_controller updater] checkForUpdatesInBackground]; + return true; +} + +bool sparkle_available(void) { return g_controller != nil; } + +void sparkle_check_now(void) { + if (!g_controller) return; + [g_controller checkForUpdates:nil]; +} +#else +bool sparkle_start(bool) { return false; } +bool sparkle_available(void) { return false; } +void sparkle_check_now(void) {} +#endif diff --git a/tools/bundle_macos.sh b/tools/bundle_macos.sh index 9af8384a6..fdd1e5548 100755 --- a/tools/bundle_macos.sh +++ b/tools/bundle_macos.sh @@ -4,7 +4,8 @@ # paths rewritten to @rpath; Contents/Resources: the icon, the seed generator helper (build/helper/rando-gen, when # built: runtime/ui/rando_tab.mm generator_cmd) and what the start screen builds the game code with on the player's # machine (runtime/gamebuild.c): the generator helper (build/helper/lasgen), the compiler (build/zig, tools/fetch_zig.sh) -# and the headers the code is compiled against (gamelib-src/). Ad-hoc signed. No game files, game code or fonts: the +# and the headers the code is compiled against (gamelib-src/); Contents/Frameworks/Sparkle.framework: the updater +# (tools/fetch_sparkle.sh, runtime/ui/sparkle.mm), with the feed of this build's channel. Ad-hoc signed. No game files, game code or fonts: the # app keeps those in ~/Library/Application Support/ (runtime/paths.h). # MACOS_MIN=: LSMinimumSystemVersion, and every Mach-O inside must be built for it or older (else it fails and # lists them); without it the newest minimum found inside is used. @@ -38,6 +39,27 @@ mkdir -p "$C/MacOS" "$C/Frameworks" "$C/Resources" cp "$EXE" "$C/MacOS/lasrecomp" strip -S "$C/MacOS/lasrecomp" # (debug-map entries only: the symbols crash reports name functions by stay) if [ -x "$HELPER/rando-gen" ]; then cp -R "$HELPER" "$C/Resources/rando-gen"; else echo "note: no $HELPER (make rando-helper)"; fi +# Sparkle: the framework as released (its own ad-hoc signatures kept: ditto), the feed of this build's channel, and +# the update key's public half (runtime/update.cpp UPDATE_PUBLIC_KEY, hex there, base64 here). Until the key exists +# (all zeros) the app gets no feed and Sparkle stays off. +tools/fetch_sparkle.sh +ditto build/sparkle/Sparkle.framework "$C/Frameworks/Sparkle.framework" +cp build/sparkle/LICENSE "$C/Resources/Sparkle-LICENSE.txt" +UPDATE_KEY=$(sed -n 's/^#define UPDATE_PUBLIC_KEY "\([0-9a-f]\{64\}\)"/\1/p' runtime/update.cpp) +[ -n "$UPDATE_KEY" ] || { echo "no UPDATE_PUBLIC_KEY in runtime/update.cpp"; exit 1; } +SPARKLE_KEYS= +if [ "$UPDATE_KEY" != "$(printf '%064d' 0)" ]; then + case $TAG in + nightly-*) FEED=https://github.com/peiikai/LASRecomp/releases/download/nightly/appcast-macOS.xml ;; + *) FEED=https://github.com/peiikai/LASRecomp/releases/latest/download/appcast-macOS.xml ;; + esac + ED_KEY=$(printf '%s' "$UPDATE_KEY" | xxd -r -p | base64) + # (SUEnableAutomaticChecks false: Sparkle's own schedule off and no permission prompt; the app checks once at launch) + SPARKLE_KEYS="SUFeedURL$FEED + SUPublicEDKey$ED_KEY + SUEnableAutomaticChecks + SUVerifyUpdateBeforeExtraction" +fi cp -R "$GEN_HELPER" "$C/Resources/lasgen" cp -R "$ZIG" "$C/Resources/zig" mkdir "$C/Resources/gamelib-src" @@ -127,6 +149,7 @@ cat > "$C/Info.plist" <LSArchitecturePriorityarm64 LSApplicationCategoryTypepublic.app-category.games NSHighResolutionCapable + $SPARKLE_KEYS EOF @@ -134,9 +157,12 @@ printf 'APPL????' > "$C/PkgInfo" # ---- ad-hoc signature (Apple Silicon refuses to run unsigned code; the rewrites above invalidated the originals): # every Mach-O inside first, then the bundle -while read -r f; do [ "$f" = "$C/MacOS/lasrecomp" ] || codesign -f -s - "$f" 2>/dev/null; done < <(machos) +# (Sparkle.framework keeps its own signatures, made inside-out: re-signing its pieces here would leave its seal stale) +while read -r f; do + case $f in "$C/MacOS/lasrecomp"|"$C/Frameworks/Sparkle.framework/"*) ;; *) codesign -f -s - "$f" 2>/dev/null ;; esac +done < <(machos) codesign -f -s - "$APP" -codesign --verify --strict "$APP" +codesign --verify --deep --strict "$APP" if find "$APP" -name 'lasgame*' | grep . >/dev/null; then echo "game code inside $APP"; exit 1; fi # no path of this machine inside (configure lines, debug paths, frozen Python's file names). Not on CI: its paths # name no one, and prebuilt wheels hold the CI runner's own (/Users/runner/...) diff --git a/tools/bundle_version.sh b/tools/bundle_version.sh index 4b3dc2cda..3bc191aeb 100755 --- a/tools/bundle_version.sh +++ b/tools/bundle_version.sh @@ -4,8 +4,9 @@ # Short version (Finder, About): the semantic version under the tag - beta_ -> 0..0, beta_. -> 0.., # v0.6.0 -> 0.6.0, v1.2.3 -> 1.2.3. Build number: one number that always goes up, major*10000 + minor*100 + patch # (0.5.3 -> 503, 0.6.0 -> 600, 1.0.0 -> 10000). macOS compares build numbers part by part, so 503 is above Beta 5.2's -# 0.9.5.2. A test build (test-, previewing ) or a nightly (nightly--) is 0.0.1 to players and .1 inside: -# above the release before it, below the one it previews. +# 0.9.5.2. A test build (test-, previewing ) is 0.0.1 to players and .1 inside: +# above the release before it, below the one it previews. A nightly (nightly--) is the same with its +# stamp after it, .1., so each round is newer than the last (Sparkle compares these). set -eu tag=$1 semver() { @@ -22,7 +23,14 @@ build() { { print $1 * 10000 + $2 * 100 + $3 }' } case "$tag" in - test-*|nightly-*) + nightly-*) + [ $# -ge 2 ] || { echo "bundle_version.sh: a nightly needs the tag it previews" >&2; exit 1; } + stamp=${tag#nightly-}; stamp=${stamp%%-*} + case $stamp in [0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]) ;; + *) echo "bundle_version.sh: bad nightly stamp in $tag" >&2; exit 1 ;; esac + b=$(build "$(semver "$2")") + echo "0.0.1 $((b - 1)).1.$stamp" ;; + test-*) [ $# -ge 2 ] || { echo "bundle_version.sh: a test build needs the tag it previews" >&2; exit 1; } b=$(build "$(semver "$2")") echo "0.0.1 $((b - 1)).1" ;; diff --git a/tools/fetch_sparkle.sh b/tools/fetch_sparkle.sh new file mode 100755 index 000000000..ee5103e0f --- /dev/null +++ b/tools/fetch_sparkle.sh @@ -0,0 +1,25 @@ +#!/bin/bash +# Sparkle 2 (MIT: https://sparkle-project.org), the macOS app's updater (runtime/ui/sparkle.mm), into +# build/sparkle/ (Sparkle.framework, LICENSE). tools/bundle_macos.sh puts the framework in the app. Fetches the pinned +# release and checks its hash; needs network once, as tools/fetch_zig.sh does. +set -euo pipefail +cd "$(dirname "$0")/.." +VER=2.10.1 +SHA=1a856d2a9edb8e628de88121d7be04cf0e2167f8641650b78fca00b14244cf27 +DL=build/sparkle-dl +OUT=build/sparkle +[ -f "$OUT/.ok-$VER" ] && exit 0 +mkdir -p "$DL" +TAR="$DL/Sparkle-$VER.tar.xz" +if [ ! -f "$TAR" ]; then # (a .part file until it's whole) + curl -fsSL --proto '=https' -o "$TAR.part" "https://github.com/sparkle-project/Sparkle/releases/download/$VER/Sparkle-$VER.tar.xz" + mv "$TAR.part" "$TAR" +fi +GOT=$(shasum -a 256 < "$TAR" | cut -d' ' -f1) +[ "$GOT" = "$SHA" ] || { echo "Sparkle-$VER.tar.xz: sha256 $GOT, expected $SHA"; rm -f "$TAR"; exit 1; } +rm -rf "$OUT" "$DL/x" && mkdir -p "$DL/x" "$OUT" +tar -xJf "$TAR" -C "$DL/x" Sparkle.framework LICENSE +ditto "$DL/x/Sparkle.framework" "$OUT/Sparkle.framework" # (ditto: links and signatures as they are) +cp "$DL/x/LICENSE" "$OUT/LICENSE" +touch "$OUT/.ok-$VER" +echo "build/sparkle: Sparkle $VER" diff --git a/tools/nightly_publish.sh b/tools/nightly_publish.sh index dca6847f2..e52478244 100755 --- a/tools/nightly_publish.sh +++ b/tools/nightly_publish.sh @@ -2,9 +2,10 @@ # Puts one platform's nightly file on the rolling "nightly" pre-release (.github/workflows/nightly.yml), replacing that # platform's older nightly file. Each platform's job calls it as soon as its own build is done, so a platform that is # slow or fails never holds the others back. -# The platform's update manifest (build/dist/update-.txt, tools/update_manifest.sh) goes up right after the -# file and before the older file goes, so it always names a file that is there; without one (no signing key) the old -# manifest is removed, so the start screen's Update never fetches a file of an older round. +# The platform's update manifest (build/dist/update-.txt, tools/update_manifest.sh) or Sparkle feed +# (appcast-macOS.xml, tools/sparkle_appcast.sh) goes up right after the file and before the older file goes, so it +# always names a file that is there; without one (no signing key) the old one is removed, so Update never fetches a +# file of an older round. # Usage: tools/nightly_publish.sh (GH_TOKEN, GH_REPO set) set -euo pipefail f=$1 @@ -14,9 +15,10 @@ new=$(basename "$f" | tr ' ' .) # (GitHub stores "LAS Recomp-..." as "LAS.Recom case $new in LAS.Recomp-nightly-*-"$suffix") ;; *) echo "nightly_publish.sh: $new is not a nightly $suffix file" >&2; exit 1 ;; esac gh release upload nightly "$f" --clobber platform=${suffix%.*} # (windows.zip -> windows, linux-x86_64.AppImage -> linux-x86_64) -manifest=$(dirname "$f")/update-$platform.txt -if [ -f "$manifest" ]; then gh release upload nightly "$manifest" --clobber -else gh release delete-asset nightly "update-$platform.txt" -y 2>/dev/null || true; fi +for m in "update-$platform.txt" "appcast-$platform.xml"; do + if [ -f "$(dirname "$f")/$m" ]; then gh release upload nightly "$(dirname "$f")/$m" --clobber + else gh release delete-asset nightly "$m" -y 2>/dev/null || true; fi +done # (this platform's older nightly files out, after the new one is up: the page never lacks this platform) gh release view nightly --json assets -q '.assets[].name' | while read -r old; do case $old in LAS.Recomp-nightly-*-"$suffix") [ "$old" = "$new" ] || gh release delete-asset nightly "$old" -y ;; esac diff --git a/tools/sparkle_appcast.sh b/tools/sparkle_appcast.sh new file mode 100755 index 000000000..0c162c568 --- /dev/null +++ b/tools/sparkle_appcast.sh @@ -0,0 +1,51 @@ +#!/bin/bash +# The macOS update feed for Sparkle (runtime/ui/sparkle.mm): build/dist/appcast-macOS.xml with one item, this build's +# .dmg, signed with the UPDATE_SIGNING_KEY secret (EdDSA, the same key as the Windows and Linux manifests: +# tools/update_sign.cpp). release.yml and nightly.yml put it next to the .dmg; the apps read it from +# releases/latest/download/ (releases) or releases/download/nightly/ (nightlies), tools/bundle_macos.sh. Without the +# key it only warns: no feed, and the app's Download still works. +# Usage: tools/sparkle_appcast.sh +set -euo pipefail +cd "$(dirname "$0")/.." +[ $# = 2 ] || { echo "usage: tools/sparkle_appcast.sh " >&2; exit 2; } +REL=$1 +DMG=$2 +OUT=build/dist/appcast-macOS.xml +rm -f "$OUT" +if [ -z "${UPDATE_SIGNING_KEY:-}" ]; then + echo "::warning::UPDATE_SIGNING_KEY is not set: no Sparkle feed for macOS (players there update with Download)" + exit 0 +fi +TAG=$(sed -n 's/^#define LARECOMP_VERSION "\(.*\)"/\1/p' runtime/ui/launcher.mm) +TEST_OF=$(sed -n 's/^#define LARECOMP_TEST_OF "\(.*\)"/\1/p' runtime/ui/launcher.mm) +read -r SHORT BUILD < "$OUT.part" < + + + LAS Recomp + + $TITLE + $(LC_ALL=C date -u '+%a, %d %b %Y %H:%M:%S +0000') + $BUILD + $SHORT + 15.0 + https://github.com/peiikai/LASRecomp/releases/tag/$REL + + + + +EOF +mv "$OUT.part" "$OUT" +cat "$OUT" diff --git a/tools/test_update_tags.cpp b/tools/test_update_tags.cpp index f27840cba..d20e5c2bb 100644 --- a/tools/test_update_tags.cpp +++ b/tools/test_update_tags.cpp @@ -68,6 +68,12 @@ int main(void) { CHECK(bundle_cmp(t, bundle_build("beta_5.3")) > 0 && bundle_cmp(t, bundle_build("beta_5.4")) < 0, "test build of beta_5.4: %s between 5.3 and 5.4", t.c_str()); CHECK(bundle_build("test-foo").empty() && bundle_build("alpha_3").empty(), "no build number without a release"); + // nightlies: each round above the last (Sparkle's feed), all between the release before and the one previewed + std::string n1 = bundle_build("nightly-202611161000-abc1234", "v0.7.0"), n2 = bundle_build("nightly-202611171000-def5678", "v0.7.0"); + CHECK(n1 == "699.1.202611161000", "nightly build number: %s", n1.c_str()); + CHECK(bundle_cmp(n2, n1) > 0 && bundle_cmp(n1, bundle_build("v0.6.9")) > 0 && bundle_cmp(n2, bundle_build("v0.7.0")) < 0, + "nightlies in order: %s %s", n1.c_str(), n2.c_str()); + CHECK(bundle_build("nightly-2026-abc", "v0.7.0").empty(), "bad nightly stamp"); } const char *never[] = {"alpha_3", "test-388-grass", "beta_0", "beta_5.0", "v0.0.1", "v1.0", "v0.6.0-rc1", "beta_5.3x", "ci-test-1", "", "v", "beta_", "experimental", "experimental-202610302315-abc1234", "nightly", From 6372a81dd36c33fc8a4e3128a36d315b7288c92a Mon Sep 17 00:00:00 2001 From: Peiikai <339721950+peiikai@users.noreply.github.com> Date: Sun, 15 Nov 2026 18:24:32 -0600 Subject: [PATCH 5/8] Update signing key: the public half The key that signs every update manifest and Sparkle feed; its private half is the UPDATE_SIGNING_KEY repo secret. tools/bundle_macos.sh derives Sparkle's SUPublicEDKey from it. Co-Authored-By: Claude Opus 5.5 --- runtime/update.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/update.cpp b/runtime/update.cpp index 84713c808..6700b8dbe 100644 --- a/runtime/update.cpp +++ b/runtime/update.cpp @@ -33,7 +33,7 @@ extern "C" const char *larecomp_version(void); // runtime/ui/launcher.mm (LAREC // The public half of the key that signs every manifest (the UPDATE_SIGNING_KEY secret; tools/update_sign.cpp). The // same key signs the macOS updates for Sparkle (SUPublicEDKey in tools/bundle_macos.sh, base64 there). Never change // it: builds out there only accept manifests signed by this one. -#define UPDATE_PUBLIC_KEY "0000000000000000000000000000000000000000000000000000000000000000" +#define UPDATE_PUBLIC_KEY "ff5d19bca25dab8d425793da6cdcd9736ed27b306b9e166f15dbf027fd8f7942" #define DOWNLOAD_URL "https://github.com/peiikai/LASRecomp/releases/download" // Where the app is: the folder whose files the manifest lists (Windows), or the AppImage's folder and its name From 698f249954fc42cebb55d2a090eb0d049c765f59 Mon Sep 17 00:00:00 2001 From: Peiikai <339721950+peiikai@users.noreply.github.com> Date: Sun, 15 Nov 2026 19:10:43 -0600 Subject: [PATCH 6/8] Sparkle: test hook to install without a click LARECOMP_SPARKLE_AUTOINSTALL=1 installs a downloaded update at once, as Sparkle's Install and Relaunch does. Used to check the macOS path end to end on this build: two ad-hoc signed bundles of the app, a local feed, Sparkle 2.10.1 updated the bundle in place and relaunched it (the app quits cleanly when asked); a feed with a broken EdDSA signature was downloaded but not installed. Co-Authored-By: Claude Opus 5.5 --- docs/debug-hooks.md | 1 + runtime/ui/sparkle.mm | 9 +++++++++ 2 files changed, 10 insertions(+) diff --git a/docs/debug-hooks.md b/docs/debug-hooks.md index 319aea95f..2cdeb68c0 100644 --- a/docs/debug-hooks.md +++ b/docs/debug-hooks.md @@ -161,6 +161,7 @@ Use it with `LARECOMP_INPUT` (to get into a save) and `LARECOMP_SAVE_DIR` (so th | `LARECOMP_UPDATE_APP` | folder | Windows: the app folder Update replaces files in (default: the exe's). Linux updates `$APPIMAGE`. | | `LARECOMP_UPDATE_NO_RESTART` | `1` | After Update installs (or rolls back), quit instead of starting the app again. | | `LARECOMP_SPARKLE_FEED` | URL | macOS: Sparkle reads this appcast instead of the build's, and runs even in builds whose channel has no Update yet. | +| `LARECOMP_SPARKLE_AUTOINSTALL` | `1` | macOS: an update Sparkle downloaded installs at once and the app restarts, as its Install and Relaunch button does (no window to click). | | `LARECOMP_FONT` | font file | Use this file for the system fonts the game asks for (.ttf, .otf, .ttc, .bfttf). | ## Logging and diagnostics diff --git a/runtime/ui/sparkle.mm b/runtime/ui/sparkle.mm index 70ff1aba6..8835da25a 100644 --- a/runtime/ui/sparkle.mm +++ b/runtime/ui/sparkle.mm @@ -33,6 +33,15 @@ - (NSString *)feedURLStringForUpdater:(id)updater { const char *f = getenv("LARECOMP_SPARKLE_FEED"); return f && *f ? [NSString stringWithUTF8String:f] : nil; } +// (test) LARECOMP_SPARKLE_AUTOINSTALL=1: an update downloaded in the background installs at once, as Sparkle's +// "Install and Relaunch" does (the app is asked to quit, then started again), with no window to click +- (BOOL)updater:(id)updater willInstallUpdateOnQuit:(id)item immediateInstallationBlock:(void (^)(void))install { + (void)updater, (void)item; + if (!getenv("LARECOMP_SPARKLE_AUTOINSTALL")) return NO; + fprintf(stderr, "[sparkle] installing now (test)\n"); + install(); + return YES; +} @end static LASSparkleDelegate *g_delegate; From b01470a178f4e658e18d4644072ca3d5aba5230a Mon Sep 17 00:00:00 2001 From: Peiikai <339721950+peiikai@users.noreply.github.com> Date: Sun, 15 Nov 2026 19:25:46 -0600 Subject: [PATCH 7/8] Windows: manifests with LF lines; a fresh log after an update's restart Found in the first Windows test: update_sign wrote the manifest through stdout in text mode, so every line ended in CR LF and every install refused it ("bad signature line"). stdout is binary now; tools/update_manifest.sh reads each manifest back from the file and checks it as the app would, so a broken one fails the build; the app names CR LF line ends when it refuses one. The restarted new version inherited LASRECOMP_LOG_FILE and appended to the old version's session log without its own header; it starts a session log of its own now. Windows x64 test (Windows PC, steps per the request): update, automatic restart, the start screen keeping it, rollback of a version that never got there, and a bad signature all passed with the LF manifest; saves, seeds and game files untouched. Co-Authored-By: Claude Opus 5.5 --- runtime/update.cpp | 4 ++++ runtime/update_core.h | 2 ++ tools/test_update.cpp | 5 +++++ tools/update_manifest.sh | 4 +++- tools/update_sign.cpp | 7 +++++++ 5 files changed, 21 insertions(+), 1 deletion(-) diff --git a/runtime/update.cpp b/runtime/update.cpp index 6700b8dbe..14bb8055e 100644 --- a/runtime/update.cpp +++ b/runtime/update.cpp @@ -290,6 +290,10 @@ static void restart_app(const std::string &dir, const std::string &appimage_name wchar_t wpath[1100], wcmd[1200]; MultiByteToWideChar(CP_UTF8, 0, path.c_str(), -1, wpath, 1100); MultiByteToWideChar(CP_UTF8, 0, cmd.c_str(), -1, wcmd, 1200); + // (a new session log for the new version: LASRECOMP_LOG_FILE would make it append to this one's, as a relaunch + // of the same version does - runtime/platform/windows.c) + _putenv_s("LASRECOMP_LOG_FILE", ""); + SetEnvironmentVariableA("LASRECOMP_LOG_FILE", NULL); STARTUPINFOW si = {}; si.cb = sizeof si; PROCESS_INFORMATION pi; diff --git a/runtime/update_core.h b/runtime/update_core.h index ac712bceb..299d3108e 100644 --- a/runtime/update_core.h +++ b/runtime/update_core.h @@ -114,6 +114,8 @@ static inline bool upd_safe_path(const std::string &p) { static inline bool upd_parse_manifest(const std::string &text, const uint8_t pub[32], UpdManifest *m, std::string *why) { *m = UpdManifest(); auto fail = [&](const char *w) { if (why) *why = w; return false; }; + // (a manifest written through a Windows text stream: every line ends in CR LF, which the signature doesn't cover) + if (text.find('\r') != std::string::npos) return fail("CR LF line ends"); size_t sig = text.rfind("\nsignature "); if (sig == std::string::npos) return fail("no signature"); std::string sighex = text.substr(sig + 11); diff --git a/tools/test_update.cpp b/tools/test_update.cpp index 684b9a740..5991f2a7f 100644 --- a/tools/test_update.cpp +++ b/tools/test_update.cpp @@ -63,6 +63,11 @@ static void manifest_tests() { t[t.size() - 3] = t[t.size() - 3] == '0' ? '1' : '0'; CHECK(!upd_parse_manifest(t, g_pk, &r, &why), "a changed signature"); CHECK(!upd_parse_manifest(good.substr(0, good.size() / 2), g_pk, &r, &why), "truncated"); + { // written through a Windows text stream (CR LF lines): refused, and said so + std::string crlf; + for (char c : good) crlf += c == '\n' ? std::string("\r\n") : std::string(1, c); + CHECK(!upd_parse_manifest(crlf, g_pk, &r, &why) && why == "CR LF line ends", "CR LF: %s", why.c_str()); + } CHECK(!upd_parse_manifest("", g_pk, &r, &why), "empty"); CHECK(!upd_parse_manifest(good + "file 1 " + sha_of("x") + " extra\n", g_pk, &r, &why), "a line after the signature"); // signed, but wrong inside: every one refused diff --git a/tools/update_manifest.sh b/tools/update_manifest.sh index c0275f622..0a30c4e6c 100755 --- a/tools/update_manifest.sh +++ b/tools/update_manifest.sh @@ -13,9 +13,11 @@ if [ -z "${UPDATE_SIGNING_KEY:-}" ]; then echo "::warning::UPDATE_SIGNING_KEY is not set: no update manifest for $2 (players there update with Download)" exit 0 fi -mkdir -p build +mkdir -p build/dist "${CXX_UPDATE:-clang++}" -std=c++17 -O2 -Iruntime tools/update_sign.cpp -o build/update_sign build/update_sign manifest "$@" > "$out.part" +# (read back from the file as the app reads it: catches anything the way out changed, e.g. CR LF line ends) +build/update_sign verify "$out.part" "$(build/update_sign public | awk '/^public /{print $2}')" mv "$out.part" "$out" head -4 "$out" echo "$(grep -c '^file ' "$out" || true) files; $out" diff --git a/tools/update_sign.cpp b/tools/update_sign.cpp index af2ab0ac5..40d97b4cb 100644 --- a/tools/update_sign.cpp +++ b/tools/update_sign.cpp @@ -11,6 +11,10 @@ // update_sign verify checks a manifest (exit 0: good) #include #include +#ifdef _WIN32 +#include +#include +#endif #include #include @@ -78,6 +82,9 @@ static bool read_file(const char *path, std::string *out) { } int main(int argc, char **argv) { +#ifdef _WIN32 + _setmode(_fileno(stdout), _O_BINARY); // (the manifest goes out as signed: LF lines, never CR LF) +#endif std::string cmd = argc > 1 ? argv[1] : ""; if (cmd == "keygen" && argc == 3) { uint8_t seed[32], sk[64], pk[32]; From cf9162416a9fb95f00240f6056beffb5e56c2beb Mon Sep 17 00:00:00 2001 From: Peiikai <339721950+peiikai@users.noreply.github.com> Date: Sun, 15 Nov 2026 19:29:25 -0600 Subject: [PATCH 8/8] Update restart: the new version logs its own startup header The restarted version inherited LASRECOMP_INFO_LOGGED (and would inherit the re-exec markers), so its new session log had no "[info] LAS Recomp " line. The restart now clears what a process passes to its own relaunches, on Windows and Linux. Found in the Windows recheck, which otherwise passed: an unmodified manifest from the fixed tool (no CR bytes) updated, restarted and was kept, with the new version in its own session log. Co-Authored-By: Claude Opus 5.5 --- runtime/update.cpp | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/runtime/update.cpp b/runtime/update.cpp index 14bb8055e..3d1b2fc26 100644 --- a/runtime/update.cpp +++ b/runtime/update.cpp @@ -279,6 +279,20 @@ int update_status(double *frac, char *msg, int n) { return st; } +// What this process passed down to its own relaunches (the same version): the new version starts as a fresh launch, +// its own session log with its own "[info]" header (runtime/main.c, runtime/platform/windows.c) +static void fresh_launch_env(void) { + static const char *const vars[] = {"LASRECOMP_LOG_FILE", "LASRECOMP_INFO_LOGGED", "LARECOMP_REEXEC", "LARECOMP_REEXEC_WHY"}; + for (const char *v : vars) { +#ifdef _WIN32 + _putenv_s(v, ""); + SetEnvironmentVariableA(v, NULL); +#else + unsetenv(v); +#endif + } +} + static void restart_app(const std::string &dir, const std::string &appimage_name) { if (getenv("LARECOMP_UPDATE_NO_RESTART")) { fprintf(stderr, "[update] not restarting (test)\n"); fflush(stderr); end_process(); } fflush(stdout), fflush(stderr); @@ -290,10 +304,7 @@ static void restart_app(const std::string &dir, const std::string &appimage_name wchar_t wpath[1100], wcmd[1200]; MultiByteToWideChar(CP_UTF8, 0, path.c_str(), -1, wpath, 1100); MultiByteToWideChar(CP_UTF8, 0, cmd.c_str(), -1, wcmd, 1200); - // (a new session log for the new version: LASRECOMP_LOG_FILE would make it append to this one's, as a relaunch - // of the same version does - runtime/platform/windows.c) - _putenv_s("LASRECOMP_LOG_FILE", ""); - SetEnvironmentVariableA("LASRECOMP_LOG_FILE", NULL); + fresh_launch_env(); STARTUPINFOW si = {}; si.cb = sizeof si; PROCESS_INFORMATION pi; @@ -310,6 +321,7 @@ static void restart_app(const std::string &dir, const std::string &appimage_name setsid(); // (the new AppImage's runtime sets its own; these name the old one's mount) unsetenv("APPIMAGE"), unsetenv("APPDIR"), unsetenv("ARGV0"); + fresh_launch_env(); if (const char *owd = getenv("OWD")) { if (chdir(owd) != 0) {} } unsetenv("OWD"); execl(path.c_str(), path.c_str(), (char *)NULL);