Updated fork to use v0.3.11 & made points public

.github/workflows/ci.yml

@@ -22,8 +22,9 @@ jobs:
     steps:
     - uses: actions/checkout@v3
 
-    - id: get-date
-      run: echo "::set-output name=date::$(date -u +%Y-%m)"
+    - name: Get date
+      id: get-date
+      run: echo "date=$(date -u +%Y-%m)" >> $GITHUB_OUTPUT
       shell: bash
 
     - uses: actions/cache@v3
@@ -44,20 +45,44 @@ jobs:
       shell: bash
       run: |
         rustc --version --verbose
+        export CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse
         cd bindings/rust
         if [ "$GITHUB_EVENT_NAME" != "pull_request" ]; then
             cargo update
         fi
         cargo test --release
+        echo '--- test portable'
+        echo
+        cargo test --release --features=portable
+        echo '--- test no-threads'
+        echo
         cargo test --release --features=no-threads
+        echo '--- test serde-secret'
+        echo
+        cargo test --release --features=serde-secret
+        echo '--- test no_std'
+        echo
+        echo 'set -e'                                       > ulimit-s
+        echo 'export RUST_MIN_STACK=$(($1 * 1024)); shift'  >> ulimit-s
+        echo 'exec "$@"'                                    >> ulimit-s
+        triple=`rustc -vV | awk '/host:/ {print $2}' | tr 'a-z-' 'A-Z_'`
+        stack_size=`[ $OSTYPE = "msys" ] && echo 65 || echo 56`
+        env BLST_TEST_NO_STD= \
+            CARGO_TARGET_${triple}_RUNNER="bash ulimit-s $stack_size" \
+            cargo test --release
         if [ `uname -s` = "Linux" ]; then
+            echo '--- test wasm32-wasi'
+            echo
             rustup target add wasm32-wasi
             curl https://wasmtime.dev/install.sh -sSf | bash
             env PATH=$PATH:~/.wasmtime/bin:`clang -print-search-dirs | awk -F= '/^programs:/{print$2}'` \
                 AR=llvm-ar CARGO_TARGET_WASM32_WASI_RUNNER=wasmtime \
                 cargo test --release --target=wasm32-wasi
+            cargo clean -p blst --release --target=wasm32-wasi
+            echo '--- dry-run publish'
+            echo
+            ./publish.sh --dry-run
         fi
-        [ `uname -s` = "Linux" ] && ./publish.sh --dry-run
         cargo clean -p blst
         cargo clean -p blst --release
         rm -rf target/.rustc_info.json
@@ -88,13 +113,14 @@ jobs:
         path: ~/swig
         key: ${{ runner.os }}-swig-github
 
-    - uses: actions/setup-java@v1
+    - uses: actions/setup-java@v3
       with:
+        distribution: temurin
         java-version: 11
 
     - uses: actions/setup-node@v3
       with:
-        node-version: '12.x'
+        node-version: '16.x'
 
     - name: Environment
       run: |
@@ -167,6 +193,6 @@ jobs:
             bindings/c#/run.me;
             if which dotnet > /dev/null 2>&1; then
                 cd bindings/c#
-                env LD_LIBRARY_PATH=`pwd` dotnet run -c Release
+                dotnet run -c Release
             fi
         fi

.github/workflows/codeql-analysis.yml

@@ -5,15 +5,15 @@ on:
     branches:
       - '**'
     paths:
-      - 'src'
-      - 'bindings/c#'
+      - 'src/*'
+      - 'bindings/c#/*'
       - '.github/workflows/codeql-analysis.yml'
   pull_request:
     branches:
       - master
     paths:
-      - 'src'
-      - 'bindings/c#'
+      - 'src/*'
+      - 'bindings/c#/*'
   #schedule:
   #  - cron: '0 23+ * * 4'
 
@@ -44,7 +44,7 @@ jobs:
 
     - if: matrix.language == 'cpp'
       name: Custom build
-      run: ./build.sh -m32 -D__wasm__
+      run: ./build.sh -m32 -ffreestanding
 
     - if: matrix.language != 'cpp'
       name: Autobuild

.travis.yml

