diff --git a/.github/dependency-review-reviewed-purls.txt b/.github/dependency-review-reviewed-purls.txt index 9524dfdb..3c7e76b9 100644 --- a/.github/dependency-review-reviewed-purls.txt +++ b/.github/dependency-review-reviewed-purls.txt @@ -7,6 +7,8 @@ pkg:githubactions/actions/dependency-review-action pkg:githubactions/actions/download-artifact pkg:githubactions/actions/setup-python pkg:githubactions/actions/upload-artifact +pkg:githubactions/docker/build-push-action +pkg:githubactions/docker/setup-buildx-action pkg:githubactions/github/codeql-action/analyze pkg:githubactions/github/codeql-action/init pkg:githubactions/pypa/gh-action-pypi-publish diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index fcc2c0f2..aefafc1c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -31,7 +31,7 @@ jobs: run: python tools/verify_github_actions_pins.py --self-test tests: - name: Tests (Python ${{ matrix.python-version }}) + name: Tests (Linux, Python ${{ matrix.python-version }}) runs-on: ubuntu-latest strategy: fail-fast: false @@ -41,6 +41,8 @@ jobs: contents: read steps: - uses: actions/checkout@v6 + with: + submodules: recursive - uses: actions/setup-python@v6 with: @@ -54,13 +56,175 @@ jobs: - name: Install package run: python -m pip install --no-deps -e . - # TODO: Re-enable Ruff once the repository has a committed lint baseline or - # focused cleanup for existing violations. Ruff remains configured and - # installed so local cleanup can continue without blocking CI. + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f + + - name: Build libsecp builder image + uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 + with: + context: docker + load: true + tags: embit-libsecp:ci + cache-from: type=gha,scope=embit-libsecp + cache-to: type=gha,mode=max,scope=embit-libsecp + + - name: Build libsecp256k1 (linux/amd64) via container + # --user keeps files written into the bind-mounted workspace owned + # by the runner uid instead of root, so subsequent steps (pytest, + # SHA256SUMS write, etc.) can read and overwrite them. + # build.sh auto-stages the resulting .so at + # secp256k1/secp256k1-zkp/.libs/libsecp256k1.so, so no separate + # staging step is needed. + run: | + docker run --rm \ + --user "$(id -u):$(id -g)" \ + -v "${{ github.workspace }}":/embit \ + embit-libsecp:ci amd64 + file secp256k1/secp256k1-zkp/.libs/libsecp256k1.so + + - name: Tests + run: pytest + + tests-macos: + name: Tests (macOS native, Python 3.13) + runs-on: macos-latest + permissions: + contents: read + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - uses: actions/setup-python@v6 + with: + python-version: "3.13" + cache: pip + cache-dependency-path: constraints-dev.txt + + - name: Install pinned CI dependencies + run: python -m pip install --require-hashes -r constraints-dev.txt + + - name: Install package + run: python -m pip install --no-deps -e . + + - name: Install build tools + run: brew install autoconf automake libtool pkg-config + + - name: Build libsecp256k1 natively + working-directory: secp256k1 + run: make + + - name: Stage libsecp256k1 where the ctypes loader expects it + run: | + mkdir -p secp256k1/secp256k1-zkp/.libs + # Makefile output filename includes platform/arch; pick whichever .dylib landed. + shopt -s nullglob + built=(secp256k1/build/libsecp256k1_*.dylib) + if [ ${#built[@]} -eq 0 ]; then + echo "No libsecp256k1_*.dylib in secp256k1/build/" >&2 + exit 1 + fi + cp "${built[0]}" secp256k1/secp256k1-zkp/.libs/libsecp256k1.dylib + file secp256k1/secp256k1-zkp/.libs/libsecp256k1.dylib - name: Tests run: pytest + cross-compile-validation: + name: Cross-compile validation + runs-on: ubuntu-latest + permissions: + contents: read + steps: + - uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f + + - name: Build libsecp builder image + uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 + with: + context: docker + load: true + tags: embit-libsecp:ci + cache-from: type=gha,scope=embit-libsecp + cache-to: type=gha,mode=max,scope=embit-libsecp + + - name: Cross-compile every reproducible target + # --user keeps the build output owned by the runner uid so the + # SHA256SUMS step below can write into secp256k1/build/. + # `all` is a build.sh pseudo-target that loops over every supported + # arch and continues past individual failures, so this job surfaces + # every broken target at once instead of stopping at the first. + run: | + docker run --rm \ + --user "$(id -u):$(id -g)" \ + -v "${{ github.workspace }}":/embit \ + embit-libsecp:ci all + + - name: Verify each artifact reports the expected architecture + run: | + set -e + ls -la secp256k1/build/ + file secp256k1/build/libsecp256k1_linux_x86_64.so | grep -i 'x86-64' + file secp256k1/build/libsecp256k1_linux_armv6l.so | grep -i 'ARM' | grep -i 'EABI5' + file secp256k1/build/libsecp256k1_linux_armv7l.so | grep -i 'ARM' | grep -i 'EABI5' + file secp256k1/build/libsecp256k1_linux_aarch64.so | grep -i 'aarch64' + file secp256k1/build/libsecp256k1_windows_amd64.dll | grep -i 'PE32+' + + - name: Compute and publish SHA256SUMS for the produced binaries + run: | + set -e + cd secp256k1/build + + # Gather the reproducible-build inputs so consumers can confirm they + # built against the same recipe before comparing hashes. + embit_commit="$(git -C "${{ github.workspace }}" rev-parse HEAD)" + zkp_commit="$(git -C "${{ github.workspace }}/secp256k1/secp256k1-zkp" rev-parse HEAD)" + debian_snapshot="$(grep -E '^ARG DEBIAN_SNAPSHOT=' "${{ github.workspace }}/docker/Dockerfile" | head -n1 | cut -d= -f2)" + # Scan every token after `FROM` and pick the one that starts with + # `debian:`. Robust against the Dockerfile's optional + # `--platform=linux/amd64` token between `FROM` and the image + # reference (and against any future flags that might land there). + debian_digest="$(awk '/^FROM / {for (i=2; i<=NF; i++) if ($i ~ /^debian:/) {print $i; exit}}' "${{ github.workspace }}/docker/Dockerfile")" + + { + echo "# embit commit: ${embit_commit}" + echo "# secp256k1-zkp: ${zkp_commit}" + echo "# debian base image: ${debian_digest}" + echo "# debian snapshot: ${debian_snapshot}" + echo "#" + echo "# Verify against your own Docker build with:" + echo "# docker build -t embit-libsecp docker/ && \\" + echo "# docker run --rm -v \"\$PWD\":/embit embit-libsecp " + echo "# cd secp256k1/build && sha256sum -c SHA256SUMS" + echo "" + sha256sum \ + libsecp256k1_linux_x86_64.so \ + libsecp256k1_linux_armv6l.so \ + libsecp256k1_linux_armv7l.so \ + libsecp256k1_linux_aarch64.so \ + libsecp256k1_windows_amd64.dll + } > SHA256SUMS + + cat SHA256SUMS + + { + echo "## libsecp256k1 SHA256SUMS" + echo "" + echo '```' + cat SHA256SUMS + echo '```' + } >> "$GITHUB_STEP_SUMMARY" + + - name: Upload SHA256SUMS as a workflow artifact + uses: actions/upload-artifact@v7 + with: + name: libsecp256k1-sha256sums + path: secp256k1/build/SHA256SUMS + package: name: Build and verify artifacts runs-on: ubuntu-latest diff --git a/.gitignore b/.gitignore index a2e7c4ef..ca558779 100644 --- a/.gitignore +++ b/.gitignore @@ -135,3 +135,11 @@ settings.json src/embit/util/prebuilt/*.so src/embit/util/prebuilt/*.dylib src/embit/util/prebuilt/*.dll + +## Docker builder artifacts: locally-built libsecp256k1 binaries and ccache +## state. Neither should ever be committed. +secp256k1/build/ +.ccache/ + +#OS files +.DS_Store diff --git a/README.md b/README.md index e9811121..06d04ef0 100644 --- a/README.md +++ b/README.md @@ -25,8 +25,12 @@ To install run `pip3 install embit`. To install in development mode (editable) clone and run `pip3 install -e .` from the root folder. PyPI artifacts are pure Python and do not bundle prebuilt `libsecp256k1` binaries. -If a compatible system `libsecp256k1` is installed, `embit` can use the ctypes backend. -If no compatible system library is available, `embit` automatically falls back to the pure Python implementation. +On CPython, `libsecp256k1` is a hard runtime requirement -- there is no pure-Python +fallback. If the library is missing, `import embit` fails fast with +`embit.util.secp256k1.Libsecp256k1NotAvailable` (a subclass of `ImportError`) +whose message describes how to build the library. This is a build/setup +error, not a runtime condition to be detected later. + ctypes library discovery order is: 1. `secp256k1/secp256k1-zkp/.libs` (repo-local build outputs) @@ -34,7 +38,16 @@ ctypes library discovery order is: 3. system loader (`secp256k1`) 4. `src/embit/util/prebuilt/*` (compatibility-only path; no binaries are shipped in package artifacts) -To build and install `libsecp256k1` locally, see: [Building secp256k1 for `embit`](/secp256k1/README.md). +Build options: +- **Native build on Linux or macOS** -- the existing Makefile in + [`secp256k1/`](/secp256k1/README.md) handles host platform/arch detection. + Fast and dependency-light; recommended for macOS and Linux x86_64 + development. +- **Docker container** -- the self-contained cross-compile environment in + [`docker/`](./docker/README.md) covers ARMv6L (Pi Zero), ARMv7, aarch64, + and Windows. Recommended for any embedded ARM target or Windows build. + See the Docker README for an honest accounting of what is and isn't + reproducible. ## Using non-English BIP39 wordlists diff --git a/docker/Dockerfile b/docker/Dockerfile new file mode 100644 index 00000000..00172c5a --- /dev/null +++ b/docker/Dockerfile @@ -0,0 +1,123 @@ +# Reproducible build environment for libsecp256k1 (the C library that the embit +# ctypes backend wraps). Replaces shipped prebuilt binaries: consumers run this +# container to compile their own .so/.dll for their target. +# +# Targets supported (Linux + Windows + ARM): +# - linux/amd64 (x86_64) +# - linux/arm/v6 (Pi Zero -- armv6l) +# - linux/arm/v7 (Pi 2/3 -- armv7l) +# - linux/arm64 (aarch64) +# - windows/amd64 (mingw cross to .dll) +# +# macOS targets are deliberately NOT supported by this image -- Apple's +# licensing makes Mach-O cross-compilation from Linux awkward, and the native +# `make` workflow on a Mac is fast enough that the isolation gain isn't worth +# the third-party toolchain dependency. See docker/README.md for the macOS +# instructions. +# +# This image is NOT invoked automatically by `pip install embit`. It is a +# deliberate manual step. See docker/README.md. +# +# syntax=docker/dockerfile:1.6 + +# --platform=linux/amd64 forces the image (and any docker run against it) to +# the same host architecture CI uses. Without this, Docker Desktop on Apple +# Silicon would build a linux/arm64 image variant, gcc would run as arm64, +# and even with cross-compilers the produced binaries differ bit-for-bit +# from CI's linux/amd64 build for the amd64/aarch64/windows targets (the +# cross-compiler binary itself embeds host-arch-dependent metadata in +# debug-info / BuildID slots). Pinning the image to linux/amd64 makes +# every consumer's build reproducible against CI; on non-amd64 hosts the +# build runs under QEMU (slower but deterministic). +# +# Pinned by digest so a clean rebuild gets the same Debian image bits as +# the previous one. Bumping this is a deliberate maintainer action -- +# weigh the security updates in the new digest against any toolchain +# churn it pulls in. +# To bump: `docker pull --platform=linux/amd64 debian:bookworm-slim && docker inspect --format='{{index .RepoDigests 0}}' debian:bookworm-slim`. +FROM --platform=linux/amd64 debian:bookworm-slim@sha256:96e378d7e6531ac9a15ad505478fcc2e69f371b10f5cdf87857c4b8188404716 + +ENV DEBIAN_FRONTEND=noninteractive + +# Point apt at snapshot.debian.org so package versions are deterministic. +# Every `apt-get install ` against this snapshot resolves to the same +# version every time, until a maintainer bumps DEBIAN_SNAPSHOT below. +# +# This image is a transient build environment processing trusted input +# (SHA-pinned secp256k1 source); it doesn't run as a service or process +# untrusted data, so we deliberately trade automatic security-update +# pickup for fully-deterministic builds. +# +# To bump the snapshot: pick a recent date from +# https://snapshot.debian.org/archive/debian/?year=...&month=... +# (any YYYYMMDDTHHMMSSZ that resolves -- apt will follow snapshot.debian.org's +# internal redirect to the nearest actual snapshot). +ARG DEBIAN_SNAPSHOT=20260601T000000Z + +# snapshot.debian.org supports HTTPS, but debian:bookworm-slim ships +# without ca-certificates -- so the first apt-get update has to go over +# HTTP. We bootstrap ca-certificates from the snapshot's HTTP endpoint +# (content integrity is still provided by apt's GPG signature chain), +# then swap the sources.list to HTTPS for the larger install in the next +# RUN layer. This adds transport-layer protection (metadata +# confidentiality + an extra integrity check) without sacrificing the +# snapshot-pinned reproducibility for ca-certificates itself. +RUN echo "deb [check-valid-until=no] http://snapshot.debian.org/archive/debian/${DEBIAN_SNAPSHOT}/ bookworm main" > /etc/apt/sources.list && \ + echo "deb [check-valid-until=no] http://snapshot.debian.org/archive/debian-security/${DEBIAN_SNAPSHOT}/ bookworm-security main" >> /etc/apt/sources.list && \ + echo 'Acquire::Check-Valid-Until "false";' > /etc/apt/apt.conf.d/10-snapshot && \ + echo 'Acquire::Retries "5";' >> /etc/apt/apt.conf.d/10-snapshot && \ + apt-get update && \ + apt-get install --no-install-recommends -y ca-certificates && \ + rm -rf /var/lib/apt/lists/* && \ + sed -i 's|http://snapshot.debian.org|https://snapshot.debian.org|g' /etc/apt/sources.list + +RUN apt-get update \ + && apt-get install --no-install-recommends -y \ + autoconf \ + automake \ + build-essential \ + ca-certificates \ + ccache \ + file \ + git \ + gcc-aarch64-linux-gnu \ + gcc-arm-linux-gnueabihf \ + gcc-mingw-w64-x86-64 \ + gcc-x86-64-linux-gnu \ + libc6-dev-amd64-cross \ + libc6-dev-arm64-cross \ + libc6-dev-armhf-cross \ + libtool \ + make \ + pkg-config \ + && rm -rf /var/lib/apt/lists/* + +# Wire ccache symlinks for every cross toolchain. Debian's `ccache` package only +# auto-symlinks the native `gcc`; cross-compilers need explicit symlinks so the +# Makefile's `$(TOOLCHAIN_PREFIX)gcc` invocation routes through ccache without +# any Makefile changes. CCACHE_DIR is bind-mountable so consumers can persist +# the cache between container runs (e.g. -v $PWD/.ccache:/ccache). +RUN set -eux; \ + for triple in arm-linux-gnueabihf aarch64-linux-gnu x86_64-linux-gnu x86_64-w64-mingw32; do \ + ln -sf /usr/bin/ccache /usr/lib/ccache/${triple}-gcc; \ + done + +ENV PATH="/usr/lib/ccache:${PATH}" +ENV CCACHE_DIR=/ccache + +# Pre-create the ccache directory world-writable (sticky bit, like /tmp) so +# the container works correctly whether it runs as root, as the host uid via +# --user, or with a bind-mounted host directory at /ccache. Without this, +# ccache's "create /ccache/tmp" probe fails with Permission denied when the +# container runs as a non-root uid against the image's own /ccache. +RUN mkdir -p /ccache && chmod 1777 /ccache + +WORKDIR /embit + +COPY build.sh /usr/local/bin/build.sh +RUN chmod +x /usr/local/bin/build.sh + +# Default entrypoint exposes the wrapper script. Override with `--entrypoint` +# for ad-hoc shell access. +ENTRYPOINT ["/usr/local/bin/build.sh"] +CMD ["--help"] diff --git a/docker/README.md b/docker/README.md new file mode 100644 index 00000000..464f3caa --- /dev/null +++ b/docker/README.md @@ -0,0 +1,211 @@ +# Building `libsecp256k1` for `embit` via Docker + +`embit`'s ctypes backend wraps the `libsecp256k1` C library. The `embit` Python +package itself ships no compiled binaries -- you have to compile one for your +target platform. + +This directory provides a self-contained Docker build environment so you +don't have to install cross-toolchains on your host. It is **not** invoked +automatically by `pip install embit`. Running it is a deliberate manual step +the first time you set up `embit` on a target platform (and again only when +you bump the `secp256k1-zkp` submodule). + +See [Reproducibility properties](#reproducibility-properties) below for an +honest summary of what is and isn't pinned today. + +## Supported targets + +| Target | Use case | +| --------- | --------------------------------------------------- | +| `amd64` | Native Linux x86_64 build (CI, desktops, servers) | +| `armv6l` | Raspberry Pi Zero | +| `armv7l` | Raspberry Pi 2/3, armhf devices | +| `aarch64` | arm64 Linux (Pi 4/5, embedded ARM) | +| `windows` | Cross-compile to `.dll` via mingw-w64 | + +**macOS is intentionally not supported by this image.** Building natively on +a Mac (see below) is fast and only depends on Xcode Command Line Tools, which +Mac developers already have -- the isolation gain from a Linux container +isn't worth pulling in a third-party cross-toolchain. + +## Quick start (Linux / Windows targets) + +From the **embit repo root**: + +```sh +# Build the image once. +docker build -t embit-libsecp docker/ + +# Pick a target. Output lands in secp256k1/build/. +# --user keeps files written into the bind-mounted workspace owned by your +# shell user (essential on Linux hosts; harmless on macOS). +docker run --rm \ + --user "$(id -u):$(id -g)" \ + -v "$PWD":/embit \ + -v "$PWD/.ccache":/ccache \ + embit-libsecp armv6l +``` + +The resulting file is `secp256k1/build/libsecp256k1_linux_armv6l.so`. The +container also automatically stages a copy at +`secp256k1/secp256k1-zkp/.libs/libsecp256k1.so` (the path the `embit` ctypes +loader checks first), so once the run completes `embit` will pick it up with +no further action. If you want a different deployment layout, copy the +artifact from `secp256k1/build/` to wherever you need it. See the universal +staging notes at +[`../secp256k1/README.md`](../secp256k1/README.md#make-embit-find-your-built-library-all-platforms), +including the macOS / Homebrew compatibility note. + +Re-mount `$PWD/.ccache` on subsequent runs to get fast incremental rebuilds +across targets. The container also publishes a `ccache -s` summary at the end +of every build. + +## macOS + +macOS isn't built inside this container -- build natively on the Mac with +`cd secp256k1 && make`. See [`../secp256k1/README.md`](../secp256k1/README.md) +for the full instructions (including where to drop the resulting `.dylib` so +the loader finds it). CI exercises the macOS path on a `macos-latest` runner. + +## What happens if `libsecp256k1` isn't found + +`import embit` fails fast with +`embit.util.secp256k1.Libsecp256k1NotAvailable` (a subclass of +`ImportError`) and a message describing the search paths that were tried +and pointing at this directory for build instructions. It's a build/setup +error -- fix it by producing a `libsecp256k1` binary with this container +(or building natively per [`../secp256k1/README.md`](../secp256k1/README.md)) +and staging it where the loader will find it. + +## ccache (optional, local-dev only) + +The image installs `ccache` and wires symlinks for every cross-toolchain so +the Makefile's `$(TOOLCHAIN_PREFIX)gcc` invocation transparently caches all +compiles. **CI doesn't use it** -- libsecp256k1 compiles in seconds, so the +overhead of plumbing a third-party action through CI isn't worth the tiny +speedup. Local devs iterating across multiple ARM targets in succession do +benefit; mount a host directory at `/ccache` to persist the cache between +container runs: + +```sh +docker run --rm \ + --user "$(id -u):$(id -g)" \ + -v "$PWD":/embit \ + -v "$PWD/.ccache":/ccache \ + embit-libsecp armv6l +``` + +A `ccache -s` summary prints at the end of each build when `/ccache` is +mounted. Without the mount, ccache still runs inside the container but its +state is thrown away. + +## Reproducibility properties + +This build environment is fully pinned. A clean rebuild today vs. one a +year from now produces the same toolchain bits and the same libsecp256k1 +artifact, provided the maintainer hasn't deliberately bumped one of the +inputs below. + +**Verified cross-host:** CI (`ubuntu-latest`, linux/amd64) and Apple Silicon +(linux/amd64 via Docker Desktop QEMU emulation) produce byte-identical +binaries for all five targets from the same inputs. The `FROM +--platform=linux/amd64` directive in the Dockerfile is what pins host +architecture for the build; without it, gcc-on-arm64 vs gcc-on-amd64 +embed slightly different metadata (BuildID, debug info) and the hashes +diverge for the amd64/aarch64/windows targets. Consumers on non-amd64 +hosts pay a one-time QEMU emulation cost at build time in exchange for +this guarantee. + +**Pinned in this Dockerfile:** +- **`secp256k1-zkp` submodule** -- pinned by git SHA from the embit repo. + Same code in → same C sources out. +- **Debian base image** -- pinned by digest + (`debian:bookworm-slim@sha256:...`). Same digest in → same root + filesystem at the `FROM` step. +- **apt package resolution** -- pinned via + [`snapshot.debian.org`](https://snapshot.debian.org/). The + `DEBIAN_SNAPSHOT` build arg (default in the Dockerfile) points apt at + a frozen archive snapshot from a specific datetime, so every + `apt-get install ` resolves to the same version on every run. + +**Trade-off you should know about:** snapshot pinning means automatic +security updates from Debian are **not** picked up. Bumping the +`DEBIAN_SNAPSHOT` arg or the base-image digest is a deliberate maintainer +action. For a transient build container that processes a SHA-pinned +source tree and exits, this trade-off is the right call -- there's no +persistent attack surface that auto-updates would protect. But if the +project's threat model ever expands, it's worth revisiting. + +**Not in scope of "reproducible" for this image:** +- **Native macOS builds** done outside this container (per + [`../secp256k1/README.md`](../secp256k1/README.md)) depend on whatever + Xcode CLT, host clang, and Homebrew packages are present. They're fine + for personal use on a Mac; they're not a path to shipping the same + binary to multiple consumers. +- **Container layer SHA stability.** Different Docker daemons / BuildKit + versions can produce slightly different layer hashes for the same + inputs (timestamp metadata, etc.). The *contents* are reproducible; + the image's own SHA may vary. Distribute by content hash of the + produced `.so` if you need to verify across consumers. + +### Verifying your build matches CI + +Every CI run publishes a `SHA256SUMS` file covering the five reproducible +targets (`amd64`, `armv6l`, `armv7l`, `aarch64`, `windows`). It's emitted +both as a workflow step-summary (visible at the top of the run page) and +as a downloadable workflow artifact named `libsecp256k1-sha256sums`. The +file's header records the embit commit, the `secp256k1-zkp` submodule +SHA, the Debian base image digest, and the `DEBIAN_SNAPSHOT` value used +for the build -- everything you need to confirm you're comparing apples +to apples. + +To verify your own build matches CI: + +```sh +# Every target uses an explicit cross-compiler inside the container, so the +# produced binary's architecture is fully decoupled from the host. No +# --platform flags needed. --user keeps files written into the +# bind-mounted workspace owned by your shell user. `all` is a pseudo-target +# that builds every supported arch in sequence. +docker build -t embit-libsecp docker/ +docker run --rm --user "$(id -u):$(id -g)" \ + -v "$PWD":/embit embit-libsecp all + +# Drop the SHA256SUMS from the CI artifact into secp256k1/build/ and +# verify: +cd secp256k1/build && sha256sum -c SHA256SUMS +``` + +If the hashes diverge, something in your build inputs differs from CI's +-- check the header in `SHA256SUMS` against your local `git submodule +status` and `docker/Dockerfile`. + +### Bumping the snapshot + +When you want to refresh: + +```sh +# Pick a recent date from https://snapshot.debian.org/archive/debian/ +# (any YYYYMMDDTHHMMSSZ that resolves -- apt follows the internal redirect). +docker build --build-arg DEBIAN_SNAPSHOT=20260901T000000Z -t embit-libsecp docker/ +``` + +If a new version is going into the repo as the default, bump +`ARG DEBIAN_SNAPSHOT=...` in the [Dockerfile](./Dockerfile) directly. +Also bump the base image digest at the same time if you want Debian's +filesystem updates too: + +```sh +docker pull debian:bookworm-slim +docker inspect --format='{{index .RepoDigests 0}}' debian:bookworm-slim +``` + +## Troubleshooting + +- **`secp256k1-zkp submodule is not checked out`** -- run `git submodule + update --init --recursive` in the embit repo first. +- **`macOS targets are not built inside this container`** -- by design. + Build natively on the Mac with `cd secp256k1 && make`. +- **Slow incremental builds** -- make sure `$PWD/.ccache` is mounted at + `/ccache` and writable. The first run primes the cache; subsequent runs + should report a high hit rate from `ccache -s`. diff --git a/docker/build.sh b/docker/build.sh new file mode 100755 index 00000000..90e4a96e --- /dev/null +++ b/docker/build.sh @@ -0,0 +1,182 @@ +#!/usr/bin/env bash +# Convenience wrapper around secp256k1/Makefile that selects the right +# toolchain triple and CFLAGS for a named target. +# +# Source is fixed to secp256k1-zkp (the Blockstream fork) because Liquid +# support requires its extra crypto modules (ECDH, generator, pedersen, +# rangeproof, surjectionproof, musig, schnorrsig). This can be swapped to +# upstream bitcoin-core/secp256k1 in the future, once Liquid lives in a +# separate external module that owns its own zkp build. +# +# Output lands at: +# secp256k1/build/libsecp256k1__.{so,dll} +# (the Makefile decides the filename based on PLATFORM and ARCH it sees.) +# +# Run inside the docker image: +# docker run --rm -v "$PWD":/embit -v "$PWD/.ccache":/ccache embit-libsecp +# +# Targets: +# amd64 Native Linux x86_64 build +# armv6l Cross-compile for Raspberry Pi Zero +# armv7l Cross-compile for Raspberry Pi 2/3 / armhf +# aarch64 Cross-compile for arm64 (Pi 4/5, modern ARM Linux) +# windows Cross-compile to .dll via mingw-w64 +# all Build every target above in sequence. Individual failures +# do not abort the run; the script exits non-zero at the end +# if any target failed, so a single invocation surfaces every +# broken target at once. +# --help Show this message +# +# macOS targets are not supported by this container -- build natively on a +# Mac with the existing secp256k1/Makefile. See docker/README.md. + +set -euo pipefail + +SECP_DIR="/embit/secp256k1" + +usage() { + sed -n '2,30p' "$0" | sed 's/^# \{0,1\}//' +} + +if [ "$#" -lt 1 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then + usage + exit 0 +fi + +TARGET="$1" +shift || true + +# `all` recurses into the script for each supported target. Any extra args +# the caller passed in are forwarded to every per-target invocation. We +# continue past individual failures so a single run shows every broken +# target, then exit non-zero at the end if anything failed. +if [ "${TARGET}" = "all" ]; then + rc=0 + for t in amd64 armv6l armv7l aarch64 windows; do + echo "" + echo "===== build.sh: ${t} =====" + "$0" "${t}" "$@" || rc=$? + done + exit "${rc}" +fi + +if [ ! -d "${SECP_DIR}" ]; then + echo "ERROR: ${SECP_DIR} not found. Mount the embit repo at /embit:" >&2 + echo " docker run --rm -v \"\$PWD\":/embit ... " >&2 + exit 1 +fi + +if [ ! -d "${SECP_DIR}/secp256k1-zkp" ] || [ -z "$(ls -A "${SECP_DIR}/secp256k1-zkp" 2>/dev/null || true)" ]; then + echo "ERROR: secp256k1-zkp submodule is not checked out." >&2 + echo " git submodule update --init --recursive" >&2 + exit 1 +fi + +case "${TARGET}" in + amd64|x86_64|linux-amd64) + # Explicit cross-compiler so the produced binary is x86_64 regardless + # of the container's host architecture. Without this, the build would + # silently produce an arm64 binary when run on Apple Silicon (Docker + # Desktop's default linux/arm64 image variant). + MAKE_ARGS=( + PLATFORM=linux + ARCH=x86_64 + "TOOLCHAIN_PREFIX=x86_64-linux-gnu-" + ) + BUILT_NAME=libsecp256k1_linux_x86_64.so + ;; + armv6l|pi-zero|linux-armv6l) + # -marm forces ARM (not Thumb) instruction selection; ARMv6 Thumb-1 + # does not support hard-float VFP, so without -marm gcc errors out + # with "sorry, unimplemented: Thumb-1 'hard-float' VFP ABI". This + # matches Raspbian's stock toolchain for Pi Zero hard-float builds. + MAKE_ARGS=( + PLATFORM=linux + ARCH=armv6l + "TOOLCHAIN_PREFIX=arm-linux-gnueabihf-" + "CFLAGS=-fPIC -O2 -Werror -Wno-unused-function -march=armv6 -mfpu=vfp -mfloat-abi=hard -marm -I${SECP_DIR}/secp256k1-zkp -I${SECP_DIR}/secp256k1-zkp/src -I${SECP_DIR}/config -DHAVE_CONFIG_H" + ) + BUILT_NAME=libsecp256k1_linux_armv6l.so + ;; + armv7l|pi-2|linux-armv7l) + MAKE_ARGS=( + PLATFORM=linux + ARCH=armv7l + "TOOLCHAIN_PREFIX=arm-linux-gnueabihf-" + "CFLAGS=-fPIC -O2 -Werror -Wno-unused-function -march=armv7-a -mfpu=neon-vfpv4 -mfloat-abi=hard -I${SECP_DIR}/secp256k1-zkp -I${SECP_DIR}/secp256k1-zkp/src -I${SECP_DIR}/config -DHAVE_CONFIG_H" + ) + BUILT_NAME=libsecp256k1_linux_armv7l.so + ;; + aarch64|arm64|linux-aarch64) + MAKE_ARGS=( + PLATFORM=linux + ARCH=aarch64 + "TOOLCHAIN_PREFIX=aarch64-linux-gnu-" + ) + BUILT_NAME=libsecp256k1_linux_aarch64.so + ;; + windows|win|win64|windows-amd64) + MAKE_ARGS=(CROSS_DLL=1) + BUILT_NAME=libsecp256k1_windows_amd64.dll + ;; + darwin-*|macos-*) + echo "ERROR: macOS targets are not built inside this container." >&2 + echo " Build natively on a Mac: 'cd secp256k1 && make'." >&2 + echo " See docker/README.md for details." >&2 + exit 1 + ;; + *) + echo "ERROR: unknown target '${TARGET}'" >&2 + usage >&2 + exit 1 + ;; +esac + +cd "${SECP_DIR}" + +# Remove stale intermediate objects from any previous build that may have +# targeted a different architecture (e.g. an earlier native macOS `make` +# run leaving a Mach-O secp256k1.o behind). Per-target .so/.dll outputs +# in build/ are preserved so consecutive cross-compile invocations don't +# clobber each other. +rm -f build/*.o build/*.d + +make "${MAKE_ARGS[@]}" "$@" + +# Stage only the artifact produced by THIS invocation at the autotools- +# conventional path the embit ctypes loader checks first +# (secp256k1/secp256k1-zkp/.libs/). Staging exactly the current target's +# output -- rather than globbing every libsecp256k1_*.so/.dll in build/ -- +# keeps prior runs' outputs from racing for the staged slot (last-glob-win +# is shell-alphabetical, not what the caller asked for) and ensures the +# staged file matches what the caller actually requested. +LIBS_DIR="${SECP_DIR}/secp256k1-zkp/.libs" +mkdir -p "${LIBS_DIR}" + +case "${BUILT_NAME}" in + *.so) STAGED_NAME=libsecp256k1.so ;; + *.dll) STAGED_NAME=libsecp256k1.dll ;; + *) + echo "ERROR: unexpected BUILT_NAME '${BUILT_NAME}' (no .so/.dll extension)" >&2 + exit 1 + ;; +esac + +if [ ! -f "${SECP_DIR}/build/${BUILT_NAME}" ]; then + echo "ERROR: expected build/${BUILT_NAME} not found after make. Did the build silently fail?" >&2 + exit 1 +fi + +cp "${SECP_DIR}/build/${BUILT_NAME}" "${LIBS_DIR}/${STAGED_NAME}" +echo "Staged: ${SECP_DIR}/build/${BUILT_NAME} -> ${LIBS_DIR}/${STAGED_NAME}" + +# Surface a brief summary of what was built and where. +echo "" +echo "Built artifacts:" +find "${SECP_DIR}/build" -maxdepth 1 -type f \( -name '*.so' -o -name '*.dll' \) -print + +if command -v ccache >/dev/null 2>&1; then + echo "" + echo "ccache stats:" + ccache -s | sed 's/^/ /' +fi diff --git a/secp256k1/Makefile b/secp256k1/Makefile index 45b93bcb..06868e07 100644 --- a/secp256k1/Makefile +++ b/secp256k1/Makefile @@ -12,6 +12,8 @@ ARCH = $(shell uname -m) endif # Paths +# Sourced from secp256k1-zkp for Liquid support; can be swapped to upstream +# bitcoin-core/secp256k1 in the future. LIB_DIR = secp256k1-zkp BUILD_DIR = build @@ -64,8 +66,12 @@ CFLAGS = -fPIC -O2 -Werror -Wno-unused-function \ endif ifeq ($(PLATFORM),windows) +# --no-insert-timestamp keeps the PE32 COFF header's timestamp at 0 so +# successive builds of the same source produce byte-identical .dll files. +# Without it, mingw-w64 fills the slot with wall-clock time and the hash +# changes on every build. LDFLAGS = -shared -s \ - -Wl,--subsystem,windows,--out-implib,$(BUILD_DIR)/$(TARGET).a + -Wl,--subsystem,windows,--no-insert-timestamp,--out-implib,$(BUILD_DIR)/$(TARGET).a EXT = .dll else ifeq ($(PLATFORM),darwin) LDFLAGS = -dynamiclib diff --git a/secp256k1/README.md b/secp256k1/README.md index 502daa47..473a82e9 100644 --- a/secp256k1/README.md +++ b/secp256k1/README.md @@ -1,72 +1,149 @@ # Building secp256k1 for `embit` -`embit` PyPI artifacts do not include prebuilt `libsecp256k1` binaries. -If you want the optional ctypes backend, build and install `libsecp256k1` locally. +`embit` PyPI artifacts do not include prebuilt `libsecp256k1` binaries. On +CPython, `libsecp256k1` is required at runtime; build and install it locally +for your target platform. There is no pure-Python fallback. + +If `libsecp256k1` is missing, `import embit` fails fast with +`embit.util.secp256k1.Libsecp256k1NotAvailable` (a subclass of +`ImportError`) whose message points back to this directory. This is a +build/setup error -- a deployment without `libsecp256k1` is broken and +should never reach an end user. + +## Pick your build path + +| Platform | Recommended path | +| ------------------------------------- | ---------------------------------------------------------------------- | +| macOS (Intel or Apple Silicon) | **Native build** -- see below. Fast, no extra dependencies beyond Xcode CLT. | +| Linux x86_64 (development) | Native build, or the Docker container in [`../docker/`](../docker/) for a self-contained build environment. | +| Linux ARM (Raspberry Pi, embedded) | **Docker container** -- handles cross-compilation for `armv6l`, `armv7l`, `aarch64`. See [`../docker/README.md`](../docker/README.md). | +| Windows (.dll) | **Docker container** -- mingw cross-compile, see [`../docker/README.md`](../docker/README.md). | +| Microcontroller (STM32, ESP32, etc.) | **Built separately in the firmware project's own build environment.** See "Microcontroller targets" below. | ## Clone `embit` recursively -We are using the **libsecp256k1** fork - [**secp256k1-zkp**](https://github.com/ElementsProject/secp256k1-zkp). -Start by cloning `embit` with the `--recursive` flag: +We use the **libsecp256k1** fork -- +[**secp256k1-zkp**](https://github.com/ElementsProject/secp256k1-zkp) -- because +Liquid support needs its extra crypto modules (ECDH, generator, pedersen, +rangeproof, surjectionproof, musig, schnorrsig). + +Start by cloning `embit` with `--recursive`: + ```sh git clone --recursive https://github.com/diybitcoinhardware/embit.git ``` -This will automatically pull in the `libsecp256k1-zkp` repo and checkout the correct commit within that repo. +If you already cloned without `--recursive`, run: + +```sh +git submodule update --init --recursive +``` + +If you see `make: *** No rule to make target 'build/secp256k1.o'`, the +submodule isn't initialized -- run the line above first. +## Native build (Linux, macOS) -## Building the library -This directory (`secp256k1/` in the `embit` root) already has a fully-configured Makefile to run the compilation for you. +This directory (`secp256k1/` in the `embit` root) ships a fully-configured +Makefile that handles `PLATFORM` and `ARCH` detection from `uname` for you. -On your target platform run: ```sh +cd secp256k1 make ``` -Install the resulting library into a standard system library location so the dynamic loader can find it (for example `/usr/local/lib` on Unix-like systems), then refresh your linker environment as needed for your platform. +Output lands at `secp256k1/build/libsecp256k1__.{so,dylib}`. -Note: runtime lookup prefers local `secp256k1/secp256k1-zkp/.libs` and system library paths. -`src/embit/util/prebuilt` is still checked last for compatibility with older local setups, but binaries are not shipped by this project. +### Clean -To clean build directory use: -```shell +```sh make clean ``` +## Make `embit` find your built library (all platforms) -# Cross-compiling Windows DLL +**This step applies to every build path -- native or Docker, Linux, macOS, or +Windows.** The Makefile writes its output to `secp256k1/build/`, but +`embit`'s ctypes loader searches a different set of paths in this order: -## Toolchain install +1. `secp256k1/secp256k1-zkp/.libs/libsecp256k1.{so,dylib,dll}` (autotools convention) +2. System loader (`ctypes.util.find_library("libsecp256k1")` then `"secp256k1"`) +3. `src/embit/util/prebuilt/` (compatibility-only path; no binaries shipped) -### Linux +After building, copy or symlink the artifact into the `.libs/` path so the +loader finds your zkp build first. (The Docker container's `build.sh` +wrapper does this for you automatically. Native `make` does not -- you'll +need to run the `cp` yourself.) Examples (substitute the actual filename for +your platform): -In the console type: - -```shell -sudo apt-get install gcc-mingw-w64-x86-64 g++-mingw-w64-x86-64 wine64 -``` +```sh +mkdir -p secp256k1/secp256k1-zkp/.libs -### Mac +# macOS Apple Silicon +cp secp256k1/build/libsecp256k1_darwin_arm64.dylib \ + secp256k1/secp256k1-zkp/.libs/libsecp256k1.dylib -Assuming that [Homebrew](https://brew.sh/) package manager is installed, in the console type: +# Linux x86_64 +cp secp256k1/build/libsecp256k1_linux_x86_64.so \ + secp256k1/secp256k1-zkp/.libs/libsecp256k1.so -```shell -brew install mingw-w64 -brew install --cask xquartz -brew install --cask wine-stable +# Raspberry Pi Zero (after a Docker cross-compile) +cp secp256k1/build/libsecp256k1_linux_armv6l.so \ + secp256k1/secp256k1-zkp/.libs/libsecp256k1.so ``` -### Windows +Alternatively, install the artifact to a standard system library location +(e.g. `/usr/local/lib` on Unix-like systems with `ldconfig`) so the system +loader resolves it. Either approach works. -Assuming that [Chocolatey](https://chocolatey.org/) package manager is installed, in the **Powershell** type: +### ⚠️ macOS / Homebrew compatibility -```shell -choco install mingw make -``` +If you have Homebrew's `libsecp256k1` installed (`brew install secp256k1`), +you **must** do the `.libs/` copy step above. Homebrew ships upstream +`bitcoin-core/secp256k1`, not the `secp256k1-zkp` fork that `embit` requires: -## Building the library +- Upstream is missing some legacy symbol aliases that `embit`'s ctypes + wrapper binds (e.g. `secp256k1_ec_privkey_negate`, which was renamed to + `secp256k1_ec_seckey_negate`). +- Upstream is missing all of the ZKP/Liquid extras (ECDH, generator, + pedersen, rangeproof, surjectionproof, musig). -To build the Windows DLL and the companion library from other platforms run: +If the loader picks up Homebrew's version before your zkp build, `embit` +will fail to initialize with messages like: -```shell -make CROSS_DLL=1 ``` +dlsym(...): symbol not found -> secp256k1_ec_privkey_negate +``` + +Staging your build at `secp256k1/secp256k1-zkp/.libs/libsecp256k1.dylib` +puts it ahead of the system loader and avoids the conflict. + +## Cross-compilation + +For ARM (Raspberry Pi, embedded) and Windows targets, use the Docker +container at [`../docker/README.md`](../docker/README.md). It bundles all +required cross-toolchains and exposes a single-command wrapper +(`build.sh armv6l`, `build.sh windows`, etc.). See its +"Reproducibility properties" section for what's pinned. + +## Microcontroller targets + +Microcontroller targets (STM32, ESP32-S3, ESP32-P4, and similar embedded +MicroPython platforms) are out of scope for both the native `make` flow here +and the Docker container in [`../docker/`](../docker/). They don't fit +either flow because: + +- **They use project-specific build systems.** Each firmware project pins + its own toolchain and build infrastructure (e.g. ARM GCC + per-board + linker scripts for STM32, ESP-IDF + CMake for ESP32). Neither the + `secp256k1/Makefile` nor the cross-compile Docker image knows how to + drive those. +- **They consume `libsecp256k1` differently.** Embedded MicroPython doesn't + load `libsecp256k1` via `ctypes`; the `secp256k1` native module is + statically linked into the firmware image, so there is no standalone + `.so` for `embit` to discover at runtime. + +For those targets, `libsecp256k1` is compiled as part of the firmware +project's own build, using whatever toolchain and configuration that project +pins. The resulting binding ships inside the firmware -- not through any +path documented here. diff --git a/src/embit/util/py_secp256k1.py b/src/embit/util/py_secp256k1.py deleted file mode 100644 index 0f1f8e1d..00000000 --- a/src/embit/util/py_secp256k1.py +++ /dev/null @@ -1,389 +0,0 @@ -""" -This is a fallback option if the library can't do ctypes bindings to secp256k1 library. -Mimics the micropython bindings and internal representation of data structs in secp256k1. -""" - -from . import key as _key - -# Flags to pass to context_create. -CONTEXT_VERIFY = 0b0100000001 -CONTEXT_SIGN = 0b1000000001 -CONTEXT_NONE = 0b0000000001 - -# Flags to pass to ec_pubkey_serialize -EC_COMPRESSED = 0b0100000010 -EC_UNCOMPRESSED = 0b0000000010 - - -def context_randomize(seed, context=None): - pass - - -def _reverse64(b): - """Converts (a,b) from big to little endian to be consistent with secp256k1""" - x = b[:32] - y = b[32:] - return x[::-1] + y[::-1] - - -def _pubkey_serialize(pub): - """Returns pubkey representation like secp library""" - b = pub.get_bytes()[1:] - return _reverse64(b) - - -def _pubkey_parse(b): - """Returns pubkey class instance""" - pub = _key.ECPubKey() - pub.set(b"\x04" + _reverse64(b)) - return pub - - -def ec_pubkey_create(secret, context=None): - if len(secret) != 32: - raise ValueError("Private key should be 32 bytes long") - pk = _key.ECKey() - pk.set(secret, compressed=False) - if not pk.is_valid: - raise ValueError("Invalid private key") - return _pubkey_serialize(pk.get_pubkey()) - - -def ec_pubkey_parse(sec, context=None): - if len(sec) != 33 and len(sec) != 65: - raise ValueError("Serialized pubkey should be 33 or 65 bytes long") - if len(sec) == 33: - if sec[0] != 0x02 and sec[0] != 0x03: - raise ValueError("Compressed pubkey should start with 0x02 or 0x03") - else: - if sec[0] != 0x04: - raise ValueError("Uncompressed pubkey should start with 0x04") - pub = _key.ECPubKey() - pub.set(sec) - pub.compressed = False - if not pub.is_valid: - raise ValueError("Failed parsing public key") - return _pubkey_serialize(pub) - - -def ec_pubkey_serialize(pubkey, flag=EC_COMPRESSED, context=None): - if len(pubkey) != 64: - raise ValueError("Pubkey should be 64 bytes long") - if flag not in [EC_COMPRESSED, EC_UNCOMPRESSED]: - raise ValueError("Invalid flag") - pub = _pubkey_parse(pubkey) - if not pub.is_valid: - raise ValueError("Failed to serialize pubkey") - if flag == EC_COMPRESSED: - pub.compressed = True - return pub.get_bytes() - - -def ecdsa_signature_parse_compact(compact_sig, context=None): - if len(compact_sig) != 64: - raise ValueError("Compact signature should be 64 bytes long") - sig = _reverse64(compact_sig) - return sig - - -def ecdsa_signature_parse_der(der, context=None): - if der[1] + 2 != len(der): - raise ValueError("Failed parsing compact signature") - if len(der) < 4: - raise ValueError("Failed parsing compact signature") - if der[0] != 0x30: - raise ValueError("Failed parsing compact signature") - if der[2] != 0x02: - raise ValueError("Failed parsing compact signature") - rlen = der[3] - if len(der) < 6 + rlen: - raise ValueError("Failed parsing compact signature") - if rlen < 1 or rlen > 33: - raise ValueError("Failed parsing compact signature") - if der[4] >= 0x80: - raise ValueError("Failed parsing compact signature") - if rlen > 1 and (der[4] == 0) and not (der[5] & 0x80): - raise ValueError("Failed parsing compact signature") - r = int.from_bytes(der[4 : 4 + rlen], "big") - if der[4 + rlen] != 0x02: - raise ValueError("Failed parsing compact signature") - slen = der[5 + rlen] - if slen < 1 or slen > 33: - raise ValueError("Failed parsing compact signature") - if len(der) != 6 + rlen + slen: - raise ValueError("Failed parsing compact signature") - if der[6 + rlen] >= 0x80: - raise ValueError("Failed parsing compact signature") - if slen > 1 and (der[6 + rlen] == 0) and not (der[7 + rlen] & 0x80): - raise ValueError("Failed parsing compact signature") - s = int.from_bytes(der[6 + rlen : 6 + rlen + slen], "big") - - # Verify that r and s are within the group order - if r < 1 or s < 1 or r >= _key.SECP256K1_ORDER or s >= _key.SECP256K1_ORDER: - raise ValueError("Failed parsing compact signature") - if s >= _key.SECP256K1_ORDER_HALF: - raise ValueError("Failed parsing compact signature") - - return r.to_bytes(32, "little") + s.to_bytes(32, "little") - - -def ecdsa_signature_serialize_der(sig, context=None): - if len(sig) != 64: - raise ValueError("Signature should be 64 bytes long") - r = int.from_bytes(sig[:32], "little") - s = int.from_bytes(sig[32:], "little") - rb = r.to_bytes((r.bit_length() + 8) // 8, "big") - sb = s.to_bytes((s.bit_length() + 8) // 8, "big") - return ( - b"\x30" - + bytes([4 + len(rb) + len(sb), 2, len(rb)]) - + rb - + bytes([2, len(sb)]) - + sb - ) - - -def ecdsa_signature_serialize_compact(sig, context=None): - if len(sig) != 64: - raise ValueError("Signature should be 64 bytes long") - return _reverse64(sig) - - -def ecdsa_signature_normalize(sig, context=None): - if len(sig) != 64: - raise ValueError("Signature should be 64 bytes long") - r = int.from_bytes(sig[:32], "little") - s = int.from_bytes(sig[32:], "little") - if s >= _key.SECP256K1_ORDER_HALF: - s = _key.SECP256K1_ORDER - s - return r.to_bytes(32, "little") + s.to_bytes(32, "little") - - -def ecdsa_verify(sig, msg, pub, context=None): - if len(sig) != 64: - raise ValueError("Signature should be 64 bytes long") - if len(msg) != 32: - raise ValueError("Message should be 32 bytes long") - if len(pub) != 64: - raise ValueError("Public key should be 64 bytes long") - pubkey = _pubkey_parse(pub) - return pubkey.verify_ecdsa(ecdsa_signature_serialize_der(sig), msg) - - -def ecdsa_sign(msg, secret, nonce_function=None, extra_data=None, context=None): - if len(msg) != 32: - raise ValueError("Message should be 32 bytes long") - if len(secret) != 32: - raise ValueError("Secret key should be 32 bytes long") - pk = _key.ECKey() - pk.set(secret, False) - sig = pk.sign_ecdsa(msg, nonce_function, extra_data) - return ecdsa_signature_parse_der(sig) - - -def ec_seckey_verify(secret, context=None): - if len(secret) != 32: - raise ValueError("Secret should be 32 bytes long") - pk = _key.ECKey() - pk.set(secret, compressed=False) - return pk.is_valid - - -def ec_privkey_negate(secret, context=None): - # negate in place - if len(secret) != 32: - raise ValueError("Secret should be 32 bytes long") - s = int.from_bytes(secret, "big") - s2 = _key.SECP256K1_ORDER - s - return s2.to_bytes(32, "big") - - -def ec_pubkey_negate(pubkey, context=None): - if len(pubkey) != 64: - raise ValueError("Pubkey should be a 64-byte structure") - sec = ec_pubkey_serialize(pubkey) - return ec_pubkey_parse(bytes([0x05 - sec[0]]) + sec[1:]) - - -def ec_privkey_tweak_add(secret, tweak, context=None): - res = ec_privkey_add(secret, tweak) - for i in range(len(secret)): - secret[i] = res[i] - - -def ec_pubkey_tweak_add(pub, tweak, context=None): - res = ec_pubkey_add(pub, tweak) - for i in range(len(pub)): - pub[i] = res[i] - - -def ec_privkey_add(secret, tweak, context=None): - if len(secret) != 32 or len(tweak) != 32: - raise ValueError("Secret and tweak should both be 32 bytes long") - s = int.from_bytes(secret, "big") - t = int.from_bytes(tweak, "big") - r = (s + t) % _key.SECP256K1_ORDER - return r.to_bytes(32, "big") - - -def ec_pubkey_add(pub, tweak, context=None): - if len(pub) != 64: - raise ValueError("Public key should be 64 bytes long") - if len(tweak) != 32: - raise ValueError("Tweak should be 32 bytes long") - pubkey = _pubkey_parse(pub) - pubkey.compressed = True - t = int.from_bytes(tweak, "big") - Q = _key.SECP256K1.affine( - _key.SECP256K1.mul([(_key.SECP256K1_G, t), (pubkey.p, 1)]) - ) - if Q is None: - return None - return Q[0].to_bytes(32, "little") + Q[1].to_bytes(32, "little") - - -# def ec_privkey_tweak_mul(secret, tweak, context=None): -# if len(secret)!=32 or len(tweak)!=32: -# raise ValueError("Secret and tweak should both be 32 bytes long") -# s = int.from_bytes(secret, 'big') -# t = int.from_bytes(tweak, 'big') -# if t > _key.SECP256K1_ORDER or s > _key.SECP256K1_ORDER: -# raise ValueError("Failed to tweak the secret") -# r = pow(s, t, _key.SECP256K1_ORDER) -# res = r.to_bytes(32, 'big') -# for i in range(len(secret)): -# secret[i] = res[i] - -# def ec_pubkey_tweak_mul(pub, tweak, context=None): -# if len(pub)!=64: -# raise ValueError("Public key should be 64 bytes long") -# if len(tweak)!=32: -# raise ValueError("Tweak should be 32 bytes long") -# if _secp.secp256k1_ec_pubkey_tweak_mul(context, pub, tweak) == 0: -# raise ValueError("Failed to tweak the public key") - -# def ec_pubkey_combine(*args, context=None): -# pub = bytes(64) -# pubkeys = (c_char_p * len(args))(*args) -# r = _secp.secp256k1_ec_pubkey_combine(context, pub, pubkeys, len(args)) -# if r == 0: -# raise ValueError("Failed to negate pubkey") -# return pub - -# schnorrsig - - -def xonly_pubkey_from_pubkey(pubkey, context=None): - if len(pubkey) != 64: - raise ValueError("Pubkey should be 64 bytes long") - sec = ec_pubkey_serialize(pubkey) - parity = sec[0] == 0x03 - pub = ec_pubkey_parse(b"\x02" + sec[1:33]) - return pub, parity - - -def schnorrsig_verify(sig, msg, pubkey, context=None): - if len(sig) != 64: - raise ValueError("Signature should be 64 bytes long") - if len(msg) != 32: - raise ValueError("Message should be 32 bytes long") - if len(pubkey) != 64: - raise ValueError("Public key should be 64 bytes long") - sec = ec_pubkey_serialize(pubkey) - return _key.verify_schnorr(sec[1:33], sig, msg) - - -def keypair_create(secret, context=None): - pub = ec_pubkey_create(secret) - pub2, parity = xonly_pubkey_from_pubkey(pub) - keypair = secret + pub - return keypair - - -def schnorrsig_sign(msg, keypair, nonce_function=None, extra_data=None, context=None): - if len(msg) != 32: - raise ValueError("Message should be 32 bytes long") - if len(keypair) == 32: - keypair = keypair_create(keypair, context=context) - if len(keypair) != 96: - raise ValueError("Keypair should be 96 bytes long") - return _key.sign_schnorr(keypair[:32], msg, extra_data) - - -# recoverable - - -def ecdsa_sign_recoverable(msg, secret, context=None): - sig = ecdsa_sign(msg, secret) - pub = ec_pubkey_create(secret) - # Search for correct index. Not efficient but I am lazy. - # For efficiency use c-bindings to libsecp256k1 - for i in range(4): - if ecdsa_recover(sig + bytes([i]), msg) == pub: - return sig + bytes([i]) - raise ValueError("Failed to sign") - - -def ecdsa_recoverable_signature_serialize_compact(sig, context=None): - if len(sig) != 65: - raise ValueError("Recoverable signature should be 65 bytes long") - compact = ecdsa_signature_serialize_compact(sig[:64]) - return compact, sig[64] - - -def ecdsa_recoverable_signature_parse_compact(compact_sig, recid, context=None): - if len(compact_sig) != 64: - raise ValueError("Signature should be 64 bytes long") - # TODO: also check r value so recid > 2 makes sense - if recid < 0 or recid > 4: - raise ValueError("Failed parsing compact signature") - return ecdsa_signature_parse_compact(compact_sig) + bytes([recid]) - - -def ecdsa_recoverable_signature_convert(sigin, context=None): - if len(sigin) != 65: - raise ValueError("Recoverable signature should be 65 bytes long") - return sigin[:64] - - -def ecdsa_recover(sig, msghash, context=None): - if len(sig) != 65: - raise ValueError("Recoverable signature should be 65 bytes long") - if len(msghash) != 32: - raise ValueError("Message should be 32 bytes long") - idx = sig[-1] - r = int.from_bytes(sig[:32], "little") - s = int.from_bytes(sig[32:64], "little") - z = int.from_bytes(msghash, "big") - # r = Rx mod N, so R can be 02x, 03x, 02(N+x), 03(N+x) - # two latter cases only if N+x < P - r_candidates = [ - b"\x02" + r.to_bytes(32, "big"), - b"\x03" + r.to_bytes(32, "big"), - ] - if r + _key.SECP256K1_ORDER < _key.SECP256K1_FIELD_SIZE: - r2 = r + _key.SECP256K1_ORDER - r_candidates = r_candidates + [ - b"\x02" + r2.to_bytes(32, "big"), - b"\x03" + r2.to_bytes(32, "big"), - ] - if idx >= len(r_candidates): - raise ValueError("Failed to recover public key") - R = _key.ECPubKey() - R.set(r_candidates[idx]) - # s = (z + d * r)/k - # (R*s/r - z/r*G) = P - rinv = _key.modinv(r, _key.SECP256K1_ORDER) - u1 = (s * rinv) % _key.SECP256K1_ORDER - u2 = (z * rinv) % _key.SECP256K1_ORDER - P1 = _key.SECP256K1.mul([(R.p, u1)]) - P2 = _key.SECP256K1.negate(_key.SECP256K1.mul([(_key.SECP256K1_G, u2)])) - P = _key.SECP256K1.affine(_key.SECP256K1.add(P1, P2)) - result = P[0].to_bytes(32, "little") + P[1].to_bytes(32, "little") - # verify signature at the end - pubkey = _pubkey_parse(result) - if not pubkey.is_valid: - raise ValueError("Failed to recover public key") - if not ecdsa_verify(sig[:64], msghash, result): - raise ValueError("Failed to recover public key") - return result diff --git a/src/embit/util/secp256k1.py b/src/embit/util/secp256k1.py index a616bc64..ee1d7758 100644 --- a/src/embit/util/secp256k1.py +++ b/src/embit/util/secp256k1.py @@ -1,76 +1,143 @@ -# ruff: noqa: F403, E722 +# ruff: noqa: F403 +# +# secp256k1 backend selector. +# +# On MicroPython this re-exports the native ``secp256k1`` module if present. +# On CPython this re-exports ``ctypes_secp256k1`` if libsecp256k1 can be +# loaded. If neither path can resolve the bindings, importing this module +# raises ``Libsecp256k1NotAvailable`` (a subclass of ``ImportError``) with +# a message describing how to install or build the library. This is a hard +# setup-time failure -- a deployment without libsecp256k1 is broken, not a +# soft runtime condition to detect. + + +class Libsecp256k1NotAvailable(ImportError): + """Raised at import time when libsecp256k1 bindings cannot be loaded. + + Always raise with ``raise Libsecp256k1NotAvailable() from `` + so the underlying loader failure is recorded as the direct cause in + tracebacks. + """ + + MESSAGE = ( + "libsecp256k1 not found. embit requires libsecp256k1 at import time.\n" + "\n" + "On CPython, the recommended way to build it is the Docker " + "container at docker/ in the embit source tree -- see " + "docker/README.md. You may also place a prebuilt libsecp256k1 " + "shared library on your system loader path or at " + "secp256k1/secp256k1-zkp/.libs/ in the embit source tree.\n" + "\n" + "On MicroPython, rebuild the firmware with the secp256k1 native " + "module enabled." + ) + + def __init__(self, message=None): + super().__init__(message if message is not None else self.MESSAGE) + + try: - # if it's micropython - # `from micropython import const` is the discriminator: it raises ImportError on - # CPython, forcing the fallback branch. Without it, `from secp256k1 import *` - # can resolve to the repo-local `secp256k1/` libsecp256k1 build directory as an - # implicit namespace package and silently succeed with an empty namespace. + # MicroPython discriminator: this import raises ImportError on CPython. + # Without it, ``from secp256k1 import *`` could resolve to the repo-local + # ``secp256k1/`` directory as an implicit namespace package on CPython + # and silently succeed with an empty namespace. from micropython import const # noqa: F401 - from secp256k1 import * -except: - # we are in python + + try: + from secp256k1 import * + except Exception as _mp_exc: + raise Libsecp256k1NotAvailable() from _mp_exc +except Libsecp256k1NotAvailable: + # Re-raise so the outer ImportError clause below doesn't swallow it. + raise +except ImportError: + # CPython branch: ``from micropython import const`` raised ImportError, + # confirming we're not on MicroPython. Only catch ImportError here so + # unrelated runtime errors from a MicroPython environment surface as + # themselves instead of being misrouted to the CPython loader. try: - # try ctypes bindings from . import ctypes_secp256k1 as _ctypes_secp256k1 from .ctypes_secp256k1 import * - _secp = _ctypes_secp256k1._secp + except Exception as _cp_exc: + raise Libsecp256k1NotAvailable() from _cp_exc + + _secp = _ctypes_secp256k1._secp + + # Symbols that may not be present in every libsecp build. We drop the + # corresponding wrapper from globals() when the underlying C symbol is + # missing, so capability-dependent tests skip via + # ``hasattr(secp256k1, name)`` instead of erroring at call time. + + def _has_ctypes_symbol(symbol_name): + try: + getattr(_secp, symbol_name) + return True + except AttributeError: + return False + + # Removed from upstream `bitcoin-core/secp256k1` v0.7.0+; present in + # zkp and upstream <= v0.6.0. + _RELEASE_REMOVED_SYMBOLS = { + "ec_privkey_tweak_mul": "secp256k1_ec_privkey_tweak_mul", + } - # For optional modules (ECDH/Schnorr/recovery/ZKP), keep ctypes when symbols - # are exported by the loaded library, otherwise use pure-Python fallbacks when - # available or hide the API so tests can skip capability-dependent paths. - from . import py_secp256k1 as _py_secp256k1 + # Optional modules in upstream `bitcoin-core/secp256k1`. A maintainer + # can compile these in or out via libsecp's ``--enable-module-*`` + # configure flags. Always present in zkp. + _UPSTREAM_OPTIONAL_MODULE_SYMBOLS = { + # --enable-module-ecdh + "ecdh": "secp256k1_ecdh", + # --enable-module-extrakeys + "xonly_pubkey_from_pubkey": "secp256k1_xonly_pubkey_from_pubkey", + # --enable-module-schnorrsig + "schnorrsig_verify": "secp256k1_schnorrsig_verify", + "schnorrsig_sign": "secp256k1_schnorrsig_sign", + "keypair_create": "secp256k1_keypair_create", + # --enable-module-recovery + "ecdsa_sign_recoverable": "secp256k1_ecdsa_sign_recoverable", + "ecdsa_recoverable_signature_parse_compact": ( + "secp256k1_ecdsa_recoverable_signature_parse_compact" + ), + "ecdsa_recoverable_signature_serialize_compact": ( + "secp256k1_ecdsa_recoverable_signature_serialize_compact" + ), + "ecdsa_recoverable_signature_convert": ( + "secp256k1_ecdsa_recoverable_signature_convert" + ), + "ecdsa_recover": "secp256k1_ecdsa_recover", + } - def _has_ctypes_symbol(symbol_name): - try: - getattr(_secp, symbol_name) - return True - except AttributeError: - return False + # Confidential-transaction primitives that exist only in the + # secp256k1-zkp fork. + _ZKP_ONLY_SYMBOLS = { + "generator_parse": "secp256k1_generator_parse", + "generator_generate": "secp256k1_generator_generate", + "generator_generate_blinded": "secp256k1_generator_generate_blinded", + "generator_serialize": "secp256k1_generator_serialize", + "pedersen_commitment_parse": "secp256k1_pedersen_commitment_parse", + "pedersen_commitment_serialize": "secp256k1_pedersen_commitment_serialize", + "pedersen_commit": "secp256k1_pedersen_commit", + "pedersen_blind_generator_blind_sum": ( + "secp256k1_pedersen_blind_generator_blind_sum" + ), + "pedersen_verify_tally": "secp256k1_pedersen_verify_tally", + "rangeproof_rewind": "secp256k1_rangeproof_rewind", + "rangeproof_verify": "secp256k1_rangeproof_verify", + "rangeproof_sign": "secp256k1_rangeproof_sign", + "surjectionproof_initialize": "secp256k1_surjectionproof_initialize", + "surjectionproof_generate": "secp256k1_surjectionproof_generate", + "surjectionproof_verify": "secp256k1_surjectionproof_verify", + "surjectionproof_serialize": "secp256k1_surjectionproof_serialize", + "surjectionproof_parse": "secp256k1_surjectionproof_parse", + } - _OPTIONAL_SYMBOLS = { - "ecdh": "secp256k1_ecdh", - "xonly_pubkey_from_pubkey": "secp256k1_xonly_pubkey_from_pubkey", - "schnorrsig_verify": "secp256k1_schnorrsig_verify", - "schnorrsig_sign": "secp256k1_schnorrsig_sign", - "keypair_create": "secp256k1_keypair_create", - "ecdsa_sign_recoverable": "secp256k1_ecdsa_sign_recoverable", - "ecdsa_recoverable_signature_parse_compact": ( - "secp256k1_ecdsa_recoverable_signature_parse_compact" - ), - "ecdsa_recoverable_signature_serialize_compact": ( - "secp256k1_ecdsa_recoverable_signature_serialize_compact" - ), - "ecdsa_recoverable_signature_convert": ( - "secp256k1_ecdsa_recoverable_signature_convert" - ), - "ecdsa_recover": "secp256k1_ecdsa_recover", - "generator_parse": "secp256k1_generator_parse", - "generator_generate": "secp256k1_generator_generate", - "generator_generate_blinded": "secp256k1_generator_generate_blinded", - "generator_serialize": "secp256k1_generator_serialize", - "pedersen_commitment_parse": "secp256k1_pedersen_commitment_parse", - "pedersen_commitment_serialize": "secp256k1_pedersen_commitment_serialize", - "pedersen_commit": "secp256k1_pedersen_commit", - "pedersen_blind_generator_blind_sum": ( - "secp256k1_pedersen_blind_generator_blind_sum" - ), - "pedersen_verify_tally": "secp256k1_pedersen_verify_tally", - "rangeproof_rewind": "secp256k1_rangeproof_rewind", - "rangeproof_verify": "secp256k1_rangeproof_verify", - "rangeproof_sign": "secp256k1_rangeproof_sign", - "surjectionproof_initialize": "secp256k1_surjectionproof_initialize", - "surjectionproof_generate": "secp256k1_surjectionproof_generate", - "surjectionproof_verify": "secp256k1_surjectionproof_verify", - "surjectionproof_serialize": "secp256k1_surjectionproof_serialize", - "surjectionproof_parse": "secp256k1_surjectionproof_parse", - } - for _name, _symbol in _OPTIONAL_SYMBOLS.items(): - if _has_ctypes_symbol(_symbol): - continue - if hasattr(_py_secp256k1, _name): - globals()[_name] = getattr(_py_secp256k1, _name) - elif _name in globals(): - del globals()[_name] - except: - # fallback to python version - from .py_secp256k1 import * + _OPTIONAL_SYMBOLS = { + **_RELEASE_REMOVED_SYMBOLS, + **_UPSTREAM_OPTIONAL_MODULE_SYMBOLS, + **_ZKP_ONLY_SYMBOLS, + } + for _name, _symbol in _OPTIONAL_SYMBOLS.items(): + if _has_ctypes_symbol(_symbol): + continue + if _name in globals(): + del globals()[_name] diff --git a/tests/tests/__init__.py b/tests/tests/__init__.py index 2593ae54..8f376d3c 100644 --- a/tests/tests/__init__.py +++ b/tests/tests/__init__.py @@ -17,5 +17,5 @@ if sys.implementation.name != "micropython": from .test_ecdh import * from .test_ripemd160 import * - from .test_bindings import * + from .bindings import * from .test_threading import * diff --git a/tests/tests/bindings/__init__.py b/tests/tests/bindings/__init__.py new file mode 100644 index 00000000..6e5cb590 --- /dev/null +++ b/tests/tests/bindings/__init__.py @@ -0,0 +1 @@ +from .test_bindings import * # noqa: F401, F403 diff --git a/tests/tests/bindings/_helper_libsecp_load_failure.py b/tests/tests/bindings/_helper_libsecp_load_failure.py new file mode 100644 index 00000000..5afd84bb --- /dev/null +++ b/tests/tests/bindings/_helper_libsecp_load_failure.py @@ -0,0 +1,57 @@ +"""Subprocess helper for `WrapperImportTest` in `test_bindings.py`. + +Run as ``python _helper_libsecp_load_failure.py``. Installs a meta-path +entry that makes ``embit.util.ctypes_secp256k1`` raise at import time +(simulating the real-world "libsecp256k1 not found" scenario, which is +how ``ctypes_secp256k1``'s module-level ``_secp = _init()`` fails in +production), then triggers the selector module's import to exercise the +fail-fast path. + +Output (one per line on stdout, exit 0): + 1. Fully-qualified exception type from the selector's import-time raise. + 2. ``__cause__`` exception type, or ``NO_CAUSE`` if absent. + 3. ``str(__cause__)``, or empty string if absent. + +Exits 1 if the import unexpectedly succeeded (treat that as a test failure +in the calling test case). + +The underscore-prefixed filename keeps pytest from auto-collecting this +file as a test module while still letting it live next to the test that +uses it. +""" + +import importlib.abc +import importlib.util +import sys + + +class _FailLoader(importlib.abc.Loader): + def create_module(self, spec): + return None + + def exec_module(self, module): + raise RuntimeError("simulated libsecp loader failure") + + +class _FailFinder(importlib.abc.MetaPathFinder): + def find_spec(self, name, path, target=None): + if name == "embit.util.ctypes_secp256k1": + return importlib.util.spec_from_loader(name, _FailLoader()) + return None + + +def main(): + sys.meta_path.insert(0, _FailFinder()) + try: + from embit.util import secp256k1 # noqa: F401 + except Exception as exc: + print("{0}.{1}".format(type(exc).__module__, type(exc).__name__)) + cause = exc.__cause__ + print(type(cause).__name__ if cause is not None else "NO_CAUSE") + print(str(cause) if cause is not None else "") + sys.exit(0) + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/tests/tests/bindings/test_bindings.py b/tests/tests/bindings/test_bindings.py new file mode 100644 index 00000000..f07a8c72 --- /dev/null +++ b/tests/tests/bindings/test_bindings.py @@ -0,0 +1,181 @@ +from binascii import hexlify +from unittest import TestCase, skipUnless +from embit.util import ctypes_secp256k1, secp256k1 + +# Schnorr and ECDSA recovery are optional modules in both upstream secp256k1 +# and zkp. If a future build of embit targets a libsecp256k1 without these +# modules enabled, these checks let the test suite skip cleanly instead of +# erroring out. +# +# Capability is checked against the `embit.util.secp256k1` selector module +# (imported as `secp256k1` above) rather than against `ctypes_secp256k1` +# directly. The selector imports ctypes_secp256k1 and then walks an +# `_OPTIONAL_SYMBOLS` table, pruning names whose underlying C symbols +# weren't present in the loaded library. So `hasattr(secp256k1, name)` is +# the source of truth for "is this capability available?" -- +# `hasattr(ctypes_secp256k1, name)` would always return True because the +# ctypes-binding Python functions are defined unconditionally regardless +# of which C symbols actually exist in libsecp256k1. +_SCHNORR_AVAILABLE = all( + hasattr(secp256k1, name) + for name in ( + "xonly_pubkey_from_pubkey", + "schnorrsig_sign", + "schnorrsig_verify", + "keypair_create", + ) +) +_RECOVERY_AVAILABLE = all( + hasattr(secp256k1, name) + for name in ( + "ecdsa_sign_recoverable", + "ecdsa_recoverable_signature_serialize_compact", + "ecdsa_recoverable_signature_parse_compact", + "ecdsa_recoverable_signature_convert", + "ecdsa_recover", + ) +) + + +class BindingsTest(TestCase): + def test_identity(self): + """1 * G""" + answer = ( + b"0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179" + b"8483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8" + ) + one = 1 + bone = one.to_bytes(32, "big") + g = ctypes_secp256k1.ec_pubkey_create(bone) + der = ctypes_secp256k1.ec_pubkey_serialize(g, ctypes_secp256k1.EC_UNCOMPRESSED) + g_hex = hexlify(der) + self.assertEqual(answer, g_hex) + + def test_cross(self): + secret = b"5" * 32 + pub1 = ctypes_secp256k1.ec_pubkey_create(secret) + der = ctypes_secp256k1.ec_pubkey_serialize(pub1) + self.assertEqual(pub1, ctypes_secp256k1.ec_pubkey_parse(der)) + + msg = b"7" * 32 + sig = ctypes_secp256k1.ecdsa_sign(msg, secret) + + # extra data is accepted + sig_extra = ctypes_secp256k1.ecdsa_sign(msg, secret, None, b"1" * 32) + + compact = ctypes_secp256k1.ecdsa_signature_serialize_compact(sig) + der = ctypes_secp256k1.ecdsa_signature_serialize_der(sig) + self.assertEqual(sig, ctypes_secp256k1.ecdsa_signature_parse_compact(compact)) + self.assertEqual(sig, ctypes_secp256k1.ecdsa_signature_parse_der(der)) + + # The extra-data variant must also survive the same serialize/parse + # roundtrips so a regression in the aux-data signing path can't sneak + # past as a "we verified, that's enough" pass. + compact_extra = ctypes_secp256k1.ecdsa_signature_serialize_compact(sig_extra) + der_extra = ctypes_secp256k1.ecdsa_signature_serialize_der(sig_extra) + self.assertEqual( + sig_extra, + ctypes_secp256k1.ecdsa_signature_parse_compact(compact_extra), + ) + self.assertEqual( + sig_extra, + ctypes_secp256k1.ecdsa_signature_parse_der(der_extra), + ) + + self.assertEqual(ctypes_secp256k1.ecdsa_verify(sig, msg, pub1), True) + self.assertEqual(ctypes_secp256k1.ecdsa_verify(sig_extra, msg, pub1), True) + self.assertEqual(ctypes_secp256k1.ecdsa_verify(sig, b"a" * 32, pub1), False) + + # tweak via privkey and via pubkey reach the same point + tweak = b"9" * 32 + tweaked_priv = ctypes_secp256k1.ec_privkey_add(secret, tweak) + self.assertEqual( + ctypes_secp256k1.ec_pubkey_create(tweaked_priv), + ctypes_secp256k1.ec_pubkey_add(pub1, tweak), + ) + + @skipUnless( + _SCHNORR_AVAILABLE, + "secp256k1 build is missing the Schnorr module", + ) + def test_schnorr(self): + for i in range(1, 10): + secret = bytes([i] * 32) + pub1 = ctypes_secp256k1.ec_pubkey_create(secret) + pub1, par = ctypes_secp256k1.xonly_pubkey_from_pubkey(pub1) + msg = b"q" * 32 + + # without aux data + sig_no_aux = ctypes_secp256k1.schnorrsig_sign(msg, secret) + + # with aux data + sig_with_aux = ctypes_secp256k1.schnorrsig_sign(msg, secret, None, b"4" * 32) + + self.assertTrue(ctypes_secp256k1.schnorrsig_verify(sig_no_aux, msg, pub1)) + self.assertTrue(ctypes_secp256k1.schnorrsig_verify(sig_with_aux, msg, pub1)) + + self.assertFalse(ctypes_secp256k1.schnorrsig_verify(sig_no_aux, b"w" * 32, pub1)) + self.assertFalse(ctypes_secp256k1.schnorrsig_verify(sig_with_aux, b"w" * 32, pub1)) + + # libsecp's keypair structure is a 96-byte opaque blob (32-byte + # secret + 64-byte uncompressed pubkey). Assert the length so a + # binding-level shape regression fails here rather than at a + # downstream consumer. + keypair = ctypes_secp256k1.keypair_create(secret) + self.assertEqual(len(keypair), 96) + + @skipUnless( + _RECOVERY_AVAILABLE, + "secp256k1 build is missing the ECDSA recovery module", + ) + def test_recovery(self): + secret = b"1" * 32 + msg = b"2" * 32 + sig = ctypes_secp256k1.ecdsa_sign_recoverable(msg, secret) + self.assertEqual(len(sig), 65) + + # sign/recover roundtrip: the recovered pubkey matches the secret's pubkey + expected_pub = ctypes_secp256k1.ec_pubkey_create(secret) + self.assertEqual(ctypes_secp256k1.ecdsa_recover(sig, msg), expected_pub) + + +class WrapperImportTest(TestCase): + """End-to-end coverage of the selector module's fail-fast behavior. + + These tests live separately from BindingsTest because they don't exercise + the libsecp256k1 bindings -- they exercise what `embit.util.secp256k1` + does when those bindings cannot be loaded. They run in a subprocess so + we get a clean import state (once `embit.util.secp256k1` has been + imported successfully by other tests in the suite, it can't be reliably + unloaded and re-loaded in-process). The subprocess script lives next + to this file as `_helper_libsecp_load_failure.py`. + """ + + def test_libsecp_load_failure_raises_with_chained_cause(self): + """Verifies the contract that future maintenance can't silently break: + when the underlying ctypes module fails at import time, the selector + raises Libsecp256k1NotAvailable with the original error chained as + __cause__. Catches regressions like dropping the `from _cp_exc` + clause or widening the `except ImportError:` to a bare `except:`. + """ + import os + import subprocess + import sys + + helper = os.path.join( + os.path.dirname(__file__), "_helper_libsecp_load_failure.py" + ) + result = subprocess.run( + [sys.executable, helper], capture_output=True, text=True + ) + + self.assertEqual( + result.returncode, + 0, + "subprocess did not raise on the wrapper import; " + "stdout={!r} stderr={!r}".format(result.stdout, result.stderr), + ) + lines = result.stdout.strip().split("\n") + self.assertEqual(lines[0], "embit.util.secp256k1.Libsecp256k1NotAvailable") + self.assertEqual(lines[1], "RuntimeError") + self.assertEqual(lines[2], "simulated libsecp loader failure") diff --git a/tests/tests/test_bindings.py b/tests/tests/test_bindings.py deleted file mode 100644 index d0cbc519..00000000 --- a/tests/tests/test_bindings.py +++ /dev/null @@ -1,172 +0,0 @@ -from binascii import hexlify -from unittest import TestCase, skipUnless -from embit.util import py_secp256k1 - -try: - from embit.util import ctypes_secp256k1 -except Exception: # pragma: no cover - environment dependent - ctypes_secp256k1 = None - print( - "[tests] libsecp256k1 ctypes backend unavailable; " - "skipping ctypes parity tests and using pure-Python fallback." - ) - _CTYPES_AVAILABLE = False -else: - _CTYPES_AVAILABLE = True - _CTYPES_SECP = getattr(ctypes_secp256k1, "_secp", None) - - -def _ctypes_has_symbol(name): - if not _CTYPES_AVAILABLE or _CTYPES_SECP is None: - return False - try: - getattr(_CTYPES_SECP, name) - return True - except AttributeError: - return False - - -_RECOVERY_AVAILABLE = all( - _ctypes_has_symbol(symbol) - for symbol in ( - "secp256k1_ecdsa_sign_recoverable", - "secp256k1_ecdsa_recoverable_signature_parse_compact", - "secp256k1_ecdsa_recoverable_signature_serialize_compact", - "secp256k1_ecdsa_recoverable_signature_convert", - "secp256k1_ecdsa_recover", - ) -) -_SCHNORR_AVAILABLE = all( - _ctypes_has_symbol(symbol) - for symbol in ( - "secp256k1_xonly_pubkey_from_pubkey", - "secp256k1_schnorrsig_verify", - "secp256k1_schnorrsig_sign", - "secp256k1_keypair_create", - ) -) - - -@skipUnless( - _CTYPES_AVAILABLE, - "libsecp256k1 ctypes backend unavailable; pure-Python fallback in use", -) -class BindingsTest(TestCase): - def test_identity(self): - """1 * G""" - for secp256k1 in [py_secp256k1, ctypes_secp256k1]: - answer = ( - b"0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179" - b"8483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8" - ) - one = 1 - bone = one.to_bytes(32, "big") - g = secp256k1.ec_pubkey_create(bone) - der = secp256k1.ec_pubkey_serialize(g, secp256k1.EC_UNCOMPRESSED) - g_hex = hexlify(der) - self.assertEqual(answer, g_hex) - - def test_cross(self): - secret = b"5" * 32 - pub1 = ctypes_secp256k1.ec_pubkey_create(secret) - pub2 = py_secp256k1.ec_pubkey_create(secret) - self.assertEqual(pub1, pub2) - der = ctypes_secp256k1.ec_pubkey_serialize(pub1) - self.assertEqual(der, py_secp256k1.ec_pubkey_serialize(pub1)) - self.assertEqual( - ctypes_secp256k1.ec_pubkey_parse(der), py_secp256k1.ec_pubkey_parse(der) - ) - - msg = b"7" * 32 - sig = ctypes_secp256k1.ecdsa_sign(msg, secret) - self.assertEqual(sig, py_secp256k1.ecdsa_sign(msg, secret)) - - # check that extra data is handled in the same way - sig = ctypes_secp256k1.ecdsa_sign(msg, secret, None, b"1" * 32) - self.assertEqual(sig, py_secp256k1.ecdsa_sign(msg, secret, None, b"1" * 32)) - - compact = py_secp256k1.ecdsa_signature_serialize_compact(sig) - der = py_secp256k1.ecdsa_signature_serialize_der(sig) - self.assertEqual( - compact, ctypes_secp256k1.ecdsa_signature_serialize_compact(sig) - ) - self.assertEqual(der, ctypes_secp256k1.ecdsa_signature_serialize_der(sig)) - - self.assertEqual(sig, ctypes_secp256k1.ecdsa_signature_parse_compact(compact)) - self.assertEqual(sig, py_secp256k1.ecdsa_signature_parse_compact(compact)) - self.assertEqual(sig, ctypes_secp256k1.ecdsa_signature_parse_der(der)) - self.assertEqual(sig, py_secp256k1.ecdsa_signature_parse_der(der)) - - self.assertEqual(py_secp256k1.ecdsa_verify(sig, msg, pub1), True) - self.assertEqual(ctypes_secp256k1.ecdsa_verify(sig, msg, pub1), True) - - self.assertEqual(py_secp256k1.ecdsa_verify(sig, b"a" * 32, pub1), False) - self.assertEqual(ctypes_secp256k1.ecdsa_verify(sig, b"a" * 32, pub1), False) - - self.assertEqual( - py_secp256k1.ec_privkey_add(secret, b"9" * 32), - ctypes_secp256k1.ec_privkey_add(secret, b"9" * 32), - ) - - self.assertEqual( - py_secp256k1.ec_pubkey_add(pub1, b"9" * 32), - ctypes_secp256k1.ec_pubkey_add(pub1, b"9" * 32), - ) - - @skipUnless( - _SCHNORR_AVAILABLE, - "ctypes backend missing schnorr symbols; skipping parity checks", - ) - def test_schnorr(self): - for i in range(1, 10): - secret = bytes([i] * 32) - pub1 = ctypes_secp256k1.ec_pubkey_create(secret) - pub2 = py_secp256k1.ec_pubkey_create(secret) - self.assertEqual(pub1, pub2) - pub1, par = ctypes_secp256k1.xonly_pubkey_from_pubkey(pub1) - pub2, par = py_secp256k1.xonly_pubkey_from_pubkey(pub2) - self.assertEqual(pub1, pub2) - msg = b"q" * 32 - - # without aux data - sig1 = ctypes_secp256k1.schnorrsig_sign(msg, secret) - sig2 = py_secp256k1.schnorrsig_sign(msg, secret) - self.assertEqual(sig1, sig2) - - # with aux data - sig1 = ctypes_secp256k1.schnorrsig_sign(msg, secret, None, b"4" * 32) - sig2 = py_secp256k1.schnorrsig_sign(msg, secret, None, b"4" * 32) - self.assertEqual(sig1, sig2) - - self.assertTrue(ctypes_secp256k1.schnorrsig_verify(sig1, msg, pub1)) - self.assertTrue(py_secp256k1.schnorrsig_verify(sig2, msg, pub2)) - self.assertTrue(ctypes_secp256k1.schnorrsig_verify(sig2, msg, pub1)) - self.assertTrue(py_secp256k1.schnorrsig_verify(sig1, msg, pub2)) - - self.assertFalse(ctypes_secp256k1.schnorrsig_verify(sig1, b"w" * 32, pub1)) - self.assertFalse(py_secp256k1.schnorrsig_verify(sig2, b"w" * 32, pub2)) - self.assertFalse(ctypes_secp256k1.schnorrsig_verify(sig2, b"w" * 32, pub1)) - self.assertFalse(py_secp256k1.schnorrsig_verify(sig1, b"w" * 32, pub2)) - - self.assertEqual( - ctypes_secp256k1.keypair_create(secret), - py_secp256k1.keypair_create(secret), - ) - - @skipUnless( - _RECOVERY_AVAILABLE, - "ctypes backend missing recovery symbols; skipping parity checks", - ) - def test_recovery(self): - secret = b"1" * 32 - msg = b"2" * 32 - sig = ctypes_secp256k1.ecdsa_sign_recoverable(msg, secret) - sig2 = py_secp256k1.ecdsa_sign_recoverable(msg, secret) - self.assertEqual(sig, sig2) - - # signature (r,s) = (4,4), which can be recovered with all 4 recids. - sig = (b"\x04" + b"\x00" * 31) * 2 - for i in range(4): - pub = ctypes_secp256k1.ecdsa_recover(sig + bytes([i]), msg) - pub2 = py_secp256k1.ecdsa_recover(sig + bytes([i]), msg) - self.assertEqual(pub, pub2) diff --git a/tests/tests/test_ecdh.py b/tests/tests/test_ecdh.py index 03ca6d84..6ef793ec 100644 --- a/tests/tests/test_ecdh.py +++ b/tests/tests/test_ecdh.py @@ -1,17 +1,18 @@ from unittest import TestCase, skipUnless -from embit.ec import PrivateKey, secp256k1 +from embit.ec import PrivateKey +from embit.util import secp256k1 import hashlib +# ECDH is an optional module in upstream secp256k1 (enabled with +# --enable-module-ecdh) and always present in zkp. If a future build of embit +# targets upstream secp256k1 without the ECDH module enabled, this check lets +# the test suite skip cleanly instead of erroring out. _ECDH_AVAILABLE = hasattr(secp256k1, "ecdh") -if not _ECDH_AVAILABLE: - print( - "[tests] ECDH backend unavailable; " - "skipping ECDH tests and using pure-Python fallback." - ) @skipUnless( - _ECDH_AVAILABLE, "ECDH backend unavailable; pure-Python fallback in use" + _ECDH_AVAILABLE, + "secp256k1 build is missing the ECDH module", ) class ECDHTest(TestCase): def test_one(self): diff --git a/tests/tests/test_liquid.py b/tests/tests/test_liquid.py index cc8a290b..4a4ee8d9 100644 --- a/tests/tests/test_liquid.py +++ b/tests/tests/test_liquid.py @@ -12,6 +12,10 @@ from embit.ec import PrivateKey from embit.hashes import tagged_hash +# Liquid needs zkp-only extras (rangeproof, pedersen, generator, surjectionproof, +# plus the tweak_mul operations upstream secp256k1 deprecated). If a future +# build of embit targets upstream secp256k1, with Liquid moving to a separate +# package, these checks let the test suite skip cleanly instead of erroring out. _LIQUID_REQUIRED_FUNCS = [ "ec_pubkey_tweak_mul", "ec_privkey_tweak_mul", @@ -21,16 +25,11 @@ "surjectionproof_generate", ] _LIQUID_AVAILABLE = all(hasattr(secp256k1, func) for func in _LIQUID_REQUIRED_FUNCS) -if not _LIQUID_AVAILABLE: - print( - "[tests] Liquid/ZKP backend unavailable; " - "skipping liquid tests and using pure-Python fallback." - ) @skipUnless( _LIQUID_AVAILABLE, - "Liquid/ZKP backend unavailable; pure-Python fallback in use", + "secp256k1 build is missing zkp extras required for Liquid", ) class LiquidTest(TestCase): def test_value_commitment(self): diff --git a/tests/tests/test_threading.py b/tests/tests/test_threading.py index decf6c69..7005f330 100644 --- a/tests/tests/test_threading.py +++ b/tests/tests/test_threading.py @@ -7,14 +7,11 @@ from embit.util import secp256k1 import threading -mbkey = PrivateKey.from_string("L2U2zGBgimb2vNee3bTw2y936PDJZXq3p7nMXEWuPP5MmpE1nCfv") -B64PSET = "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" -UNBLINDED = "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" -BLINDED = "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" -REBLINDED = "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" - - - +# This test exercises Liquid PSET blinding/unblinding under thread contention, +# which needs zkp-only extras (rangeproof, pedersen, generator, +# surjectionproof). If a future build of embit targets upstream secp256k1, +# with Liquid moving to a separate package, these checks let the test suite +# skip cleanly instead of erroring out. _THREADING_REQUIRED_FUNCS = [ "generator_generate_blinded", "pedersen_commit", @@ -24,16 +21,18 @@ _THREADING_AVAILABLE = all( hasattr(secp256k1, func) for func in _THREADING_REQUIRED_FUNCS ) -if not _THREADING_AVAILABLE: - print( - "[tests] ZKP/threading backend unavailable; " - "skipping threading tests and using pure-Python fallback." - ) + +mbkey = PrivateKey.from_string("L2U2zGBgimb2vNee3bTw2y936PDJZXq3p7nMXEWuPP5MmpE1nCfv") +B64PSET = "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" +UNBLINDED = "cHNldP8BAgQCAAAAAQMEAAAAAAEEAQIBBQEEAfsEAgAAAAABAP33AQIAAAAAAq/zCgOyWrF7jEptFQVi+6pWu60rVxzzAh+SVuu0RkldAQAAAAD9////r/MKA7JasXuMSm0VBWL7qla7rStXHPMCH5JW67RGSV0AAAAAAP3///8ECi3+xw457nd+eWfnwyiqaPIwiyGcKy++gmgbjSOXHq4RCXPrFTqJtDeSkRDgpdh4kLEIrMDDTtAk6LZDVFn0zaSrA+HUWB/GqlWohVEnu/MA0QaiCM592NMPJRxHYXBVSg4zFgAU3eFT8XcfZM775nQRyHYE+En6B88LtKW1ryz0TLzDdw5jjgUA3XLQp/ypT0vaf8YBF3iwYbkI0Ca4UQNJymoyrg5l5bfq99NxlrStKKqUEJxqzin6O+ED5z4F75EztrIhsjDarL+I7I6lHCZoZsrVX37q95OjlMcWABRulkp1Y83Qz8HjnCZA/fWq+z6FyAsK8SBzt+X/tKGuLv9E2YnkiASzOqiZ2MorEerlLCdYLwjRc+edZLkOa/ablLA2b8aXvdt1a8Ai1QFqcPX2oZOM3wI+GEHY09vbIJVO1/rOeUJtVxKLHD1NBvybkYpLdkCtxRYAFG+gFlAKPGpzfrsmDi3cp4upI0VYARhpbPI+Mgmm6ER50B8T/nnJATVq5TkHzIgs/9PiZAEjAQAAAAAAAAF4AAB2AAAAAQF6CwrxIHO35f+0oa4u/0TZieSIBLM6qJnYyisR6uUsJ1gvCNFz551kuQ5r9puUsDZvxpe923VrwCLVAWpw9fahk4zfAj4YQdjT29sglU7X+s55Qm1XEoscPU0G/JuRikt2QK3FFgAUb6AWUAo8anN+uyYOLdyni6kjRVgiBgPu7SBaaQIv7UpioCRX82mbGcBr90v4AazG2a6EvBap4RhzxdoKVAAAgAEAAIAAAACAAAAAAAEAAAABDiA0NhauQv7rYlE2VO7IoPCJqhrYQwcTv/DUbZYEqNElXgEPBAIAAAABEAT9////C/wIZWxlbWVudHMACADKmjsAAAAAC/wIZWxlbWVudHMBILQeLqnbyR0NIL3LGFwkzSrTz55maH7K5mW2P+OA0K8xC/wIZWxlbWVudHMCIAPP3UbPGfEQixv5JCES1bgYfNXcDuLR/8trTmaLHSfDC/wIZWxlbWVudHMDIFnwRKIXGRvqtlcZlCmzOepaxfJTwjYVJB9bYeFRZKUzB/wEcHNldA79ThBgMwAAAAAAAAABreTTAAFiJOXwKK3Qw8bnuSHdpODsjvsZLIiBjiR00RT6s8OXQPijmJuWlO43rzsEwdKr71yR6CTbSJm5mty13sqoh9I7B2WphX6kN53WsyU1vom1dnqd8nbBFcu4LQ6W/gN4f1C2iyguxehlKJq7+c73pHr7u51MSIxOinlUGa2PhD25nNq+HkA8NI6ZJKhVGki+Oj59TsbmzYYe89iijmG2n3k8Q7pZzFvcNBpj2o+ouUNjB6s6tYTFAkLbr9gEsck/mbPpOluEwVi2Y3UOLvwadfjA64RETLpFsvTuMBApH1yYxfahGiUWO6dmO1GykIhPYitrTPt16A5/47Qpf27iCMtDLLkrDpWg6KSC8PhaEhuJjzcGTeqdyxyONc2Ii0aTls7i2Um3rlIqBz/ONSvx2SzzZyLkpw+w/lnJjZq3273TUMYeKq4gNvVGnlIBkYRURJoYbCD+OL1xWZTKmfeNW4dkOkh5jDvoEv73B923YHYiIhQ+CvYgCbviYN4h//2m21JEDl9R+hMAXMaXVldBzlj+rIBJlwD7dSiC+aJtZzRvZAw30x4n1ledI7ti9Manl2M+oa1AjvGmlhvzIYIEcoFsJqgHN8+PXyu7i2lCSmyeOOCwGlR9lNTm8k+TXXndGc57YtVjbnC0J2Elko+9kTZoKGogw1XgC42bKoVKRh9bukY8ExZuuetpPs05uVeJfZ0q95yJn+FJLNcd9eik5+gtiuzoQgVjuUPZSrMi3+X8AxWX1o8kXKq2dAeRROIZSFMYADJ1h13XufvBBCkKQBv/omAAIWzF/Em/SRGpwFmgb080IJmqg405gbNKYtSBKcvyTbily/Y/Ss63HZQ+VkTtBKWyQq33ICKztRZ6PWuEaw7V/3aX45dRlQ/fiKdkq9ZNzS9s31RenZwHHvWaUT9F4OItO/tpp4uoMWGDGlzw9UjPzgzobHTQldsvwW5iKhF/tlTdSGj6zSjcSGJ4vzXMQmC2Q3eoLed6ayS3PFN8g3C15wZ/OPwacmFqv4WNuF8Yg1L43IDjMaVlNaddk+g7hVBKGWurMA103WVf4o0h96Ok3EJ8r7SNjxDz6Riu70fuvLvpwk3p25TsDFxx5SHzpXMhz/SEsctZ+QvfFwend3QDU5/iZuAmJqpS5jKo9McEuOZk3zc6jjZgU3qGpalLWzzLZjhJ/dmipdKZCJjdslf34SMxXcPXicbJPmMuPBf5TPjk5Mo/tj9O4dwr3jpw0suXr+tIsZysYgg+clewYsahvaDvUzSPdKsdGvcZUcy0ddRO6a6I899F0tbLSfMtcdnaCpoDHxSThpIc9hMBQY998p2kla6RMcJosgj2C8LwmGM5d/sTAyT1R0Ho1jd6G9P70fLGmQeeL00RQVW6pvpe2BEvpfdY5u7uNF56e95CCK9y8r1BxTcp8Ti8sY++mkFM1RBMYDcrceiWCEwH0DMfNznFlUWs/T48aZ9G1Al4OBkDc63FzPEXimB3uVWuBNqSprzVCkaJ7La97Y+5a7uFFpBVO6pLcPiLxA6d51R5PZpqeu0oSYEoJYel41HYmO3BmAMuPd3VhczGJG0jZyjwLAqlGBjTbPTv40b26kftXOlx+NUn95QH++wxva204d6jvghEoKiRwbFB6YNNuG4rhGOKAVWnXVr6i8p0l/MuM1vGIZdiEtU3IsWhIHFWNk4wWf7Di1Uk/oxh2Y3CToDL8D32GvR7z+yw5eH9ds7Ay+ftBWjNR9t+FeSOKwd+tJo0qcwuydETQAJ8P2mjZkb5smEHHTAfCz6vdwjYmT2GJpdAtgoIlKy/IT7rweteScjx5b17i8gRL2QHOqpvr91O+2mvFD4g+a/ieHtkXTikd1lNbTaR7jwbQaF3deK26/MEhZfrN5hBhewEXK7qjZHg1GalIDbZA7pDn/ZX6jknSNqKrfBvQmwcjGCcRRSt7nn+tLj6pw+/dZrL0Re1HGhQaE/gd4eAGSIHNtnkXMTPfXWj017ViVfouRP4B/Vurfq2mxhvJSp7MCh04vm/YpK0iFX2qXvDBZSJfr+yyj6tLzFfPhhFlZct/z2P95iSuvleLGHGY9a8u4GKM9OnXlrz+Cbau59NlMy3pEY+rKSueeVhfJhrOWolZoEmT/5vLABSoclTRaB48qR2ohK7wEicMS0dSat+eC9CUBBfT5vGc/5y/qHQm/lI4/vKtoIJ/R9H/UVDW9+AD+ysDFPBN8h1LGvt2pdO1gyOkXzmpeAxBjrBibmYJkiPQiMs6QILb0rV4v4ugwBLVGTkcv0LJp/XU4s2Zxs9/HSazKZEvQJKEb0FWlUHvNnPT8QhZ6WDUupj29PIg+wXmi9/mWAiqfNyzwMuGptqeHWA5jrTIE/n1gjfSYtkIf3Mu8YnfwzfCbpGsY2w+KRDtemco7w+AHMY8TfjWH7/0UVjPTiMM38wlyABMQlOYjnwfTc38DtiEnnxMBQvqU3aRSvBCooZIhTZ1VX/rOEtjFX5sYlVUP+kFL/oDHw1bV7BlIEqYvvCjnJ0x7FOIuAiy7hCev40Rl+cK/c7+eOC6MMnxJFoHTazkdX35/MqU0qp2Fl6POkhkpFHYl/iLpQOIMHHn0sbU5HpxLBJ6BsueD9wBWssw+lTCowXqnk4d1K5Co0xVQWVT96/z1TjMTdZl9K87CyTn10HE/FMPse3IZNxvTszQPhdBdW8f5YFxK57kUrVo6Hqw3dDSwdRsamwOz0OoDhKRA5vRbwINn/eXiVz95q2YfIonY4RWbsjOuYfgBruOsbRsYmTYG0onAhnC4lfwUoZVvyTeIt7d3SJBz7CAb1ENCuXfiNdkWqh081/R/4gCRgSVk8iizgnIVEp1WpORNALo+ZA3JB8UK/2l2fRE0xgqBRWpJpSpNqAnlECrZy6lMXFQogXNGgLTNK8NKKZ1IW8uWOmFTZN98nB8sW8rKeNFPp9is6Jkz3WIbNXzzFIKcQCbAlQyabpXhGuKoDlP7Jd6ynW3c/ZoP65VdLIxLD8nlw/9KUBRCvss0/7OooydZ0nIS1EZhlMQ8ZQanNr8utcnnmx7h5WSRg3/Ze+acOYqQpKKp90eyLwOhp7ELUxVffF70Qud95+tg4EIJFlrybKB6ngzUyxtamlI7d0hzA7nryo9iAX6dVPXRnvC6krsfpt9bztTZp3/sBGWGRdTNWI+KWByoh5Qa6vYccaLd1mkhaVaPNuTp3/UAExun2509jheSPmrDx+2JffTVfXDCl1ybk9YcR+Z4V1H6DbzfJD62o8Ht3Oo2+c1z57onKeMBrgop12K8XwmAVlS9CEntoGjP2L9q7bdFK7ilGnLczktdhEbuLFrm1+Kv3I01PzV4OLmEMKeuVlR63PLGgSJe3wj5deIlXCC4Lqzr8v6LJfLpF2THnCQ1/DwhDEPLidvB1H/j9rAzgCrSAlNQ6hnWMRcbXSMIMM1XXWT/dI52jRIVll5b5puBryM3x8h/SCzi710Jx0+GnAGxV2kcIevW6EC58ywzjQPWDeeiLbYOXGPQYBJRNXv6peK4hvl+E0YqFg4gftrmQfM5Mszgr/QqaOM5XJUUoQuow9kzI/dF8J5RXMXehPfzmZKC+Vfbg+98Vj3iijXNb5KVIbXU4pFJu9B9YWYtK4oslkWHJP4BSzbfoF37X4u7r/G+9W6j5K0PH+prZ42T63r7XcvcZl1oWXuCPQVWlA2NOGJIvm7RUVheWfga7uOgPvJsiqHG+0GCv74xpxKZUFCUUn1BD2x8pHmICjbyFXBbi97uGAKKNLZoSUSyHxm4m5rURn+MS1FuD2BkNHoWOia16kSItId7ieiy93WUdo9eAB8XoP8feidVfZryYCkzu4cXTZcgxYioVpu5+aoY8lzXMoi7Hk1wv8LinG0aTZ/DB0O/mBn/1ZF95v3l0Nc15LGwKRFJYppVmFtp8RSHrdAaTwXA4SUBoNtwpqgvFJNAXwWIDj+VGtH/usMGzBpmOdgHg5jmrSGGsiVa2rAh0twyHuT12wcOBnK7LX7iftiKZ8RFp6oyyjdd+CMOVeLO+z3xo2ThGeePL2g9uwXCrvroEgvJ5zh+baqSDW6tWAD95WAKoSthhRqxSv73Lqn/mwW6A5zaFxiD6sSgJMnBXgdLy+//izFDoU9YiXAGm1AOYSwV3VOkFZueutG9DbISvTjyGyxcPCVEsxfpH/0sSW/QO175whD76moHD7Q/qtC0wZXqryzIb+Y/7qqWeYz6KPz+v/j2zYn4TENMQGHTEYk22Nyri88hmgWbnU6CaBTWnxtiXhrLiywbX270cooEt84p7EwVlzyUJuE1mrafxmtq5sptfjFFNLbT61UTd8YjbZ70tCStnymYFX38yo5zhGGn9W5EuQ+oWeewMDfymVykOpi72Bbcha9M1aZSslFFXFfwrUX6xZJLeyrRAS/lGEXun3lRzrNr93EGL5AFjL6juHLmqcfG+l7gFAjaMXCRt3uenalx3x52XxtDwG7azD7lcsD9pUbRE5FMaf2h2Kg61h5YgIOQbDoF57CJKys9boHHpGK+S2vYvlEl+C5c1DJWLVXKCGbB4gl7WXgCoyj264QfQ1IBy1XgKAuwetsBlXWaX6FPp6NSzM6e2MXQ7h9tzl3lwyZri7QlB7Tm9EatSAx3OUKRXRWp0AkCKcQtKoblEtLJ6kgh5Ekzcuesc9MM6ZThNfobaOyO2spdxogk/rvddhIq8fgd4nK7T3KvaZkfauifXQQZFAicp7xxeFD6HEuge9Q5jL3oHfaZ1KrSZctCY7HtXr8I5oHRbMv8n1/Ip5NJnrt8L17elnYWRWAr9NSFjuKhuZ7iTo2d8X0nstYc+linzzamECQo661fOMTeAw+ev+LZ12Ak4Q31xNBnpPoRnClrEHpQlucNazSNTYX23uZSYIWfjMVkb1/BswPluErENciH7dk1fhAoJrygUDI1YaZgm3OGC6gNrPuvN3iCLqOYCe999D41SDBkp2oJ+abg1DiUdRV3yw8n5roDadsQ7XSwx+S9VSazUua9IXC9LQmMIPWNBgjvzRy+z69N/bhPN8ZH/vgt1PgRtBKUP9lXsCwscFZPQYwqYBfa45wfjOwK+7eCqhvSS8R/c+qXq2348ewZ6krqGkkMjbQZpEi13cQEfr8PNOVb2NTwkG/Kh2NkLzI1zlYAyfkTmRFg/3eVx4aMnWjqXNaKtJSMrBo+L9glVXmfuVDcLXGFjws9XfkEdRE21Sf6f92W0V47Yv5FMjHfmky8dMQ/riXxbz5KYRWv8cUethtp2hlhizJqMKJl5uLop6P0o3mjqznxETg+WtD1PhnabxpvA8/tLzZqShO2Dkvh08GpKvjrNEvhJqxp8afTAigJCG4ur5FbMzTidd27ShFySUCY8VfIM4VSiRnkbzqQpCZ4obfGaLb1T267sSB+JPIdy+3fFLClhtT0ZMPUWWeatGSoH+GqW7IWuCERdN1j83ngOalczaktcc1dS6YYJrLg/srZH+kcrnGtO0NXGwL1+iE9z/JG13SyK3NJe1qggkixqgdfKJH5TLZQH1AAEA/VQBAgAAAAAB3J/IrUwUWy8EubZ6BxwFyKfoDnQFx8Ws3k0G+TsZ0vMBAAAAAP3///8DC3Nhx39lJvCLk85hLK2jOideItHxtmwbbBm1TX8i72e0CMMNyrbkaul04PRt3rrI6xW5bHZJ5He/eRY6am10RnCdAlGhFKKBV3QTY2LfUbhY9DDFmzdg3RJjOsmuvMHsq/aBFgAUIZejNpgO7ZxNU8/VHk+Yde2Nt0gKXXLGxoz72obRjRIitW10XkLnHe6XuTxgjdwoiSLX2dEIEjEAT0SqTZcQf7pthn4SIqxEp/AXEbH3eackEVQSvXcCH2Xx/4RDwnmCXfVbSRbvIIYHcgon/ko/Z/qsxfx2NLAWABTQxKPvCemXtumeOX5Rj+PkGhGMoQEYaWzyPjIJpuhEedAfE/55yQE1auU5B8yILP/T4mQBIwEAAAAAAAAA+QAAdAAAAAEBegpdcsbGjPvahtGNEiK1bXReQucd7pe5PGCN3CiJItfZ0QgSMQBPRKpNlxB/um2GfhIirESn8BcRsfd5pyQRVBK9dwIfZfH/hEPCeYJd9VtJFu8ghgdyCif+Sj9n+qzF/HY0sBYAFNDEo+8J6Ze26Z45flGP4+QaEYyhIgYC56slN7XUnpcDCargbp5J82zhyf671E7I4NHMoLT5wxkYc8XaClQAAIABAACAAAAAgAAAAAAAAAAAAQ4ghLK/ZrL/Qp6OnIo/TB3J8j4nYwlPq8i57lKBZgMg6XgBDwQBAAAAARAE/f///wv8CGVsZW1lbnRzAAgA4fUFAAAAAAv8CGVsZW1lbnRzASC0vDFvvZYaY1OBypwMOHCImi1rABcHHgGIzSOQbJt81Qv8CGVsZW1lbnRzAiAYaWzyPjIJpuhEedAfE/55yQE1auU5B8yILP/T4mQBIwv8CGVsZW1lbnRzAyCbUmpOG0+u3lnxy7+bij2JAfcKiXJ4hyK/E2OFxXxbkQf8BHBzZXQO/U4QYDMAAAAAAAAAAZHeKwBfNKVVpnI+FqH09q+ZGMBAELa8Jy2JXJqhP8TqRoueL7w70A+1efTnunpcM4Vv/HNjQdfRLWrgQA/wR6C7Eev4rA+RSGvcKrxHApafS/04BeWQKGXuqQYkKrw3ahLRWNCbFiF7Y0uwaN2BVD9IrdLis2SHCR1pDjkdInEBzIWXwjLzyM42tkmY5e9ZDwY/HIleJBeSPci7OXOo4IYV8exLicoFGv62MgJW+sa7eNwejbP7GTAuXtS+NwpdPUAxBTKoIkuPy9n4aNaaQxylvgnis2Zxum0MzspBde+YEGBlP4DMSh/U5HiLOuYUWRdUXV0J72TX2ERgtd3KBiaPEgueKxdDzBUcRIxT769BZVY54IS/zzDpDxJ4ZA5av7qyB1Ojg74O54JOq2JQwmhts5a4GdWnEFrpCt2Eeqar370y1N4d9vKacwYWUlrQoM6jNplf911SFyqeiWZdE6kEoPc77iz7rePu+A9vZ650PXr1rmvkY4wlDv/lSFS+pr3HpsMX7RnfS8YwSmKEF3IKTMvHdJ/2x5uc5kTObfjbJB/mC1p2yr6MEI5+nuxOp0xIc+QV/XkREPelerpazXvtxNYjjxoH6X0CM6IKtzqcTJPXUKj5SiKVBMU89jAunS9taBGbv2PvvNaWqps92qVjbz/XtkJ1dbdaB1o6pCSPWBO9VoJ5uJq/+WlBhHRnV6JtiisQui8oKFopP8+m/VTrwTtT1yEkMoEplRnpY0d2qwQydJLoX3RPz0tbbfDFdi40Vv8pEfk2HZYIRTsPRyFG/Sz92b6D5Oy4bYobd42tRNbBkBusphu0/RfrT9SuR/raXm83klYqPkcNLFHfotsEJxLEYsG4vZR+Cj/SK3jptLDWofQLB9jzQxoyM/Xk3voBE0DBDyTmge4SL8BGbzVvFIKv6gaK5YGN7b8FK2dhwu9yTsk+BOVLnYsi+UiGQKT8IMVhlig7IIpRN54i7GeCl0Edor+BO85PSWUWCAwdB5lL1FAhg/RDxgjiwemS/COQgUgixt91b1lNSb0qNbfOzFIT5hENdKfdDaqzzfXGOb+3/LKeK1RXjcKtOyGa7cLQotpEm3ET7SEjXM8NHzy9HBXRMCbE0LlxCsxSz9vu9VHuZzmSQh5fgRT1PUCb7NZCUoJNdBpxFJkiBRfsF0TTY3cw4mIdAEDkBsEWrmSWHYo8S9r2dhnI/92aJ2XVxBsVUu9x+txFBeqiOZB41JK5TZMFXe7yU0ghHpMTCbkgenn5vgongWIKz2aAUyqb7YvXozQvE7p44wy6PoOMDq+r4mru2XWaK/FNylNUYbdDLCXiGOBzEyyQ79hRRupGD3xPbYiQxeWNBRXZwD3WzZetPO1c7d7O5fswJQW9KRJD1MPbM0JAcNrLbUI5z+6+jQBBTkGNF7wmCwu5jMhkzUJANayfDzJyk8zTmTbDhtg0MoK0ydEQt5PHKHCbGl+fchNXQZDA81NN6MaviOSqSIaciNI7LoLH42E7nTVniobiobD9XB32wtihoAx8PEbbjavH7gDYyGWv2IpLBB0L1spJfdisS7V4XFS3DHd+P1B7q5yBxDhtTlM3p7MywsTyma3s/8NLI0VxyUdEYV+MvvIkd6dtZ62DTDcqmqnQTqyb+OmvCcZY3Xv8SATuXr9fUI8PJ/sGOFJRJJUu+uTZtpli31Kjtm5C82RWTiPeyOZAdkYTa1Qos5q2rINiQr3WFEUL1qRGXlq/EyDbpnG72fAFgsDfvSk26s8wFOSTrU1Ls+w0tm/ToSqwXWQKYjKfiSBpaA8cjz7B7NTOnf8D3RfYLlPLC0jKI4AVl1OHaJ1u+s87UWiphxMrLtOM1mmOVR0uoSDmtSbzS8VQHtUyVvSkBAF2AL3unIy+5Ke65YBeDMIUZ5mMui4w8SCKyIFl+E9ztQ7wjDeguIvN7C8B9l6rzUc1Lcsg2s5rk+OgNB8Arv4maqV41bleQIss98cpM/Q/FUFitRxLEHn3RuDSmciJQnoIoFskFikpRkFCmZKMuFfHH7U+//nFca7v8ow9H0GxeKAIdZLvv/4MvPkulbUoQUV9SMwXmuyI6Gx+8NWscNkftJ2mSPrT61GgQ+YtmKZ5OXA/BVezm5GN0bHN5gSSJAAYM5SqAyWs21BRS//PJEoHaY0cLKFyML1MTYYo/gyT3vTkGZmmhJVdkUpd2lHp0cG/nbALktC+GKo7fDlxq2MYvEOctqbvs1WXjUZ2IcuLTyXDmKI6VE1bJuC4XUce5lYfrfj55qqdHSX9ex7qkFKjyHuGAgranMN1PKm9JCQG0nc4ffH0AKVAhHINAAoTFuq9z9PkRjz93CDiKx5HXryY8nwthC/k9udZdH6PXmnrNzhG3nt/pfgaZ7pHllo1hroofC/24FnHkoTTNZXKdOFfAj6BKyan9WMsvy2f5DEEgdpLSajvP4r7RzzI85b6tbQYybAf8e0lZqAb1erVdp/I8/u20lxia1bieQknPUzK0gjE0l1CGC7iEWBLpf0xIkdBzee2rSpMMkOdyyw9p3kHHz9lizSVNKS/E2X5BMg/lNYiEUcavg3Qk4gkOmp3RWVteLYLJWUiaFreVbgdJmVZyMT+L9bb9NacNLKbiFfLdmc2gqytZsCj0NgERKX2Wc56s3Cdk8cfOfNnjOxJsi1KDPUxVMn3PO5gy00oMQQ6qa5VKtxw6d5rLXV9Mk0gOxVpasruLqwb2q9appaobWibUMZUGb+2ZIxtMzu0NEoG+yS2mTfkQhBo7L30h+wZMvj/Zp2Phc7wTVJOTIxFGjGXY/3SJbWh/sB09Ih2qguRGsaG57gK62z9kQ9oU1QMS8kWSoHuxxl4cg/CwJ74Qg+ENeY7w6ElszyL/AQXsGBZkd34n4hzrYSvAyT74pvePKeEWP/HAxI5Ivp+M+FDoCtrpyd5gPdPQsIfZnmO0age1iNiqqs6ATPxsEEE5MDro5YM4EdvDAJD0ZAeqGO0KZmNoKuiK2r3tJmLSbaZJoSpR4IUHqzuYrrdVkfewyUcyERbE9ujZxEvHcPcIJ9Z62tMVoMuz7v5pj01y2ohHPrLqIOWztsNNrwBIX9fQmwtSyl/3crgrfmtRmykyNsmg4echb3rF6iGBGioKvSeL8fpSLEIQDWwZuhR0QLExVRqNULMKmxYQJM3+ofk5Hpp2JA/c8vshFYGM6hi7LmOo9/XRaAzW0/u7wl4rZ5yxV1spti25vqBeAZK48E3RFmFX+1J5369Idrs8wkZtOt25FRGcy17F1k4Fb3J9BGof2UjmQWBSHhOOoDDci6KI1gfXfPPH8/Gz27wLG4+adiViEDjSVNihpkHCGI67ugBd1ZVIt1aiuf0Kv1Najrd+Jp+Y9tFM6SFs1ErvaR5vCDSAC2PYNFqbzwztm41h/LDmptxxQLuu2HhjWoaTiWJ5lRgavuuWf+dUuCS/FDhTD+4CmG2t1sgW9E75RKA06LNUbqwO4mOmv3gdzKqiixfCO7NIoHO8o1zz8g6lqvqG3w91o3APdtyLMCKJpoBr5XJl2yzDGEgFW6y0HN8e9P8KPX3/j3lg/MeEx8H6s2oG5ySfNNOldh3U15XKcElXpCHgtWfKknzahFeeqAVSu9ikn5ErbBVbIvGtBqC8UOdG2exuQTxhyrPmJGD0Lv/lx+YbweR8e1Ar3Y2H8ML+NzuW9hLqmeJyatC5Q+d2Zy0nyOcanGmQ4sKJd8Al7jhNMbczVgbM1dku5R9f5bzFHuZ2OzuQC21aTvVwRhbyo1fcLcsqqsuWUZ64OUE0HfYOQwF2Gv/It/uvvfM8FmGPfHJGuFRBUGP6lSiMr761KnVw6yGinFtFqTsky2GxMYJsTBCjDr7V4l55RPyCeknsJWOiwS94qqGJC8SRX5Ken2f8atut7kH4aSEDo+4tOSGUAAntUCfL5QnmaWg6BI+OykJx39v6EpnRaLb6oa3YtJvKXacbCYHp4Jmjp2ml1c0EKwh6z/ka2ad6pP0LKrDFo81GbV5E17U4p249tjfpHpnrt6MAhsNDi2bNgxl0CZkhjGpO681CuKQCbrX1spi/FqAU9mKinybwGya6fdS18kpNAyWK3UQ3DPvCH5NNRdXblUS2KDksUjLmd82DmpgloitifwcFPFNBaTJNKSn2FQ2U2demarYB8sHAc+rvJuZk+va10TX/5nRKmOIepXPQJDNUnqJxJn4rDW22g60hIgKPTejW+MvAwFJkI+AWn99Pk42YsPF3/C/PnJ34kyfUFSM3zT0DnAIh7vZa6eE09xogGqIXnnVAINZUbsfpjgK1xIkG5Jm9M8xujkhJBxjEViJLjPi4o50cnGvQAjEl1rFIm+TEBzKYh4QCpmwmsAdQXQnZBNCeXsg1qmtOTfvMBP5ImGnwiWyRy3ZO4pcF+G9NUEZGdXZ7X0G2i/Bqu5WgxmleArU8MzAIg9QSNMPScNk+MUjFTg0AaO+SjdOAhKvqBG8C1shp7b8c0ov5B7z/vUEMNMDNAOZjSvQNQoj6uLjKE8a/AqebQeXG7kf/H1lMElVDovQBDvAMu4HYVZSgyp7C7f8zQZKrdxUQnAnOiUzgjOBt0KA/tvmbPaoaBzUBaMp55HjbHSZluioeYso2jlZrzDs+ySK765yI6JOqQfsNedJuhnfbL340HSYQRPSWzYp0pux1Yem6+Lp4+B/7XzfjR6ZyuH+9RyG/Rl0/RYTFIl2BktMPEZai6sEZm4o/8IPWYVyuegHuzuyUECX/QlMlDOi8YDy6hoUOdivScvmx/I3deDA22pHBgYamZRDF/7A0p6SJqI6j9gGV/bVtzbu9bg1lnnuRFIKCYgGs88vpkpw9OSMz/UKKO6QAet0iVveRhaxjzkM4oDDbfJ772j4fK2/oNGsmaoKngJr7xFGW7ifwCsh+MynyGA0erJ1hz2BImr0XuiitdbxNC7yiIHzgY1DyuDOahagTHl61imiI1NQ78XkOj5vlaOHsnd2R5YC+zi9yrD1nRIiMULmhnqg4y3ZjtLUILsyn0vOKYmmzJeKnKjvQcI20Vvvx2dvAy83FDBoGJ7DZkA81YbjeLjWX8XHdzeUxVFwyz8zIkS1T603O+dTBbsJ8INEGzreYaAKOAzq18RxWcrt2z1TPqk2WhCbQ3xFr9WZw798NEVkeWFOo3aSFv4bI5PFH8i1HtnguowscNZgqM2Z+Wred/Drss+p21ptND9h5PdwrLzBtEfoI2nvPSqypF4aeDl2DZ+AekXBLAVx70XWGwV3MV1Sb71iy3hCFYUhduJrKr0K5mJo4bOOlB/wU/QXB56R3v5wmetrBow+wS1AEp3eyVkzrf+UuTDxVzD0U6ZKueCRBWxZ0NTyhsLQN30pn2vg4VvZ49MAIXwMWoDX0xCcO3DmWXGXfoDrDchMA0IbGeqTOD5HBSXtQxcPK+3FdmW8cavOYZRBbyg5ZzeRr9IAnDjsCKSRwkN2piOn8GDuTkDQ3HJNZ/mS5Rc6u1Ljjbfm73+ZYKbydMozTdCee2pW17aVpYOsUVjvhsxTPJqfDjk86JAtLUzWhgAiAgNwz6ZQbvQ6Si0chzjatj5UdQQ1B4oxJ2DRBGV9va2WLBhzxdoKVAAAgAEAAIAAAACAAQAAAAYAAAABAwiAMwI7AAAAAAEEFgAUgBae/BBuAYfqD59MMQv8vXi8P+0H/ARwc2V0AiADz91GzxnxEIsb+SQhEtW4GHzV3A7i0f/La05mix0nwwf8BHBzZXQGIQOGDl+vjfxGNWudl6wc9g7un30h6JjEIdB1dtHCEnlC6wf8BHBzZXQIBAAAAAAAIgICtnzNQ/FEKlH6zLX9ykQkha4BGwHSuc/ymM6yFZglAfsYc8XaClQAAIABAACAAAAAgAEAAAAHAAAAAQMIct/1BQAAAAABBBYAFDHUORI3eUFKBYByM9r5KsMZw49aB/wEcHNldAIgGGls8j4yCaboRHnQHxP+eckBNWrlOQfMiCz/0+JkASMH/ARwc2V0BiEDoAHNF1/99wkb65+cTZBod6eMN2ZNyaBLQd29kzdptVQH/ARwc2V0CAQAAAAAAAEDCICWmAAAAAAAAQQiACCHiaDbtsYzl+do6EgG78zG/3pwyGilJFg1WCmGNOgCKAf8BHBzZXQCIAPP3UbPGfEQixv5JCES1bgYfNXcDuLR/8trTmaLHSfDB/wEcHNldAYhAoNp6chO9RrYMnBivw3fP18Ug+0maDvTO1iy35dUJPd0B/wEcHNldAgEAAAAAAABAwiOAQAAAAAAAAEEAAf8BHBzZXQCIBhpbPI+Mgmm6ER50B8T/nnJATVq5TkHzIgs/9PiZAEjB/wEcHNldAgEAAAAAAA=" +BLINDED = "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" +REBLINDED = "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" + @skipUnless( _THREADING_AVAILABLE, - "ZKP/threading backend unavailable; pure-Python fallback in use", + "secp256k1 build is missing zkp extras required for Liquid blinding", ) class ThreadingTest(TestCase): # run blind-unblind in a thread or multiple threads