@@ -32,7 +32,7 @@ script:
             REF=.cargo/registry/index/*/.last-updated;
             THEN=`(stat -c %Y "$TRAVIS_HOME"/$REF || stat -f %m "$TRAVIS_HOME"/$REF) 2>/dev/null`;
             if [ $(($NOW - ${THEN:-0})) -gt 604800 ]; then
-                cargo update;
+                env CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse cargo update;
             fi;
             cargo test --release )
       fi

README.md

@@ -136,7 +136,7 @@ The most-significant three bits of a G1 or G2 encoding should be masked away bef
 * The third-most significant bit is set if (and only if) this point is in compressed form _and_ it is not the point at infinity _and_ its y-coordinate is the lexicographically largest of the two associated with the encoded x-coordinate.
 
 ## Build
-The build process is very simple and only requires a C complier. It's integrated into the Go and Rust ecosystems, so that respective users would go about as they would with any other external module. Otherwise, a binary library would have to be compiled.
+The build process is very simple and only requires a C compiler. It's integrated into the Go and Rust ecosystems, so that respective users would go about as they would with any other external module. Otherwise, a binary library would have to be compiled.
 
 ### C static library
 A static library called libblst.a can be built in the current working directory of the user's choice:

bindings/blst.h

@@ -95,10 +95,6 @@ void blst_fr_sqr(blst_fr *ret, const blst_fr *a);
 void blst_fr_cneg(blst_fr *ret, const blst_fr *a, bool flag);
 void blst_fr_eucl_inverse(blst_fr *ret, const blst_fr *a);
 void blst_fr_inverse(blst_fr *ret, const blst_fr *a);
-#ifdef BLST_FR_PENTAROOT
-void blst_fr_pentaroot(blst_fr *ret, const blst_fr *a);
-void blst_fr_pentapow(blst_fr *ret, const blst_fr *a);
-#endif
 
 void blst_fr_from_uint64(blst_fr *ret, const uint64_t a[4]);
 void blst_uint64_from_fr(uint64_t ret[4], const blst_fr *a);
@@ -159,7 +155,7 @@ void blst_fp12_frobenius_map(blst_fp12 *ret, const blst_fp12 *a, size_t n);
 bool blst_fp12_is_equal(const blst_fp12 *a, const blst_fp12 *b);
 bool blst_fp12_is_one(const blst_fp12 *a);
 bool blst_fp12_in_group(const blst_fp12 *a);
-const blst_fp12 *blst_fp12_one();
+const blst_fp12 *blst_fp12_one(void);
 #endif  // SWIG
 
 /*
@@ -184,13 +180,13 @@ bool blst_p1_on_curve(const blst_p1 *p);
 bool blst_p1_in_g1(const blst_p1 *p);
 bool blst_p1_is_equal(const blst_p1 *a, const blst_p1 *b);
 bool blst_p1_is_inf(const blst_p1 *a);
-const blst_p1 *blst_p1_generator();
+const blst_p1 *blst_p1_generator(void);
 
 bool blst_p1_affine_on_curve(const blst_p1_affine *p);
 bool blst_p1_affine_in_g1(const blst_p1_affine *p);
 bool blst_p1_affine_is_equal(const blst_p1_affine *a, const blst_p1_affine *b);
 bool blst_p1_affine_is_inf(const blst_p1_affine *a);
-const blst_p1_affine *blst_p1_affine_generator();
+const blst_p1_affine *blst_p1_affine_generator(void);
 
 typedef struct { blst_fp2 x, y, z; } blst_p2;
 typedef struct { blst_fp2 x, y; } blst_p2_affine;
@@ -211,13 +207,13 @@ bool blst_p2_on_curve(const blst_p2 *p);
 bool blst_p2_in_g2(const blst_p2 *p);
 bool blst_p2_is_equal(const blst_p2 *a, const blst_p2 *b);
 bool blst_p2_is_inf(const blst_p2 *a);
-const blst_p2 *blst_p2_generator();
+const blst_p2 *blst_p2_generator(void);
 
 bool blst_p2_affine_on_curve(const blst_p2_affine *p);
 bool blst_p2_affine_in_g2(const blst_p2_affine *p);
 bool blst_p2_affine_is_equal(const blst_p2_affine *a, const blst_p2_affine *b);
 bool blst_p2_affine_is_inf(const blst_p2_affine *a);
-const blst_p2_affine *blst_p2_affine_generator();
+const blst_p2_affine *blst_p2_affine_generator(void);
 
 /*
  * Multi-scalar multiplications and other multi-point operations.
@@ -341,6 +337,9 @@ void blst_sign_pk_in_g2(blst_p1 *out_sig, const blst_p1 *hash,
 #ifndef SWIG
 void blst_miller_loop(blst_fp12 *ret, const blst_p2_affine *Q,
                                       const blst_p1_affine *P);
+void blst_miller_loop_n(blst_fp12 *ret, const blst_p2_affine *const Qs[],
+                                        const blst_p1_affine *const Ps[],
+                                        size_t n);
 void blst_final_exp(blst_fp12 *ret, const blst_fp12 *f);
 void blst_precompute_lines(blst_fp6 Qlines[68], const blst_p2_affine *Q);
 void blst_miller_loop_lines(blst_fp12 *ret, const blst_fp6 Qlines[68],
@@ -356,7 +355,7 @@ typedef struct {} blst_pairing;
 typedef struct blst_opaque blst_pairing;
 #endif
 
-size_t blst_pairing_sizeof();
+size_t blst_pairing_sizeof(void);
 void blst_pairing_init(blst_pairing *new_ctx, bool hash_or_encode,
                        const byte *DST DEFNULL, size_t DST_len DEFNULL);
 const byte *blst_pairing_get_dst(const blst_pairing *ctx);

bindings/blst.hpp

@@ -9,6 +9,7 @@
 #include <string>
 #include <cstring>
 #include <vector>
+#include <memory>
 
 #if __cplusplus >= 201703L
 # include <string_view>
@@ -416,19 +417,19 @@ class P1_Affines {
 
     P1 mult(const byte* const scalars[], size_t nbits) const
     {   P1 ret;
-        limb_t* scratch;
 
         if (wbits != 0) {
-            scratch = new limb_t[blst_p1s_mult_wbits_scratch_sizeof(npoints)/sizeof(limb_t)];
+            size_t sz = blst_p1s_mult_wbits_scratch_sizeof(npoints);
+            std::unique_ptr<limb_t[]> scratch{new limb_t[sz/sizeof(limb_t)]};
             blst_p1s_mult_wbits(ret, table[0], wbits, npoints,
-                                     scalars, nbits, scratch);
+                                     scalars, nbits, scratch.get());
         } else {
-            scratch = new limb_t[blst_p1s_mult_pippenger_scratch_sizeof(npoints)/sizeof(limb_t)];
+            size_t sz = blst_p1s_mult_pippenger_scratch_sizeof(npoints);
+            std::unique_ptr<limb_t[]> scratch{new limb_t[sz/sizeof(limb_t)]};
             const blst_p1_affine* const ptrs[2] = { table[0], nullptr };
             blst_p1s_mult_pippenger(ret, ptrs, npoints,
-                                         scalars, nbits, scratch);
+                                         scalars, nbits, scratch.get());
         }
-        delete[] scratch;
         return ret;
     }
 
@@ -451,12 +452,11 @@ class P1_Affines {
     static P1 mult_pippenger(const P1_Affine* const points[], size_t npoints,
                              const byte* const scalars[], size_t nbits)
     {   P1 ret;
-        limb_t* scratch;
-        scratch = new limb_t[blst_p1s_mult_pippenger_scratch_sizeof(npoints)/sizeof(limb_t)];
+        size_t sz = blst_p1s_mult_pippenger_scratch_sizeof(npoints);
+        std::unique_ptr<limb_t[]> scratch{new limb_t[sz/sizeof(limb_t)]};
         blst_p1s_mult_pippenger(ret,
                     reinterpret_cast<const blst_p1_affine *const*>(points),
-                    npoints, scalars, nbits, scratch);
-        delete[] scratch;
+                    npoints, scalars, nbits, scratch.get());
         return ret;
     }
 #ifndef SWIG
@@ -715,19 +715,19 @@ class P2_Affines {
 
     P2 mult(const byte* const scalars[], size_t nbits) const
     {   P2 ret;
-        limb_t* scratch;
 
         if (wbits != 0) {
-            scratch = new limb_t[blst_p2s_mult_wbits_scratch_sizeof(npoints)/sizeof(limb_t)];
+            size_t sz = blst_p2s_mult_wbits_scratch_sizeof(npoints);
+            std::unique_ptr<limb_t[]> scratch{new limb_t[sz/sizeof(limb_t)]};
             blst_p2s_mult_wbits(ret, table[0], wbits, npoints,
-                                     scalars, nbits, scratch);
+                                     scalars, nbits, scratch.get());
         } else {
-            scratch = new limb_t[blst_p2s_mult_pippenger_scratch_sizeof(npoints)/sizeof(limb_t)];
+            size_t sz = blst_p2s_mult_pippenger_scratch_sizeof(npoints);
+            std::unique_ptr<limb_t[]> scratch{new limb_t[sz/sizeof(limb_t)]};
             const blst_p2_affine* const ptrs[2] = { table[0], nullptr };
             blst_p2s_mult_pippenger(ret, ptrs, npoints,
-                                         scalars, nbits, scratch);
+                                         scalars, nbits, scratch.get());
         }
-        delete[] scratch;
         return ret;
     }
 
@@ -750,12 +750,11 @@ class P2_Affines {
     static P2 mult_pippenger(const P2_Affine* const points[], size_t npoints,
                              const byte* const scalars[], size_t nbits)
     {   P2 ret;
-        limb_t* scratch;
-        scratch = new limb_t[blst_p2s_mult_pippenger_scratch_sizeof(npoints)/sizeof(limb_t)];
+        size_t sz = blst_p2s_mult_pippenger_scratch_sizeof(npoints);
+        std::unique_ptr<limb_t[]> scratch{new limb_t[sz/sizeof(limb_t)]};
         blst_p2s_mult_pippenger(ret,
                     reinterpret_cast<const blst_p2_affine *const*>(points),
-                    npoints, scalars, nbits, scratch);
-        delete[] scratch;
+                    npoints, scalars, nbits, scratch.get());
         return ret;
     }
 #ifndef SWIG

bindings/blst_aux.h

@@ -10,8 +10,14 @@
  * depending on their proven/unproven worthiness.
  */
 
+void blst_fr_ct_bfly(blst_fr *x0, blst_fr *x1, const blst_fr *twiddle);
+void blst_fr_gs_bfly(blst_fr *x0, blst_fr *x1, const blst_fr *twiddle);
 void blst_fr_to(blst_fr *ret, const blst_fr *a);
 void blst_fr_from(blst_fr *ret, const blst_fr *a);
+#ifdef BLST_FR_PENTAROOT
+void blst_fr_pentaroot(blst_fr *ret, const blst_fr *a);
+void blst_fr_pentapow(blst_fr *ret, const blst_fr *a);
+#endif
 
 void blst_fp_to(blst_fp *ret, const blst_fp *a);
 void blst_fp_from(blst_fp *ret, const blst_fp *a);
@@ -50,7 +56,11 @@ void blst_sk_to_pk2_in_g2(byte out[192], blst_p2_affine *out_pk,
 void blst_sign_pk2_in_g2(byte out[96], blst_p1_affine *out_sig,
                          const blst_p1 *hash, const blst_scalar *SK);
 
+#ifdef __BLST_RUST_BINDGEN__
 typedef struct {} blst_uniq;
+#else
+typedef struct blst_opaque blst_uniq;
+#endif
 
 size_t blst_uniq_sizeof(size_t n_nodes);
 void blst_uniq_init(blst_uniq *tree);
@@ -94,11 +104,11 @@ void blst_scalar_from_hexascii(blst_scalar *out, const byte *hex);
 void blst_fr_from_hexascii(blst_fr *ret, const byte *hex);
 void blst_fp_from_hexascii(blst_fp *ret, const byte *hex);
 
-size_t blst_p1_sizeof();
-size_t blst_p1_affine_sizeof();
-size_t blst_p2_sizeof();
-size_t blst_p2_affine_sizeof();
-size_t blst_fp12_sizeof();
+size_t blst_p1_sizeof(void);
+size_t blst_p1_affine_sizeof(void);
+size_t blst_p2_sizeof(void);
+size_t blst_p2_affine_sizeof(void);
+size_t blst_fp12_sizeof(void);
 
 /*
  * Single-shot SHA-256 hash function.

bindings/c#/run.me

@@ -16,8 +16,43 @@ using System.Numerics;
 using System.Runtime.InteropServices;
 using size_t = System.UIntPtr;
 
+#if NET5_0_OR_GREATER
+using System.Runtime.Loader;
+using System.Reflection;
+using System.IO;
+#endif
+
 namespace supranational { public static class blst {
 
+#if NET5_0_OR_GREATER
+private static string dll;
+
+static blst()
+{
+    if (String.IsNullOrEmpty(dll)) {
+        var name = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "blst.dll"
+                 : RuntimeInformation.IsOSPlatform(OSPlatform.OSX)     ? "libblst.dll.dylib"
+                 : "libblst.dll.so";
+
+        var dir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+        var arch = RuntimeInformation.ProcessArchitecture switch {
+            Architecture.X64   => "x64",
+            Architecture.Arm64 => "arm64",
+            _ => "unsupported"
+        };
+        dll = Path.Combine(dir, arch, name);
+
+        if (!File.Exists(dll))
+            dll = Path.Combine(Environment.CurrentDirectory, name);
+
+        if (File.Exists(dll)) {
+            AssemblyLoadContext.Default.ResolvingUnmanagedDll += (asm, needs) =>
+                (needs == "blst.dll" ? NativeLibrary.Load(dll) : IntPtr.Zero);
+        }
+    }
+}
+#endif
+
 public enum ERROR {
     SUCCESS = 0,
     BAD_ENCODING,