-
-#define Ch(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
-#define Maj(x,y,z) (((x) & (y)) | ((z) & ((x) | (y))))
-#define Sigma0(x) (((x) >> 2 | (x) << 30) ^ ((x) >> 13 | (x) << 19) ^ ((x) >> 22 | (x) << 10))
-#define Sigma1(x) (((x) >> 6 | (x) << 26) ^ ((x) >> 11 | (x) << 21) ^ ((x) >> 25 | (x) << 7))
-#define sigma0(x) (((x) >> 7 | (x) << 25) ^ ((x) >> 18 | (x) << 14) ^ ((x) >> 3))
-#define sigma1(x) (((x) >> 17 | (x) << 15) ^ ((x) >> 19 | (x) << 13) ^ ((x) >> 10))
-
-#define Round(a,b,c,d,e,f,g,h,k,w) do { \
- uint32_t t1 = (h) + Sigma1(e) + Ch((e), (f), (g)) + (k) + (w); \
- uint32_t t2 = Sigma0(a) + Maj((a), (b), (c)); \
- (d) += t1; \
- (h) = t1 + t2; \
-} while(0)
-
-#ifdef WORDS_BIGENDIAN
-#define BE32(x) (x)
-#else
-#define BE32(p) ((((p) & 0xFF) << 24) | (((p) & 0xFF00) << 8) | (((p) & 0xFF0000) >> 8) | (((p) & 0xFF000000) >> 24))
-#endif
-
-static void secp256k1_sha256_initialize(secp256k1_sha256_t *hash) {
- hash->s[0] = 0x6a09e667ul;
- hash->s[1] = 0xbb67ae85ul;
- hash->s[2] = 0x3c6ef372ul;
- hash->s[3] = 0xa54ff53aul;
- hash->s[4] = 0x510e527ful;
- hash->s[5] = 0x9b05688cul;
- hash->s[6] = 0x1f83d9abul;
- hash->s[7] = 0x5be0cd19ul;
- hash->bytes = 0;
-}
-
-/** Perform one SHA-256 transformation, processing 16 big endian 32-bit words. */
-static void secp256k1_sha256_transform(uint32_t* s, const uint32_t* chunk) {
- uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
- uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
-
- Round(a, b, c, d, e, f, g, h, 0x428a2f98, w0 = BE32(chunk[0]));
- Round(h, a, b, c, d, e, f, g, 0x71374491, w1 = BE32(chunk[1]));
- Round(g, h, a, b, c, d, e, f, 0xb5c0fbcf, w2 = BE32(chunk[2]));
- Round(f, g, h, a, b, c, d, e, 0xe9b5dba5, w3 = BE32(chunk[3]));
- Round(e, f, g, h, a, b, c, d, 0x3956c25b, w4 = BE32(chunk[4]));
- Round(d, e, f, g, h, a, b, c, 0x59f111f1, w5 = BE32(chunk[5]));
- Round(c, d, e, f, g, h, a, b, 0x923f82a4, w6 = BE32(chunk[6]));
- Round(b, c, d, e, f, g, h, a, 0xab1c5ed5, w7 = BE32(chunk[7]));
- Round(a, b, c, d, e, f, g, h, 0xd807aa98, w8 = BE32(chunk[8]));
- Round(h, a, b, c, d, e, f, g, 0x12835b01, w9 = BE32(chunk[9]));
- Round(g, h, a, b, c, d, e, f, 0x243185be, w10 = BE32(chunk[10]));
- Round(f, g, h, a, b, c, d, e, 0x550c7dc3, w11 = BE32(chunk[11]));
- Round(e, f, g, h, a, b, c, d, 0x72be5d74, w12 = BE32(chunk[12]));
- Round(d, e, f, g, h, a, b, c, 0x80deb1fe, w13 = BE32(chunk[13]));
- Round(c, d, e, f, g, h, a, b, 0x9bdc06a7, w14 = BE32(chunk[14]));
- Round(b, c, d, e, f, g, h, a, 0xc19bf174, w15 = BE32(chunk[15]));
-
- Round(a, b, c, d, e, f, g, h, 0xe49b69c1, w0 += sigma1(w14) + w9 + sigma0(w1));
- Round(h, a, b, c, d, e, f, g, 0xefbe4786, w1 += sigma1(w15) + w10 + sigma0(w2));
- Round(g, h, a, b, c, d, e, f, 0x0fc19dc6, w2 += sigma1(w0) + w11 + sigma0(w3));
- Round(f, g, h, a, b, c, d, e, 0x240ca1cc, w3 += sigma1(w1) + w12 + sigma0(w4));
- Round(e, f, g, h, a, b, c, d, 0x2de92c6f, w4 += sigma1(w2) + w13 + sigma0(w5));
- Round(d, e, f, g, h, a, b, c, 0x4a7484aa, w5 += sigma1(w3) + w14 + sigma0(w6));
- Round(c, d, e, f, g, h, a, b, 0x5cb0a9dc, w6 += sigma1(w4) + w15 + sigma0(w7));
- Round(b, c, d, e, f, g, h, a, 0x76f988da, w7 += sigma1(w5) + w0 + sigma0(w8));
- Round(a, b, c, d, e, f, g, h, 0x983e5152, w8 += sigma1(w6) + w1 + sigma0(w9));
- Round(h, a, b, c, d, e, f, g, 0xa831c66d, w9 += sigma1(w7) + w2 + sigma0(w10));
- Round(g, h, a, b, c, d, e, f, 0xb00327c8, w10 += sigma1(w8) + w3 + sigma0(w11));
- Round(f, g, h, a, b, c, d, e, 0xbf597fc7, w11 += sigma1(w9) + w4 + sigma0(w12));
- Round(e, f, g, h, a, b, c, d, 0xc6e00bf3, w12 += sigma1(w10) + w5 + sigma0(w13));
- Round(d, e, f, g, h, a, b, c, 0xd5a79147, w13 += sigma1(w11) + w6 + sigma0(w14));
- Round(c, d, e, f, g, h, a, b, 0x06ca6351, w14 += sigma1(w12) + w7 + sigma0(w15));
- Round(b, c, d, e, f, g, h, a, 0x14292967, w15 += sigma1(w13) + w8 + sigma0(w0));
-
- Round(a, b, c, d, e, f, g, h, 0x27b70a85, w0 += sigma1(w14) + w9 + sigma0(w1));
- Round(h, a, b, c, d, e, f, g, 0x2e1b2138, w1 += sigma1(w15) + w10 + sigma0(w2));
- Round(g, h, a, b, c, d, e, f, 0x4d2c6dfc, w2 += sigma1(w0) + w11 + sigma0(w3));
- Round(f, g, h, a, b, c, d, e, 0x53380d13, w3 += sigma1(w1) + w12 + sigma0(w4));
- Round(e, f, g, h, a, b, c, d, 0x650a7354, w4 += sigma1(w2) + w13 + sigma0(w5));
- Round(d, e, f, g, h, a, b, c, 0x766a0abb, w5 += sigma1(w3) + w14 + sigma0(w6));
- Round(c, d, e, f, g, h, a, b, 0x81c2c92e, w6 += sigma1(w4) + w15 + sigma0(w7));
- Round(b, c, d, e, f, g, h, a, 0x92722c85, w7 += sigma1(w5) + w0 + sigma0(w8));
- Round(a, b, c, d, e, f, g, h, 0xa2bfe8a1, w8 += sigma1(w6) + w1 + sigma0(w9));
- Round(h, a, b, c, d, e, f, g, 0xa81a664b, w9 += sigma1(w7) + w2 + sigma0(w10));
- Round(g, h, a, b, c, d, e, f, 0xc24b8b70, w10 += sigma1(w8) + w3 + sigma0(w11));
- Round(f, g, h, a, b, c, d, e, 0xc76c51a3, w11 += sigma1(w9) + w4 + sigma0(w12));
- Round(e, f, g, h, a, b, c, d, 0xd192e819, w12 += sigma1(w10) + w5 + sigma0(w13));
- Round(d, e, f, g, h, a, b, c, 0xd6990624, w13 += sigma1(w11) + w6 + sigma0(w14));
- Round(c, d, e, f, g, h, a, b, 0xf40e3585, w14 += sigma1(w12) + w7 + sigma0(w15));
- Round(b, c, d, e, f, g, h, a, 0x106aa070, w15 += sigma1(w13) + w8 + sigma0(w0));
-
- Round(a, b, c, d, e, f, g, h, 0x19a4c116, w0 += sigma1(w14) + w9 + sigma0(w1));
- Round(h, a, b, c, d, e, f, g, 0x1e376c08, w1 += sigma1(w15) + w10 + sigma0(w2));
- Round(g, h, a, b, c, d, e, f, 0x2748774c, w2 += sigma1(w0) + w11 + sigma0(w3));
- Round(f, g, h, a, b, c, d, e, 0x34b0bcb5, w3 += sigma1(w1) + w12 + sigma0(w4));
- Round(e, f, g, h, a, b, c, d, 0x391c0cb3, w4 += sigma1(w2) + w13 + sigma0(w5));
- Round(d, e, f, g, h, a, b, c, 0x4ed8aa4a, w5 += sigma1(w3) + w14 + sigma0(w6));
- Round(c, d, e, f, g, h, a, b, 0x5b9cca4f, w6 += sigma1(w4) + w15 + sigma0(w7));
- Round(b, c, d, e, f, g, h, a, 0x682e6ff3, w7 += sigma1(w5) + w0 + sigma0(w8));
- Round(a, b, c, d, e, f, g, h, 0x748f82ee, w8 += sigma1(w6) + w1 + sigma0(w9));
- Round(h, a, b, c, d, e, f, g, 0x78a5636f, w9 += sigma1(w7) + w2 + sigma0(w10));
- Round(g, h, a, b, c, d, e, f, 0x84c87814, w10 += sigma1(w8) + w3 + sigma0(w11));
- Round(f, g, h, a, b, c, d, e, 0x8cc70208, w11 += sigma1(w9) + w4 + sigma0(w12));
- Round(e, f, g, h, a, b, c, d, 0x90befffa, w12 += sigma1(w10) + w5 + sigma0(w13));
- Round(d, e, f, g, h, a, b, c, 0xa4506ceb, w13 += sigma1(w11) + w6 + sigma0(w14));
- Round(c, d, e, f, g, h, a, b, 0xbef9a3f7, w14 + sigma1(w12) + w7 + sigma0(w15));
- Round(b, c, d, e, f, g, h, a, 0xc67178f2, w15 + sigma1(w13) + w8 + sigma0(w0));
-
- s[0] += a;
- s[1] += b;
- s[2] += c;
- s[3] += d;
- s[4] += e;
- s[5] += f;
- s[6] += g;
- s[7] += h;
-}
-
-static void secp256k1_sha256_write(secp256k1_sha256_t *hash, const unsigned char *data, size_t len) {
- size_t bufsize = hash->bytes & 0x3F;
- hash->bytes += len;
- while (bufsize + len >= 64) {
- /* Fill the buffer, and process it. */
- memcpy(((unsigned char*)hash->buf) + bufsize, data, 64 - bufsize);
- data += 64 - bufsize;
- len -= 64 - bufsize;
- secp256k1_sha256_transform(hash->s, hash->buf);
- bufsize = 0;
- }
- if (len) {
- /* Fill the buffer with what remains. */
- memcpy(((unsigned char*)hash->buf) + bufsize, data, len);
- }
-}
-
-static void secp256k1_sha256_finalize(secp256k1_sha256_t *hash, unsigned char *out32) {
- static const unsigned char pad[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
- uint32_t sizedesc[2];
- uint32_t out[8];
- int i = 0;
- sizedesc[0] = BE32(hash->bytes >> 29);
- sizedesc[1] = BE32(hash->bytes << 3);
- secp256k1_sha256_write(hash, pad, 1 + ((119 - (hash->bytes % 64)) % 64));
- secp256k1_sha256_write(hash, (const unsigned char*)sizedesc, 8);
- for (i = 0; i < 8; i++) {
- out[i] = BE32(hash->s[i]);
- hash->s[i] = 0;
- }
- memcpy(out32, (const unsigned char*)out, 32);
-}
-
-static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256_t *hash, const unsigned char *key, size_t keylen) {
- int n;
- unsigned char rkey[64];
- if (keylen <= 64) {
- memcpy(rkey, key, keylen);
- memset(rkey + keylen, 0, 64 - keylen);
- } else {
- secp256k1_sha256_t sha256;
- secp256k1_sha256_initialize(&sha256);
- secp256k1_sha256_write(&sha256, key, keylen);
- secp256k1_sha256_finalize(&sha256, rkey);
- memset(rkey + 32, 0, 32);
- }
-
- secp256k1_sha256_initialize(&hash->outer);
- for (n = 0; n < 64; n++) {
- rkey[n] ^= 0x5c;
- }
- secp256k1_sha256_write(&hash->outer, rkey, 64);
-
- secp256k1_sha256_initialize(&hash->inner);
- for (n = 0; n < 64; n++) {
- rkey[n] ^= 0x5c ^ 0x36;
- }
- secp256k1_sha256_write(&hash->inner, rkey, 64);
- memset(rkey, 0, 64);
-}
-
-static void secp256k1_hmac_sha256_write(secp256k1_hmac_sha256_t *hash, const unsigned char *data, size_t size) {
- secp256k1_sha256_write(&hash->inner, data, size);
-}
-
-static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256_t *hash, unsigned char *out32) {
- unsigned char temp[32];
- secp256k1_sha256_finalize(&hash->inner, temp);
- secp256k1_sha256_write(&hash->outer, temp, 32);
- memset(temp, 0, 32);
- secp256k1_sha256_finalize(&hash->outer, out32);
-}
-
-
-static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256_t *rng, const unsigned char *key, size_t keylen) {
- secp256k1_hmac_sha256_t hmac;
- static const unsigned char zero[1] = {0x00};
- static const unsigned char one[1] = {0x01};
-
- memset(rng->v, 0x01, 32); /* RFC6979 3.2.b. */
- memset(rng->k, 0x00, 32); /* RFC6979 3.2.c. */
-
- /* RFC6979 3.2.d. */
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_write(&hmac, zero, 1);
- secp256k1_hmac_sha256_write(&hmac, key, keylen);
- secp256k1_hmac_sha256_finalize(&hmac, rng->k);
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_finalize(&hmac, rng->v);
-
- /* RFC6979 3.2.f. */
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_write(&hmac, one, 1);
- secp256k1_hmac_sha256_write(&hmac, key, keylen);
- secp256k1_hmac_sha256_finalize(&hmac, rng->k);
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_finalize(&hmac, rng->v);
- rng->retry = 0;
-}
-
-static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256_t *rng, unsigned char *out, size_t outlen) {
- /* RFC6979 3.2.h. */
- static const unsigned char zero[1] = {0x00};
- if (rng->retry) {
- secp256k1_hmac_sha256_t hmac;
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_write(&hmac, zero, 1);
- secp256k1_hmac_sha256_finalize(&hmac, rng->k);
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_finalize(&hmac, rng->v);
- }
-
- while (outlen > 0) {
- secp256k1_hmac_sha256_t hmac;
- int now = outlen;
- secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
- secp256k1_hmac_sha256_write(&hmac, rng->v, 32);
- secp256k1_hmac_sha256_finalize(&hmac, rng->v);
- if (now > 32) {
- now = 32;
- }
- memcpy(out, rng->v, now);
- out += now;
- outlen -= now;
- }
-
- rng->retry = 1;
-}
-
-static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hmac_sha256_t *rng) {
- memset(rng->k, 0, 32);
- memset(rng->v, 0, 32);
- rng->retry = 0;
-}
-
-#undef BE32
-#undef Round
-#undef sigma1
-#undef sigma0
-#undef Sigma1
-#undef Sigma0
-#undef Maj
-#undef Ch
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1.java b/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1.java
deleted file mode 100644
index 1c67802fba..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1.java
+++ /dev/null
@@ -1,446 +0,0 @@
-/*
- * Copyright 2013 Google Inc.
- * Copyright 2014-2016 the libsecp256k1 contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.bitcoin;
-
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-
-import java.math.BigInteger;
-import com.google.common.base.Preconditions;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-import static org.bitcoin.NativeSecp256k1Util.*;
-
-/**
- * This class holds native methods to handle ECDSA verification.
- *
- * You can find an example library that can be used for this at https://github.com/bitcoin/secp256k1
- *
- * To build secp256k1 for use with bitcoinj, run
- * `./configure --enable-jni --enable-experimental --enable-module-ecdh`
- * and `make` then copy `.libs/libsecp256k1.so` to your system library path
- * or point the JVM to the folder containing it with -Djava.library.path
- *
- */
-public class NativeSecp256k1 {
-
- private static final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
- private static final Lock r = rwl.readLock();
- private static final Lock w = rwl.writeLock();
- private static ThreadLocal nativeECDSABuffer = new ThreadLocal();
- /**
- * Verifies the given secp256k1 signature in native code.
- * Calling when enabled == false is undefined (probably library not loaded)
- *
- * @param data The data which was signed, must be exactly 32 bytes
- * @param signature The signature
- * @param pub The public key which did the signing
- */
- public static boolean verify(byte[] data, byte[] signature, byte[] pub) throws AssertFailException{
- Preconditions.checkArgument(data.length == 32 && signature.length <= 520 && pub.length <= 520);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < 520) {
- byteBuff = ByteBuffer.allocateDirect(520);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(data);
- byteBuff.put(signature);
- byteBuff.put(pub);
-
- byte[][] retByteArray;
-
- r.lock();
- try {
- return secp256k1_ecdsa_verify(byteBuff, Secp256k1Context.getContext(), signature.length, pub.length) == 1;
- } finally {
- r.unlock();
- }
- }
-
- /**
- * libsecp256k1 Create an ECDSA signature.
- *
- * @param data Message hash, 32 bytes
- * @param key Secret key, 32 bytes
- *
- * Return values
- * @param sig byte array of signature
- */
- public static byte[] sign(byte[] data, byte[] sec) throws AssertFailException{
- Preconditions.checkArgument(data.length == 32 && sec.length <= 32);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < 32 + 32) {
- byteBuff = ByteBuffer.allocateDirect(32 + 32);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(data);
- byteBuff.put(sec);
-
- byte[][] retByteArray;
-
- r.lock();
- try {
- retByteArray = secp256k1_ecdsa_sign(byteBuff, Secp256k1Context.getContext());
- } finally {
- r.unlock();
- }
-
- byte[] sigArr = retByteArray[0];
- int sigLen = new BigInteger(new byte[] { retByteArray[1][0] }).intValue();
- int retVal = new BigInteger(new byte[] { retByteArray[1][1] }).intValue();
-
- assertEquals(sigArr.length, sigLen, "Got bad signature length.");
-
- return retVal == 0 ? new byte[0] : sigArr;
- }
-
- /**
- * libsecp256k1 Seckey Verify - returns 1 if valid, 0 if invalid
- *
- * @param seckey ECDSA Secret key, 32 bytes
- */
- public static boolean secKeyVerify(byte[] seckey) {
- Preconditions.checkArgument(seckey.length == 32);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < seckey.length) {
- byteBuff = ByteBuffer.allocateDirect(seckey.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(seckey);
-
- r.lock();
- try {
- return secp256k1_ec_seckey_verify(byteBuff,Secp256k1Context.getContext()) == 1;
- } finally {
- r.unlock();
- }
- }
-
-
- /**
- * libsecp256k1 Compute Pubkey - computes public key from secret key
- *
- * @param seckey ECDSA Secret key, 32 bytes
- *
- * Return values
- * @param pubkey ECDSA Public key, 33 or 65 bytes
- */
- //TODO add a 'compressed' arg
- public static byte[] computePubkey(byte[] seckey) throws AssertFailException{
- Preconditions.checkArgument(seckey.length == 32);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < seckey.length) {
- byteBuff = ByteBuffer.allocateDirect(seckey.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(seckey);
-
- byte[][] retByteArray;
-
- r.lock();
- try {
- retByteArray = secp256k1_ec_pubkey_create(byteBuff, Secp256k1Context.getContext());
- } finally {
- r.unlock();
- }
-
- byte[] pubArr = retByteArray[0];
- int pubLen = new BigInteger(new byte[] { retByteArray[1][0] }).intValue();
- int retVal = new BigInteger(new byte[] { retByteArray[1][1] }).intValue();
-
- assertEquals(pubArr.length, pubLen, "Got bad pubkey length.");
-
- return retVal == 0 ? new byte[0]: pubArr;
- }
-
- /**
- * libsecp256k1 Cleanup - This destroys the secp256k1 context object
- * This should be called at the end of the program for proper cleanup of the context.
- */
- public static synchronized void cleanup() {
- w.lock();
- try {
- secp256k1_destroy_context(Secp256k1Context.getContext());
- } finally {
- w.unlock();
- }
- }
-
- public static long cloneContext() {
- r.lock();
- try {
- return secp256k1_ctx_clone(Secp256k1Context.getContext());
- } finally { r.unlock(); }
- }
-
- /**
- * libsecp256k1 PrivKey Tweak-Mul - Tweak privkey by multiplying to it
- *
- * @param tweak some bytes to tweak with
- * @param seckey 32-byte seckey
- */
- public static byte[] privKeyTweakMul(byte[] privkey, byte[] tweak) throws AssertFailException{
- Preconditions.checkArgument(privkey.length == 32);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < privkey.length + tweak.length) {
- byteBuff = ByteBuffer.allocateDirect(privkey.length + tweak.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(privkey);
- byteBuff.put(tweak);
-
- byte[][] retByteArray;
- r.lock();
- try {
- retByteArray = secp256k1_privkey_tweak_mul(byteBuff,Secp256k1Context.getContext());
- } finally {
- r.unlock();
- }
-
- byte[] privArr = retByteArray[0];
-
- int privLen = (byte) new BigInteger(new byte[] { retByteArray[1][0] }).intValue() & 0xFF;
- int retVal = new BigInteger(new byte[] { retByteArray[1][1] }).intValue();
-
- assertEquals(privArr.length, privLen, "Got bad pubkey length.");
-
- assertEquals(retVal, 1, "Failed return value check.");
-
- return privArr;
- }
-
- /**
- * libsecp256k1 PrivKey Tweak-Add - Tweak privkey by adding to it
- *
- * @param tweak some bytes to tweak with
- * @param seckey 32-byte seckey
- */
- public static byte[] privKeyTweakAdd(byte[] privkey, byte[] tweak) throws AssertFailException{
- Preconditions.checkArgument(privkey.length == 32);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < privkey.length + tweak.length) {
- byteBuff = ByteBuffer.allocateDirect(privkey.length + tweak.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(privkey);
- byteBuff.put(tweak);
-
- byte[][] retByteArray;
- r.lock();
- try {
- retByteArray = secp256k1_privkey_tweak_add(byteBuff,Secp256k1Context.getContext());
- } finally {
- r.unlock();
- }
-
- byte[] privArr = retByteArray[0];
-
- int privLen = (byte) new BigInteger(new byte[] { retByteArray[1][0] }).intValue() & 0xFF;
- int retVal = new BigInteger(new byte[] { retByteArray[1][1] }).intValue();
-
- assertEquals(privArr.length, privLen, "Got bad pubkey length.");
-
- assertEquals(retVal, 1, "Failed return value check.");
-
- return privArr;
- }
-
- /**
- * libsecp256k1 PubKey Tweak-Add - Tweak pubkey by adding to it
- *
- * @param tweak some bytes to tweak with
- * @param pubkey 32-byte seckey
- */
- public static byte[] pubKeyTweakAdd(byte[] pubkey, byte[] tweak) throws AssertFailException{
- Preconditions.checkArgument(pubkey.length == 33 || pubkey.length == 65);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < pubkey.length + tweak.length) {
- byteBuff = ByteBuffer.allocateDirect(pubkey.length + tweak.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(pubkey);
- byteBuff.put(tweak);
-
- byte[][] retByteArray;
- r.lock();
- try {
- retByteArray = secp256k1_pubkey_tweak_add(byteBuff,Secp256k1Context.getContext(), pubkey.length);
- } finally {
- r.unlock();
- }
-
- byte[] pubArr = retByteArray[0];
-
- int pubLen = (byte) new BigInteger(new byte[] { retByteArray[1][0] }).intValue() & 0xFF;
- int retVal = new BigInteger(new byte[] { retByteArray[1][1] }).intValue();
-
- assertEquals(pubArr.length, pubLen, "Got bad pubkey length.");
-
- assertEquals(retVal, 1, "Failed return value check.");
-
- return pubArr;
- }
-
- /**
- * libsecp256k1 PubKey Tweak-Mul - Tweak pubkey by multiplying to it
- *
- * @param tweak some bytes to tweak with
- * @param pubkey 32-byte seckey
- */
- public static byte[] pubKeyTweakMul(byte[] pubkey, byte[] tweak) throws AssertFailException{
- Preconditions.checkArgument(pubkey.length == 33 || pubkey.length == 65);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < pubkey.length + tweak.length) {
- byteBuff = ByteBuffer.allocateDirect(pubkey.length + tweak.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(pubkey);
- byteBuff.put(tweak);
-
- byte[][] retByteArray;
- r.lock();
- try {
- retByteArray = secp256k1_pubkey_tweak_mul(byteBuff,Secp256k1Context.getContext(), pubkey.length);
- } finally {
- r.unlock();
- }
-
- byte[] pubArr = retByteArray[0];
-
- int pubLen = (byte) new BigInteger(new byte[] { retByteArray[1][0] }).intValue() & 0xFF;
- int retVal = new BigInteger(new byte[] { retByteArray[1][1] }).intValue();
-
- assertEquals(pubArr.length, pubLen, "Got bad pubkey length.");
-
- assertEquals(retVal, 1, "Failed return value check.");
-
- return pubArr;
- }
-
- /**
- * libsecp256k1 create ECDH secret - constant time ECDH calculation
- *
- * @param seckey byte array of secret key used in exponentiaion
- * @param pubkey byte array of public key used in exponentiaion
- */
- public static byte[] createECDHSecret(byte[] seckey, byte[] pubkey) throws AssertFailException{
- Preconditions.checkArgument(seckey.length <= 32 && pubkey.length <= 65);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < 32 + pubkey.length) {
- byteBuff = ByteBuffer.allocateDirect(32 + pubkey.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(seckey);
- byteBuff.put(pubkey);
-
- byte[][] retByteArray;
- r.lock();
- try {
- retByteArray = secp256k1_ecdh(byteBuff, Secp256k1Context.getContext(), pubkey.length);
- } finally {
- r.unlock();
- }
-
- byte[] resArr = retByteArray[0];
- int retVal = new BigInteger(new byte[] { retByteArray[1][0] }).intValue();
-
- assertEquals(resArr.length, 32, "Got bad result length.");
- assertEquals(retVal, 1, "Failed return value check.");
-
- return resArr;
- }
-
- /**
- * libsecp256k1 randomize - updates the context randomization
- *
- * @param seed 32-byte random seed
- */
- public static synchronized boolean randomize(byte[] seed) throws AssertFailException{
- Preconditions.checkArgument(seed.length == 32 || seed == null);
-
- ByteBuffer byteBuff = nativeECDSABuffer.get();
- if (byteBuff == null || byteBuff.capacity() < seed.length) {
- byteBuff = ByteBuffer.allocateDirect(seed.length);
- byteBuff.order(ByteOrder.nativeOrder());
- nativeECDSABuffer.set(byteBuff);
- }
- byteBuff.rewind();
- byteBuff.put(seed);
-
- w.lock();
- try {
- return secp256k1_context_randomize(byteBuff, Secp256k1Context.getContext()) == 1;
- } finally {
- w.unlock();
- }
- }
-
- private static native long secp256k1_ctx_clone(long context);
-
- private static native int secp256k1_context_randomize(ByteBuffer byteBuff, long context);
-
- private static native byte[][] secp256k1_privkey_tweak_add(ByteBuffer byteBuff, long context);
-
- private static native byte[][] secp256k1_privkey_tweak_mul(ByteBuffer byteBuff, long context);
-
- private static native byte[][] secp256k1_pubkey_tweak_add(ByteBuffer byteBuff, long context, int pubLen);
-
- private static native byte[][] secp256k1_pubkey_tweak_mul(ByteBuffer byteBuff, long context, int pubLen);
-
- private static native void secp256k1_destroy_context(long context);
-
- private static native int secp256k1_ecdsa_verify(ByteBuffer byteBuff, long context, int sigLen, int pubLen);
-
- private static native byte[][] secp256k1_ecdsa_sign(ByteBuffer byteBuff, long context);
-
- private static native int secp256k1_ec_seckey_verify(ByteBuffer byteBuff, long context);
-
- private static native byte[][] secp256k1_ec_pubkey_create(ByteBuffer byteBuff, long context);
-
- private static native byte[][] secp256k1_ec_pubkey_parse(ByteBuffer byteBuff, long context, int inputLen);
-
- private static native byte[][] secp256k1_ecdh(ByteBuffer byteBuff, long context, int inputLen);
-
-}
diff --git a/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1Test.java b/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1Test.java
deleted file mode 100644
index c00d08899b..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1Test.java
+++ /dev/null
@@ -1,226 +0,0 @@
-package org.bitcoin;
-
-import com.google.common.io.BaseEncoding;
-import java.util.Arrays;
-import java.math.BigInteger;
-import javax.xml.bind.DatatypeConverter;
-import static org.bitcoin.NativeSecp256k1Util.*;
-
-/**
- * This class holds test cases defined for testing this library.
- */
-public class NativeSecp256k1Test {
-
- //TODO improve comments/add more tests
- /**
- * This tests verify() for a valid signature
- */
- public static void testVerifyPos() throws AssertFailException{
- boolean result = false;
- byte[] data = BaseEncoding.base16().lowerCase().decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()); //sha256hash of "testing"
- byte[] sig = BaseEncoding.base16().lowerCase().decode("3044022079BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F817980220294F14E883B3F525B5367756C2A11EF6CF84B730B36C17CB0C56F0AAB2C98589".toLowerCase());
- byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
-
- result = NativeSecp256k1.verify( data, sig, pub);
- assertEquals( result, true , "testVerifyPos");
- }
-
- /**
- * This tests verify() for a non-valid signature
- */
- public static void testVerifyNeg() throws AssertFailException{
- boolean result = false;
- byte[] data = BaseEncoding.base16().lowerCase().decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A91".toLowerCase()); //sha256hash of "testing"
- byte[] sig = BaseEncoding.base16().lowerCase().decode("3044022079BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F817980220294F14E883B3F525B5367756C2A11EF6CF84B730B36C17CB0C56F0AAB2C98589".toLowerCase());
- byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
-
- result = NativeSecp256k1.verify( data, sig, pub);
- //System.out.println(" TEST " + new BigInteger(1, resultbytes).toString(16));
- assertEquals( result, false , "testVerifyNeg");
- }
-
- /**
- * This tests secret key verify() for a valid secretkey
- */
- public static void testSecKeyVerifyPos() throws AssertFailException{
- boolean result = false;
- byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
-
- result = NativeSecp256k1.secKeyVerify( sec );
- //System.out.println(" TEST " + new BigInteger(1, resultbytes).toString(16));
- assertEquals( result, true , "testSecKeyVerifyPos");
- }
-
- /**
- * This tests secret key verify() for a invalid secretkey
- */
- public static void testSecKeyVerifyNeg() throws AssertFailException{
- boolean result = false;
- byte[] sec = BaseEncoding.base16().lowerCase().decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".toLowerCase());
-
- result = NativeSecp256k1.secKeyVerify( sec );
- //System.out.println(" TEST " + new BigInteger(1, resultbytes).toString(16));
- assertEquals( result, false , "testSecKeyVerifyNeg");
- }
-
- /**
- * This tests public key create() for a valid secretkey
- */
- public static void testPubKeyCreatePos() throws AssertFailException{
- byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
-
- byte[] resultArr = NativeSecp256k1.computePubkey( sec);
- String pubkeyString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( pubkeyString , "04C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D2103ED494718C697AC9AEBCFD19612E224DB46661011863ED2FC54E71861E2A6" , "testPubKeyCreatePos");
- }
-
- /**
- * This tests public key create() for a invalid secretkey
- */
- public static void testPubKeyCreateNeg() throws AssertFailException{
- byte[] sec = BaseEncoding.base16().lowerCase().decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".toLowerCase());
-
- byte[] resultArr = NativeSecp256k1.computePubkey( sec);
- String pubkeyString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( pubkeyString, "" , "testPubKeyCreateNeg");
- }
-
- /**
- * This tests sign() for a valid secretkey
- */
- public static void testSignPos() throws AssertFailException{
-
- byte[] data = BaseEncoding.base16().lowerCase().decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()); //sha256hash of "testing"
- byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
-
- byte[] resultArr = NativeSecp256k1.sign(data, sec);
- String sigString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( sigString, "30440220182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A202201C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9" , "testSignPos");
- }
-
- /**
- * This tests sign() for a invalid secretkey
- */
- public static void testSignNeg() throws AssertFailException{
- byte[] data = BaseEncoding.base16().lowerCase().decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()); //sha256hash of "testing"
- byte[] sec = BaseEncoding.base16().lowerCase().decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".toLowerCase());
-
- byte[] resultArr = NativeSecp256k1.sign(data, sec);
- String sigString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( sigString, "" , "testSignNeg");
- }
-
- /**
- * This tests private key tweak-add
- */
- public static void testPrivKeyTweakAdd_1() throws AssertFailException {
- byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
- byte[] data = BaseEncoding.base16().lowerCase().decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()); //sha256hash of "tweak"
-
- byte[] resultArr = NativeSecp256k1.privKeyTweakAdd( sec , data );
- String sigString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( sigString , "A168571E189E6F9A7E2D657A4B53AE99B909F7E712D1C23CED28093CD57C88F3" , "testPrivKeyAdd_1");
- }
-
- /**
- * This tests private key tweak-mul
- */
- public static void testPrivKeyTweakMul_1() throws AssertFailException {
- byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
- byte[] data = BaseEncoding.base16().lowerCase().decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()); //sha256hash of "tweak"
-
- byte[] resultArr = NativeSecp256k1.privKeyTweakMul( sec , data );
- String sigString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( sigString , "97F8184235F101550F3C71C927507651BD3F1CDB4A5A33B8986ACF0DEE20FFFC" , "testPrivKeyMul_1");
- }
-
- /**
- * This tests private key tweak-add uncompressed
- */
- public static void testPrivKeyTweakAdd_2() throws AssertFailException {
- byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
- byte[] data = BaseEncoding.base16().lowerCase().decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()); //sha256hash of "tweak"
-
- byte[] resultArr = NativeSecp256k1.pubKeyTweakAdd( pub , data );
- String sigString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( sigString , "0411C6790F4B663CCE607BAAE08C43557EDC1A4D11D88DFCB3D841D0C6A941AF525A268E2A863C148555C48FB5FBA368E88718A46E205FABC3DBA2CCFFAB0796EF" , "testPrivKeyAdd_2");
- }
-
- /**
- * This tests private key tweak-mul uncompressed
- */
- public static void testPrivKeyTweakMul_2() throws AssertFailException {
- byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
- byte[] data = BaseEncoding.base16().lowerCase().decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()); //sha256hash of "tweak"
-
- byte[] resultArr = NativeSecp256k1.pubKeyTweakMul( pub , data );
- String sigString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( sigString , "04E0FE6FE55EBCA626B98A807F6CAF654139E14E5E3698F01A9A658E21DC1D2791EC060D4F412A794D5370F672BC94B722640B5F76914151CFCA6E712CA48CC589" , "testPrivKeyMul_2");
- }
-
- /**
- * This tests seed randomization
- */
- public static void testRandomize() throws AssertFailException {
- byte[] seed = BaseEncoding.base16().lowerCase().decode("A441B15FE9A3CF56661190A0B93B9DEC7D04127288CC87250967CF3B52894D11".toLowerCase()); //sha256hash of "random"
- boolean result = NativeSecp256k1.randomize(seed);
- assertEquals( result, true, "testRandomize");
- }
-
- public static void testCreateECDHSecret() throws AssertFailException{
-
- byte[] sec = BaseEncoding.base16().lowerCase().decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase());
- byte[] pub = BaseEncoding.base16().lowerCase().decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase());
-
- byte[] resultArr = NativeSecp256k1.createECDHSecret(sec, pub);
- String ecdhString = javax.xml.bind.DatatypeConverter.printHexBinary(resultArr);
- assertEquals( ecdhString, "2A2A67007A926E6594AF3EB564FC74005B37A9C8AEF2033C4552051B5C87F043" , "testCreateECDHSecret");
- }
-
- public static void main(String[] args) throws AssertFailException{
-
-
- System.out.println("\n libsecp256k1 enabled: " + Secp256k1Context.isEnabled() + "\n");
-
- assertEquals( Secp256k1Context.isEnabled(), true, "isEnabled" );
-
- //Test verify() success/fail
- testVerifyPos();
- testVerifyNeg();
-
- //Test secKeyVerify() success/fail
- testSecKeyVerifyPos();
- testSecKeyVerifyNeg();
-
- //Test computePubkey() success/fail
- testPubKeyCreatePos();
- testPubKeyCreateNeg();
-
- //Test sign() success/fail
- testSignPos();
- testSignNeg();
-
- //Test privKeyTweakAdd() 1
- testPrivKeyTweakAdd_1();
-
- //Test privKeyTweakMul() 2
- testPrivKeyTweakMul_1();
-
- //Test privKeyTweakAdd() 3
- testPrivKeyTweakAdd_2();
-
- //Test privKeyTweakMul() 4
- testPrivKeyTweakMul_2();
-
- //Test randomize()
- testRandomize();
-
- //Test ECDH
- testCreateECDHSecret();
-
- NativeSecp256k1.cleanup();
-
- System.out.println(" All tests passed." );
-
- }
-}
diff --git a/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1Util.java b/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1Util.java
deleted file mode 100644
index 04732ba044..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/NativeSecp256k1Util.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright 2014-2016 the libsecp256k1 contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.bitcoin;
-
-public class NativeSecp256k1Util{
-
- public static void assertEquals( int val, int val2, String message ) throws AssertFailException{
- if( val != val2 )
- throw new AssertFailException("FAIL: " + message);
- }
-
- public static void assertEquals( boolean val, boolean val2, String message ) throws AssertFailException{
- if( val != val2 )
- throw new AssertFailException("FAIL: " + message);
- else
- System.out.println("PASS: " + message);
- }
-
- public static void assertEquals( String val, String val2, String message ) throws AssertFailException{
- if( !val.equals(val2) )
- throw new AssertFailException("FAIL: " + message);
- else
- System.out.println("PASS: " + message);
- }
-
- public static class AssertFailException extends Exception {
- public AssertFailException(String message) {
- super( message );
- }
- }
-}
diff --git a/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/Secp256k1Context.java b/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/Secp256k1Context.java
deleted file mode 100644
index 216c986a8b..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/java/org/bitcoin/Secp256k1Context.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright 2014-2016 the libsecp256k1 contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.bitcoin;
-
-/**
- * This class holds the context reference used in native methods
- * to handle ECDSA operations.
- */
-public class Secp256k1Context {
- private static final boolean enabled; //true if the library is loaded
- private static final long context; //ref to pointer to context obj
-
- static { //static initializer
- boolean isEnabled = true;
- long contextRef = -1;
- try {
- System.loadLibrary("secp256k1");
- contextRef = secp256k1_init_context();
- } catch (UnsatisfiedLinkError e) {
- System.out.println("UnsatisfiedLinkError: " + e.toString());
- isEnabled = false;
- }
- enabled = isEnabled;
- context = contextRef;
- }
-
- public static boolean isEnabled() {
- return enabled;
- }
-
- public static long getContext() {
- if(!enabled) return -1; //sanity check
- return context;
- }
-
- private static native long secp256k1_init_context();
-}
diff --git a/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_NativeSecp256k1.c b/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_NativeSecp256k1.c
deleted file mode 100644
index bcef7b32ce..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_NativeSecp256k1.c
+++ /dev/null
@@ -1,377 +0,0 @@
-#include
-#include
-#include
-#include "org_bitcoin_NativeSecp256k1.h"
-#include "include/secp256k1.h"
-#include "include/secp256k1_ecdh.h"
-#include "include/secp256k1_recovery.h"
-
-
-SECP256K1_API jlong JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ctx_1clone
- (JNIEnv* env, jclass classObject, jlong ctx_l)
-{
- const secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
-
- jlong ctx_clone_l = (uintptr_t) secp256k1_context_clone(ctx);
-
- (void)classObject;(void)env;
-
- return ctx_clone_l;
-
-}
-
-SECP256K1_API jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1context_1randomize
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
-
- const unsigned char* seed = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
-
- (void)classObject;
-
- return secp256k1_context_randomize(ctx, seed);
-
-}
-
-SECP256K1_API void JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1destroy_1context
- (JNIEnv* env, jclass classObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
-
- secp256k1_context_destroy(ctx);
-
- (void)classObject;(void)env;
-}
-
-SECP256K1_API jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1verify
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l, jint siglen, jint publen)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
-
- unsigned char* data = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
- const unsigned char* sigdata = { (unsigned char*) (data + 32) };
- const unsigned char* pubdata = { (unsigned char*) (data + siglen + 32) };
-
- secp256k1_ecdsa_signature sig;
- secp256k1_pubkey pubkey;
-
- int ret = secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigdata, siglen);
-
- if( ret ) {
- ret = secp256k1_ec_pubkey_parse(ctx, &pubkey, pubdata, publen);
-
- if( ret ) {
- ret = secp256k1_ecdsa_verify(ctx, &sig, data, &pubkey);
- }
- }
-
- (void)classObject;
-
- return ret;
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1sign
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- unsigned char* data = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
- unsigned char* secKey = (unsigned char*) (data + 32);
-
- jobjectArray retArray;
- jbyteArray sigArray, intsByteArray;
- unsigned char intsarray[2];
-
- secp256k1_ecdsa_signature sig[72];
-
- int ret = secp256k1_ecdsa_sign(ctx, sig, data, secKey, NULL, NULL );
-
- unsigned char outputSer[72];
- size_t outputLen = 72;
-
- if( ret ) {
- int ret2 = secp256k1_ecdsa_signature_serialize_der(ctx,outputSer, &outputLen, sig ); (void)ret2;
- }
-
- intsarray[0] = outputLen;
- intsarray[1] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- sigArray = (*env)->NewByteArray(env, outputLen);
- (*env)->SetByteArrayRegion(env, sigArray, 0, outputLen, (jbyte*)outputSer);
- (*env)->SetObjectArrayElement(env, retArray, 0, sigArray);
-
- intsByteArray = (*env)->NewByteArray(env, 2);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 2, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-}
-
-SECP256K1_API jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ec_1seckey_1verify
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- unsigned char* secKey = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
-
- (void)classObject;
-
- return secp256k1_ec_seckey_verify(ctx, secKey);
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ec_1pubkey_1create
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- const unsigned char* secKey = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
-
- secp256k1_pubkey pubkey;
-
- jobjectArray retArray;
- jbyteArray pubkeyArray, intsByteArray;
- unsigned char intsarray[2];
-
- int ret = secp256k1_ec_pubkey_create(ctx, &pubkey, secKey);
-
- unsigned char outputSer[65];
- size_t outputLen = 65;
-
- if( ret ) {
- int ret2 = secp256k1_ec_pubkey_serialize(ctx,outputSer, &outputLen, &pubkey,SECP256K1_EC_UNCOMPRESSED );(void)ret2;
- }
-
- intsarray[0] = outputLen;
- intsarray[1] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- pubkeyArray = (*env)->NewByteArray(env, outputLen);
- (*env)->SetByteArrayRegion(env, pubkeyArray, 0, outputLen, (jbyte*)outputSer);
- (*env)->SetObjectArrayElement(env, retArray, 0, pubkeyArray);
-
- intsByteArray = (*env)->NewByteArray(env, 2);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 2, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1privkey_1tweak_1add
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- unsigned char* privkey = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
- const unsigned char* tweak = (unsigned char*) (privkey + 32);
-
- jobjectArray retArray;
- jbyteArray privArray, intsByteArray;
- unsigned char intsarray[2];
-
- int privkeylen = 32;
-
- int ret = secp256k1_ec_privkey_tweak_add(ctx, privkey, tweak);
-
- intsarray[0] = privkeylen;
- intsarray[1] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- privArray = (*env)->NewByteArray(env, privkeylen);
- (*env)->SetByteArrayRegion(env, privArray, 0, privkeylen, (jbyte*)privkey);
- (*env)->SetObjectArrayElement(env, retArray, 0, privArray);
-
- intsByteArray = (*env)->NewByteArray(env, 2);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 2, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1privkey_1tweak_1mul
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- unsigned char* privkey = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
- const unsigned char* tweak = (unsigned char*) (privkey + 32);
-
- jobjectArray retArray;
- jbyteArray privArray, intsByteArray;
- unsigned char intsarray[2];
-
- int privkeylen = 32;
-
- int ret = secp256k1_ec_privkey_tweak_mul(ctx, privkey, tweak);
-
- intsarray[0] = privkeylen;
- intsarray[1] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- privArray = (*env)->NewByteArray(env, privkeylen);
- (*env)->SetByteArrayRegion(env, privArray, 0, privkeylen, (jbyte*)privkey);
- (*env)->SetObjectArrayElement(env, retArray, 0, privArray);
-
- intsByteArray = (*env)->NewByteArray(env, 2);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 2, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1pubkey_1tweak_1add
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l, jint publen)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
-/* secp256k1_pubkey* pubkey = (secp256k1_pubkey*) (*env)->GetDirectBufferAddress(env, byteBufferObject);*/
- unsigned char* pkey = (*env)->GetDirectBufferAddress(env, byteBufferObject);
- const unsigned char* tweak = (unsigned char*) (pkey + publen);
-
- jobjectArray retArray;
- jbyteArray pubArray, intsByteArray;
- unsigned char intsarray[2];
- unsigned char outputSer[65];
- size_t outputLen = 65;
-
- secp256k1_pubkey pubkey;
- int ret = secp256k1_ec_pubkey_parse(ctx, &pubkey, pkey, publen);
-
- if( ret ) {
- ret = secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, tweak);
- }
-
- if( ret ) {
- int ret2 = secp256k1_ec_pubkey_serialize(ctx,outputSer, &outputLen, &pubkey,SECP256K1_EC_UNCOMPRESSED );(void)ret2;
- }
-
- intsarray[0] = outputLen;
- intsarray[1] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- pubArray = (*env)->NewByteArray(env, outputLen);
- (*env)->SetByteArrayRegion(env, pubArray, 0, outputLen, (jbyte*)outputSer);
- (*env)->SetObjectArrayElement(env, retArray, 0, pubArray);
-
- intsByteArray = (*env)->NewByteArray(env, 2);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 2, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1pubkey_1tweak_1mul
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l, jint publen)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- unsigned char* pkey = (*env)->GetDirectBufferAddress(env, byteBufferObject);
- const unsigned char* tweak = (unsigned char*) (pkey + publen);
-
- jobjectArray retArray;
- jbyteArray pubArray, intsByteArray;
- unsigned char intsarray[2];
- unsigned char outputSer[65];
- size_t outputLen = 65;
-
- secp256k1_pubkey pubkey;
- int ret = secp256k1_ec_pubkey_parse(ctx, &pubkey, pkey, publen);
-
- if ( ret ) {
- ret = secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey, tweak);
- }
-
- if( ret ) {
- int ret2 = secp256k1_ec_pubkey_serialize(ctx,outputSer, &outputLen, &pubkey,SECP256K1_EC_UNCOMPRESSED );(void)ret2;
- }
-
- intsarray[0] = outputLen;
- intsarray[1] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- pubArray = (*env)->NewByteArray(env, outputLen);
- (*env)->SetByteArrayRegion(env, pubArray, 0, outputLen, (jbyte*)outputSer);
- (*env)->SetObjectArrayElement(env, retArray, 0, pubArray);
-
- intsByteArray = (*env)->NewByteArray(env, 2);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 2, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-}
-
-SECP256K1_API jlong JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1pubkey_1combine
- (JNIEnv * env, jclass classObject, jobject byteBufferObject, jlong ctx_l, jint numkeys)
-{
- (void)classObject;(void)env;(void)byteBufferObject;(void)ctx_l;(void)numkeys;
-
- return 0;
-}
-
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdh
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l, jint publen)
-{
- secp256k1_context *ctx = (secp256k1_context*)(uintptr_t)ctx_l;
- const unsigned char* secdata = (*env)->GetDirectBufferAddress(env, byteBufferObject);
- const unsigned char* pubdata = (const unsigned char*) (secdata + 32);
-
- jobjectArray retArray;
- jbyteArray outArray, intsByteArray;
- unsigned char intsarray[1];
- secp256k1_pubkey pubkey;
- unsigned char nonce_res[32];
- size_t outputLen = 32;
-
- int ret = secp256k1_ec_pubkey_parse(ctx, &pubkey, pubdata, publen);
-
- if (ret) {
- ret = secp256k1_ecdh(
- ctx,
- nonce_res,
- &pubkey,
- secdata
- );
- }
-
- intsarray[0] = ret;
-
- retArray = (*env)->NewObjectArray(env, 2,
- (*env)->FindClass(env, "[B"),
- (*env)->NewByteArray(env, 1));
-
- outArray = (*env)->NewByteArray(env, outputLen);
- (*env)->SetByteArrayRegion(env, outArray, 0, 32, (jbyte*)nonce_res);
- (*env)->SetObjectArrayElement(env, retArray, 0, outArray);
-
- intsByteArray = (*env)->NewByteArray(env, 1);
- (*env)->SetByteArrayRegion(env, intsByteArray, 0, 1, (jbyte*)intsarray);
- (*env)->SetObjectArrayElement(env, retArray, 1, intsByteArray);
-
- (void)classObject;
-
- return retArray;
-}
diff --git a/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_NativeSecp256k1.h b/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_NativeSecp256k1.h
deleted file mode 100644
index fe613c9e9e..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_NativeSecp256k1.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/* DO NOT EDIT THIS FILE - it is machine generated */
-#include
-#include "include/secp256k1.h"
-/* Header for class org_bitcoin_NativeSecp256k1 */
-
-#ifndef _Included_org_bitcoin_NativeSecp256k1
-#define _Included_org_bitcoin_NativeSecp256k1
-#ifdef __cplusplus
-extern "C" {
-#endif
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ctx_clone
- * Signature: (J)J
- */
-SECP256K1_API jlong JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ctx_1clone
- (JNIEnv *, jclass, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_context_randomize
- * Signature: (Ljava/nio/ByteBuffer;J)I
- */
-SECP256K1_API jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1context_1randomize
- (JNIEnv *, jclass, jobject, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_privkey_tweak_add
- * Signature: (Ljava/nio/ByteBuffer;J)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1privkey_1tweak_1add
- (JNIEnv *, jclass, jobject, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_privkey_tweak_mul
- * Signature: (Ljava/nio/ByteBuffer;J)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1privkey_1tweak_1mul
- (JNIEnv *, jclass, jobject, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_pubkey_tweak_add
- * Signature: (Ljava/nio/ByteBuffer;JI)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1pubkey_1tweak_1add
- (JNIEnv *, jclass, jobject, jlong, jint);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_pubkey_tweak_mul
- * Signature: (Ljava/nio/ByteBuffer;JI)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1pubkey_1tweak_1mul
- (JNIEnv *, jclass, jobject, jlong, jint);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_destroy_context
- * Signature: (J)V
- */
-SECP256K1_API void JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1destroy_1context
- (JNIEnv *, jclass, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ecdsa_verify
- * Signature: (Ljava/nio/ByteBuffer;JII)I
- */
-SECP256K1_API jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1verify
- (JNIEnv *, jclass, jobject, jlong, jint, jint);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ecdsa_sign
- * Signature: (Ljava/nio/ByteBuffer;J)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1sign
- (JNIEnv *, jclass, jobject, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ec_seckey_verify
- * Signature: (Ljava/nio/ByteBuffer;J)I
- */
-SECP256K1_API jint JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ec_1seckey_1verify
- (JNIEnv *, jclass, jobject, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ec_pubkey_create
- * Signature: (Ljava/nio/ByteBuffer;J)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ec_1pubkey_1create
- (JNIEnv *, jclass, jobject, jlong);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ec_pubkey_parse
- * Signature: (Ljava/nio/ByteBuffer;JI)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ec_1pubkey_1parse
- (JNIEnv *, jclass, jobject, jlong, jint);
-
-/*
- * Class: org_bitcoin_NativeSecp256k1
- * Method: secp256k1_ecdh
- * Signature: (Ljava/nio/ByteBuffer;JI)[[B
- */
-SECP256K1_API jobjectArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdh
- (JNIEnv* env, jclass classObject, jobject byteBufferObject, jlong ctx_l, jint publen);
-
-
-#ifdef __cplusplus
-}
-#endif
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_Secp256k1Context.c b/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_Secp256k1Context.c
deleted file mode 100644
index a52939e7e7..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_Secp256k1Context.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include
-#include
-#include "org_bitcoin_Secp256k1Context.h"
-#include "include/secp256k1.h"
-
-SECP256K1_API jlong JNICALL Java_org_bitcoin_Secp256k1Context_secp256k1_1init_1context
- (JNIEnv* env, jclass classObject)
-{
- secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
-
- (void)classObject;(void)env;
-
- return (uintptr_t)ctx;
-}
-
diff --git a/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_Secp256k1Context.h b/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_Secp256k1Context.h
deleted file mode 100644
index 0d2bc84b7f..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/java/org_bitcoin_Secp256k1Context.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/* DO NOT EDIT THIS FILE - it is machine generated */
-#include
-#include "include/secp256k1.h"
-/* Header for class org_bitcoin_Secp256k1Context */
-
-#ifndef _Included_org_bitcoin_Secp256k1Context
-#define _Included_org_bitcoin_Secp256k1Context
-#ifdef __cplusplus
-extern "C" {
-#endif
-/*
- * Class: org_bitcoin_Secp256k1Context
- * Method: secp256k1_init_context
- * Signature: ()J
- */
-SECP256K1_API jlong JNICALL Java_org_bitcoin_Secp256k1Context_secp256k1_1init_1context
- (JNIEnv *, jclass);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/modules/dummy.go b/crypto/secp256k1/libsecp256k1/src/modules/dummy.go
deleted file mode 100644
index 99c538db51..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/modules/dummy.go
+++ /dev/null
@@ -1,8 +0,0 @@
-//go:build dummy
-// +build dummy
-
-// Package c contains only a C file.
-//
-// This Go file is part of a workaround for `go mod vendor`.
-// Please see the file crypto/secp256k1/dummy.go for more information.
-package module
diff --git a/crypto/secp256k1/libsecp256k1/src/modules/ecdh/Makefile.am.include b/crypto/secp256k1/libsecp256k1/src/modules/ecdh/Makefile.am.include
deleted file mode 100644
index e3088b4697..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/modules/ecdh/Makefile.am.include
+++ /dev/null
@@ -1,8 +0,0 @@
-include_HEADERS += include/secp256k1_ecdh.h
-noinst_HEADERS += src/modules/ecdh/main_impl.h
-noinst_HEADERS += src/modules/ecdh/tests_impl.h
-if USE_BENCHMARK
-noinst_PROGRAMS += bench_ecdh
-bench_ecdh_SOURCES = src/bench_ecdh.c
-bench_ecdh_LDADD = libsecp256k1.la $(SECP_LIBS) $(COMMON_LIB)
-endif
diff --git a/crypto/secp256k1/libsecp256k1/src/modules/ecdh/dummy.go b/crypto/secp256k1/libsecp256k1/src/modules/ecdh/dummy.go
deleted file mode 100644
index 48c2e0aa54..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/modules/ecdh/dummy.go
+++ /dev/null
@@ -1,8 +0,0 @@
-//go:build dummy
-// +build dummy
-
-// Package c contains only a C file.
-//
-// This Go file is part of a workaround for `go mod vendor`.
-// Please see the file crypto/secp256k1/dummy.go for more information.
-package ecdh
diff --git a/crypto/secp256k1/libsecp256k1/src/modules/ecdh/main_impl.h b/crypto/secp256k1/libsecp256k1/src/modules/ecdh/main_impl.h
deleted file mode 100644
index 9e30fb73dd..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/modules/ecdh/main_impl.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_MODULE_ECDH_MAIN_
-#define _SECP256K1_MODULE_ECDH_MAIN_
-
-#include "include/secp256k1_ecdh.h"
-#include "ecmult_const_impl.h"
-
-int secp256k1_ecdh(const secp256k1_context* ctx, unsigned char *result, const secp256k1_pubkey *point, const unsigned char *scalar) {
- int ret = 0;
- int overflow = 0;
- secp256k1_gej res;
- secp256k1_ge pt;
- secp256k1_scalar s;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(result != NULL);
- ARG_CHECK(point != NULL);
- ARG_CHECK(scalar != NULL);
-
- secp256k1_pubkey_load(ctx, &pt, point);
- secp256k1_scalar_set_b32(&s, scalar, &overflow);
- if (overflow || secp256k1_scalar_is_zero(&s)) {
- ret = 0;
- } else {
- unsigned char x[32];
- unsigned char y[1];
- secp256k1_sha256_t sha;
-
- secp256k1_ecmult_const(&res, &pt, &s);
- secp256k1_ge_set_gej(&pt, &res);
- /* Compute a hash of the point in compressed form
- * Note we cannot use secp256k1_eckey_pubkey_serialize here since it does not
- * expect its output to be secret and has a timing sidechannel. */
- secp256k1_fe_normalize(&pt.x);
- secp256k1_fe_normalize(&pt.y);
- secp256k1_fe_get_b32(x, &pt.x);
- y[0] = 0x02 | secp256k1_fe_is_odd(&pt.y);
-
- secp256k1_sha256_initialize(&sha);
- secp256k1_sha256_write(&sha, y, sizeof(y));
- secp256k1_sha256_write(&sha, x, sizeof(x));
- secp256k1_sha256_finalize(&sha, result);
- ret = 1;
- }
-
- secp256k1_scalar_clear(&s);
- return ret;
-}
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/modules/ecdh/tests_impl.h b/crypto/secp256k1/libsecp256k1/src/modules/ecdh/tests_impl.h
deleted file mode 100644
index 85a5d0a9a6..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/modules/ecdh/tests_impl.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_MODULE_ECDH_TESTS_
-#define _SECP256K1_MODULE_ECDH_TESTS_
-
-void test_ecdh_api(void) {
- /* Setup context that just counts errors */
- secp256k1_context *tctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
- secp256k1_pubkey point;
- unsigned char res[32];
- unsigned char s_one[32] = { 0 };
- int32_t ecount = 0;
- s_one[31] = 1;
-
- secp256k1_context_set_error_callback(tctx, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_illegal_callback(tctx, counting_illegal_callback_fn, &ecount);
- CHECK(secp256k1_ec_pubkey_create(tctx, &point, s_one) == 1);
-
- /* Check all NULLs are detected */
- CHECK(secp256k1_ecdh(tctx, res, &point, s_one) == 1);
- CHECK(ecount == 0);
- CHECK(secp256k1_ecdh(tctx, NULL, &point, s_one) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdh(tctx, res, NULL, s_one) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdh(tctx, res, &point, NULL) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdh(tctx, res, &point, s_one) == 1);
- CHECK(ecount == 3);
-
- /* Cleanup */
- secp256k1_context_destroy(tctx);
-}
-
-void test_ecdh_generator_basepoint(void) {
- unsigned char s_one[32] = { 0 };
- secp256k1_pubkey point[2];
- int i;
-
- s_one[31] = 1;
- /* Check against pubkey creation when the basepoint is the generator */
- for (i = 0; i < 100; ++i) {
- secp256k1_sha256_t sha;
- unsigned char s_b32[32];
- unsigned char output_ecdh[32];
- unsigned char output_ser[32];
- unsigned char point_ser[33];
- size_t point_ser_len = sizeof(point_ser);
- secp256k1_scalar s;
-
- random_scalar_order(&s);
- secp256k1_scalar_get_b32(s_b32, &s);
-
- /* compute using ECDH function */
- CHECK(secp256k1_ec_pubkey_create(ctx, &point[0], s_one) == 1);
- CHECK(secp256k1_ecdh(ctx, output_ecdh, &point[0], s_b32) == 1);
- /* compute "explicitly" */
- CHECK(secp256k1_ec_pubkey_create(ctx, &point[1], s_b32) == 1);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, point_ser, &point_ser_len, &point[1], SECP256K1_EC_COMPRESSED) == 1);
- CHECK(point_ser_len == sizeof(point_ser));
- secp256k1_sha256_initialize(&sha);
- secp256k1_sha256_write(&sha, point_ser, point_ser_len);
- secp256k1_sha256_finalize(&sha, output_ser);
- /* compare */
- CHECK(memcmp(output_ecdh, output_ser, sizeof(output_ser)) == 0);
- }
-}
-
-void test_bad_scalar(void) {
- unsigned char s_zero[32] = { 0 };
- unsigned char s_overflow[32] = {
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41
- };
- unsigned char s_rand[32] = { 0 };
- unsigned char output[32];
- secp256k1_scalar rand;
- secp256k1_pubkey point;
-
- /* Create random point */
- random_scalar_order(&rand);
- secp256k1_scalar_get_b32(s_rand, &rand);
- CHECK(secp256k1_ec_pubkey_create(ctx, &point, s_rand) == 1);
-
- /* Try to multiply it by bad values */
- CHECK(secp256k1_ecdh(ctx, output, &point, s_zero) == 0);
- CHECK(secp256k1_ecdh(ctx, output, &point, s_overflow) == 0);
- /* ...and a good one */
- s_overflow[31] -= 1;
- CHECK(secp256k1_ecdh(ctx, output, &point, s_overflow) == 1);
-}
-
-void run_ecdh_tests(void) {
- test_ecdh_api();
- test_ecdh_generator_basepoint();
- test_bad_scalar();
-}
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/modules/recovery/Makefile.am.include b/crypto/secp256k1/libsecp256k1/src/modules/recovery/Makefile.am.include
deleted file mode 100644
index bf23c26e71..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/modules/recovery/Makefile.am.include
+++ /dev/null
@@ -1,8 +0,0 @@
-include_HEADERS += include/secp256k1_recovery.h
-noinst_HEADERS += src/modules/recovery/main_impl.h
-noinst_HEADERS += src/modules/recovery/tests_impl.h
-if USE_BENCHMARK
-noinst_PROGRAMS += bench_recover
-bench_recover_SOURCES = src/bench_recover.c
-bench_recover_LDADD = libsecp256k1.la $(SECP_LIBS) $(COMMON_LIB)
-endif
diff --git a/crypto/secp256k1/libsecp256k1/src/modules/recovery/dummy.go b/crypto/secp256k1/libsecp256k1/src/modules/recovery/dummy.go
deleted file mode 100644
index 8efbd7abe7..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/modules/recovery/dummy.go
+++ /dev/null
@@ -1,8 +0,0 @@
-//go:build dummy
-// +build dummy
-
-// Package c contains only a C file.
-//
-// This Go file is part of a workaround for `go mod vendor`.
-// Please see the file crypto/secp256k1/dummy.go for more information.
-package recovery
diff --git a/crypto/secp256k1/libsecp256k1/src/modules/recovery/main_impl.h b/crypto/secp256k1/libsecp256k1/src/modules/recovery/main_impl.h
deleted file mode 100755
index c6fbe23981..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/modules/recovery/main_impl.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013-2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_MODULE_RECOVERY_MAIN_
-#define _SECP256K1_MODULE_RECOVERY_MAIN_
-
-#include "include/secp256k1_recovery.h"
-
-static void secp256k1_ecdsa_recoverable_signature_load(const secp256k1_context* ctx, secp256k1_scalar* r, secp256k1_scalar* s, int* recid, const secp256k1_ecdsa_recoverable_signature* sig) {
- (void)ctx;
- if (sizeof(secp256k1_scalar) == 32) {
- /* When the secp256k1_scalar type is exactly 32 byte, use its
- * representation inside secp256k1_ecdsa_signature, as conversion is very fast.
- * Note that secp256k1_ecdsa_signature_save must use the same representation. */
- memcpy(r, &sig->data[0], 32);
- memcpy(s, &sig->data[32], 32);
- } else {
- secp256k1_scalar_set_b32(r, &sig->data[0], NULL);
- secp256k1_scalar_set_b32(s, &sig->data[32], NULL);
- }
- *recid = sig->data[64];
-}
-
-static void secp256k1_ecdsa_recoverable_signature_save(secp256k1_ecdsa_recoverable_signature* sig, const secp256k1_scalar* r, const secp256k1_scalar* s, int recid) {
- if (sizeof(secp256k1_scalar) == 32) {
- memcpy(&sig->data[0], r, 32);
- memcpy(&sig->data[32], s, 32);
- } else {
- secp256k1_scalar_get_b32(&sig->data[0], r);
- secp256k1_scalar_get_b32(&sig->data[32], s);
- }
- sig->data[64] = recid;
-}
-
-int secp256k1_ecdsa_recoverable_signature_parse_compact(const secp256k1_context* ctx, secp256k1_ecdsa_recoverable_signature* sig, const unsigned char *input64, int recid) {
- secp256k1_scalar r, s;
- int ret = 1;
- int overflow = 0;
-
- (void)ctx;
- ARG_CHECK(sig != NULL);
- ARG_CHECK(input64 != NULL);
- ARG_CHECK(recid >= 0 && recid <= 3);
-
- secp256k1_scalar_set_b32(&r, &input64[0], &overflow);
- ret &= !overflow;
- secp256k1_scalar_set_b32(&s, &input64[32], &overflow);
- ret &= !overflow;
- if (ret) {
- secp256k1_ecdsa_recoverable_signature_save(sig, &r, &s, recid);
- } else {
- memset(sig, 0, sizeof(*sig));
- }
- return ret;
-}
-
-int secp256k1_ecdsa_recoverable_signature_serialize_compact(const secp256k1_context* ctx, unsigned char *output64, int *recid, const secp256k1_ecdsa_recoverable_signature* sig) {
- secp256k1_scalar r, s;
-
- (void)ctx;
- ARG_CHECK(output64 != NULL);
- ARG_CHECK(sig != NULL);
- ARG_CHECK(recid != NULL);
-
- secp256k1_ecdsa_recoverable_signature_load(ctx, &r, &s, recid, sig);
- secp256k1_scalar_get_b32(&output64[0], &r);
- secp256k1_scalar_get_b32(&output64[32], &s);
- return 1;
-}
-
-int secp256k1_ecdsa_recoverable_signature_convert(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const secp256k1_ecdsa_recoverable_signature* sigin) {
- secp256k1_scalar r, s;
- int recid;
-
- (void)ctx;
- ARG_CHECK(sig != NULL);
- ARG_CHECK(sigin != NULL);
-
- secp256k1_ecdsa_recoverable_signature_load(ctx, &r, &s, &recid, sigin);
- secp256k1_ecdsa_signature_save(sig, &r, &s);
- return 1;
-}
-
-static int secp256k1_ecdsa_sig_recover(const secp256k1_ecmult_context *ctx, const secp256k1_scalar *sigr, const secp256k1_scalar* sigs, secp256k1_ge *pubkey, const secp256k1_scalar *message, int recid) {
- unsigned char brx[32];
- secp256k1_fe fx;
- secp256k1_ge x;
- secp256k1_gej xj;
- secp256k1_scalar rn, u1, u2;
- secp256k1_gej qj;
- int r;
-
- if (secp256k1_scalar_is_zero(sigr) || secp256k1_scalar_is_zero(sigs)) {
- return 0;
- }
-
- secp256k1_scalar_get_b32(brx, sigr);
- r = secp256k1_fe_set_b32(&fx, brx);
- (void)r;
- VERIFY_CHECK(r); /* brx comes from a scalar, so is less than the order; certainly less than p */
- if (recid & 2) {
- if (secp256k1_fe_cmp_var(&fx, &secp256k1_ecdsa_const_p_minus_order) >= 0) {
- return 0;
- }
- secp256k1_fe_add(&fx, &secp256k1_ecdsa_const_order_as_fe);
- }
- if (!secp256k1_ge_set_xo_var(&x, &fx, recid & 1)) {
- return 0;
- }
- secp256k1_gej_set_ge(&xj, &x);
- secp256k1_scalar_inverse_var(&rn, sigr);
- secp256k1_scalar_mul(&u1, &rn, message);
- secp256k1_scalar_negate(&u1, &u1);
- secp256k1_scalar_mul(&u2, &rn, sigs);
- secp256k1_ecmult(ctx, &qj, &xj, &u2, &u1);
- secp256k1_ge_set_gej_var(pubkey, &qj);
- return !secp256k1_gej_is_infinity(&qj);
-}
-
-int secp256k1_ecdsa_sign_recoverable(const secp256k1_context* ctx, secp256k1_ecdsa_recoverable_signature *signature, const unsigned char *msg32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void* noncedata) {
- secp256k1_scalar r, s;
- secp256k1_scalar sec, non, msg;
- int recid;
- int ret = 0;
- int overflow = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
- ARG_CHECK(msg32 != NULL);
- ARG_CHECK(signature != NULL);
- ARG_CHECK(seckey != NULL);
- if (noncefp == NULL) {
- noncefp = secp256k1_nonce_function_default;
- }
-
- secp256k1_scalar_set_b32(&sec, seckey, &overflow);
- /* Fail if the secret key is invalid. */
- if (!overflow && !secp256k1_scalar_is_zero(&sec)) {
- unsigned char nonce32[32];
- unsigned int count = 0;
- secp256k1_scalar_set_b32(&msg, msg32, NULL);
- while (1) {
- ret = noncefp(nonce32, msg32, seckey, NULL, (void*)noncedata, count);
- if (!ret) {
- break;
- }
- secp256k1_scalar_set_b32(&non, nonce32, &overflow);
- if (!secp256k1_scalar_is_zero(&non) && !overflow) {
- if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &r, &s, &sec, &msg, &non, &recid)) {
- break;
- }
- }
- count++;
- }
- memset(nonce32, 0, 32);
- secp256k1_scalar_clear(&msg);
- secp256k1_scalar_clear(&non);
- secp256k1_scalar_clear(&sec);
- }
- if (ret) {
- secp256k1_ecdsa_recoverable_signature_save(signature, &r, &s, recid);
- } else {
- memset(signature, 0, sizeof(*signature));
- }
- return ret;
-}
-
-int secp256k1_ecdsa_recover(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const secp256k1_ecdsa_recoverable_signature *signature, const unsigned char *msg32) {
- secp256k1_ge q;
- secp256k1_scalar r, s;
- secp256k1_scalar m;
- int recid;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
- ARG_CHECK(msg32 != NULL);
- ARG_CHECK(signature != NULL);
- ARG_CHECK(pubkey != NULL);
-
- secp256k1_ecdsa_recoverable_signature_load(ctx, &r, &s, &recid, signature);
- VERIFY_CHECK(recid >= 0 && recid < 4); /* should have been caught in parse_compact */
- secp256k1_scalar_set_b32(&m, msg32, NULL);
- if (secp256k1_ecdsa_sig_recover(&ctx->ecmult_ctx, &r, &s, &q, &m, recid)) {
- secp256k1_pubkey_save(pubkey, &q);
- return 1;
- } else {
- memset(pubkey, 0, sizeof(*pubkey));
- return 0;
- }
-}
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/modules/recovery/tests_impl.h b/crypto/secp256k1/libsecp256k1/src/modules/recovery/tests_impl.h
deleted file mode 100644
index 765c7dd81e..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/modules/recovery/tests_impl.h
+++ /dev/null
@@ -1,393 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013-2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_MODULE_RECOVERY_TESTS_
-#define _SECP256K1_MODULE_RECOVERY_TESTS_
-
-static int recovery_test_nonce_function(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
- (void) msg32;
- (void) key32;
- (void) algo16;
- (void) data;
-
- /* On the first run, return 0 to force a second run */
- if (counter == 0) {
- memset(nonce32, 0, 32);
- return 1;
- }
- /* On the second run, return an overflow to force a third run */
- if (counter == 1) {
- memset(nonce32, 0xff, 32);
- return 1;
- }
- /* On the next run, return a valid nonce, but flip a coin as to whether or not to fail signing. */
- memset(nonce32, 1, 32);
- return secp256k1_rand_bits(1);
-}
-
-void test_ecdsa_recovery_api(void) {
- /* Setup contexts that just count errors */
- secp256k1_context *none = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
- secp256k1_context *sign = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
- secp256k1_context *vrfy = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);
- secp256k1_context *both = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
- secp256k1_pubkey pubkey;
- secp256k1_pubkey recpubkey;
- secp256k1_ecdsa_signature normal_sig;
- secp256k1_ecdsa_recoverable_signature recsig;
- unsigned char privkey[32] = { 1 };
- unsigned char message[32] = { 2 };
- int32_t ecount = 0;
- int recid = 0;
- unsigned char sig[74];
- unsigned char zero_privkey[32] = { 0 };
- unsigned char over_privkey[32] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
-
- secp256k1_context_set_error_callback(none, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_error_callback(sign, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_error_callback(vrfy, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_error_callback(both, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_illegal_callback(none, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_illegal_callback(sign, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_illegal_callback(vrfy, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_illegal_callback(both, counting_illegal_callback_fn, &ecount);
-
- /* Construct and verify corresponding public key. */
- CHECK(secp256k1_ec_seckey_verify(ctx, privkey) == 1);
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, privkey) == 1);
-
- /* Check bad contexts and NULLs for signing */
- ecount = 0;
- CHECK(secp256k1_ecdsa_sign_recoverable(none, &recsig, message, privkey, NULL, NULL) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_sign_recoverable(sign, &recsig, message, privkey, NULL, NULL) == 1);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_sign_recoverable(vrfy, &recsig, message, privkey, NULL, NULL) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, message, privkey, NULL, NULL) == 1);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_sign_recoverable(both, NULL, message, privkey, NULL, NULL) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, NULL, privkey, NULL, NULL) == 0);
- CHECK(ecount == 4);
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, message, NULL, NULL, NULL) == 0);
- CHECK(ecount == 5);
- /* This will fail or succeed randomly, and in either case will not ARG_CHECK failure */
- secp256k1_ecdsa_sign_recoverable(both, &recsig, message, privkey, recovery_test_nonce_function, NULL);
- CHECK(ecount == 5);
- /* These will all fail, but not in ARG_CHECK way */
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, message, zero_privkey, NULL, NULL) == 0);
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, message, over_privkey, NULL, NULL) == 0);
- /* This one will succeed. */
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, message, privkey, NULL, NULL) == 1);
- CHECK(ecount == 5);
-
- /* Check signing with a goofy nonce function */
-
- /* Check bad contexts and NULLs for recovery */
- ecount = 0;
- CHECK(secp256k1_ecdsa_recover(none, &recpubkey, &recsig, message) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_recover(sign, &recpubkey, &recsig, message) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_recover(vrfy, &recpubkey, &recsig, message) == 1);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_recover(both, &recpubkey, &recsig, message) == 1);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_recover(both, NULL, &recsig, message) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdsa_recover(both, &recpubkey, NULL, message) == 0);
- CHECK(ecount == 4);
- CHECK(secp256k1_ecdsa_recover(both, &recpubkey, &recsig, NULL) == 0);
- CHECK(ecount == 5);
-
- /* Check NULLs for conversion */
- CHECK(secp256k1_ecdsa_sign(both, &normal_sig, message, privkey, NULL, NULL) == 1);
- ecount = 0;
- CHECK(secp256k1_ecdsa_recoverable_signature_convert(both, NULL, &recsig) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_recoverable_signature_convert(both, &normal_sig, NULL) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_recoverable_signature_convert(both, &normal_sig, &recsig) == 1);
-
- /* Check NULLs for de/serialization */
- CHECK(secp256k1_ecdsa_sign_recoverable(both, &recsig, message, privkey, NULL, NULL) == 1);
- ecount = 0;
- CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(both, NULL, &recid, &recsig) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(both, sig, NULL, &recsig) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(both, sig, &recid, NULL) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(both, sig, &recid, &recsig) == 1);
-
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(both, NULL, sig, recid) == 0);
- CHECK(ecount == 4);
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(both, &recsig, NULL, recid) == 0);
- CHECK(ecount == 5);
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(both, &recsig, sig, -1) == 0);
- CHECK(ecount == 6);
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(both, &recsig, sig, 5) == 0);
- CHECK(ecount == 7);
- /* overflow in signature will fail but not affect ecount */
- memcpy(sig, over_privkey, 32);
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(both, &recsig, sig, recid) == 0);
- CHECK(ecount == 7);
-
- /* cleanup */
- secp256k1_context_destroy(none);
- secp256k1_context_destroy(sign);
- secp256k1_context_destroy(vrfy);
- secp256k1_context_destroy(both);
-}
-
-void test_ecdsa_recovery_end_to_end(void) {
- unsigned char extra[32] = {0x00};
- unsigned char privkey[32];
- unsigned char message[32];
- secp256k1_ecdsa_signature signature[5];
- secp256k1_ecdsa_recoverable_signature rsignature[5];
- unsigned char sig[74];
- secp256k1_pubkey pubkey;
- secp256k1_pubkey recpubkey;
- int recid = 0;
-
- /* Generate a random key and message. */
- {
- secp256k1_scalar msg, key;
- random_scalar_order_test(&msg);
- random_scalar_order_test(&key);
- secp256k1_scalar_get_b32(privkey, &key);
- secp256k1_scalar_get_b32(message, &msg);
- }
-
- /* Construct and verify corresponding public key. */
- CHECK(secp256k1_ec_seckey_verify(ctx, privkey) == 1);
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, privkey) == 1);
-
- /* Serialize/parse compact and verify/recover. */
- extra[0] = 0;
- CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[0], message, privkey, NULL, NULL) == 1);
- CHECK(secp256k1_ecdsa_sign(ctx, &signature[0], message, privkey, NULL, NULL) == 1);
- CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[4], message, privkey, NULL, NULL) == 1);
- CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[1], message, privkey, NULL, extra) == 1);
- extra[31] = 1;
- CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[2], message, privkey, NULL, extra) == 1);
- extra[31] = 0;
- extra[0] = 1;
- CHECK(secp256k1_ecdsa_sign_recoverable(ctx, &rsignature[3], message, privkey, NULL, extra) == 1);
- CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(ctx, sig, &recid, &rsignature[4]) == 1);
- CHECK(secp256k1_ecdsa_recoverable_signature_convert(ctx, &signature[4], &rsignature[4]) == 1);
- CHECK(memcmp(&signature[4], &signature[0], 64) == 0);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[4], message, &pubkey) == 1);
- memset(&rsignature[4], 0, sizeof(rsignature[4]));
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsignature[4], sig, recid) == 1);
- CHECK(secp256k1_ecdsa_recoverable_signature_convert(ctx, &signature[4], &rsignature[4]) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[4], message, &pubkey) == 1);
- /* Parse compact (with recovery id) and recover. */
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsignature[4], sig, recid) == 1);
- CHECK(secp256k1_ecdsa_recover(ctx, &recpubkey, &rsignature[4], message) == 1);
- CHECK(memcmp(&pubkey, &recpubkey, sizeof(pubkey)) == 0);
- /* Serialize/destroy/parse signature and verify again. */
- CHECK(secp256k1_ecdsa_recoverable_signature_serialize_compact(ctx, sig, &recid, &rsignature[4]) == 1);
- sig[secp256k1_rand_bits(6)] += 1 + secp256k1_rand_int(255);
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsignature[4], sig, recid) == 1);
- CHECK(secp256k1_ecdsa_recoverable_signature_convert(ctx, &signature[4], &rsignature[4]) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[4], message, &pubkey) == 0);
- /* Recover again */
- CHECK(secp256k1_ecdsa_recover(ctx, &recpubkey, &rsignature[4], message) == 0 ||
- memcmp(&pubkey, &recpubkey, sizeof(pubkey)) != 0);
-}
-
-/* Tests several edge cases. */
-void test_ecdsa_recovery_edge_cases(void) {
- const unsigned char msg32[32] = {
- 'T', 'h', 'i', 's', ' ', 'i', 's', ' ',
- 'a', ' ', 'v', 'e', 'r', 'y', ' ', 's',
- 'e', 'c', 'r', 'e', 't', ' ', 'm', 'e',
- 's', 's', 'a', 'g', 'e', '.', '.', '.'
- };
- const unsigned char sig64[64] = {
- /* Generated by signing the above message with nonce 'This is the nonce we will use...'
- * and secret key 0 (which is not valid), resulting in recid 0. */
- 0x67, 0xCB, 0x28, 0x5F, 0x9C, 0xD1, 0x94, 0xE8,
- 0x40, 0xD6, 0x29, 0x39, 0x7A, 0xF5, 0x56, 0x96,
- 0x62, 0xFD, 0xE4, 0x46, 0x49, 0x99, 0x59, 0x63,
- 0x17, 0x9A, 0x7D, 0xD1, 0x7B, 0xD2, 0x35, 0x32,
- 0x4B, 0x1B, 0x7D, 0xF3, 0x4C, 0xE1, 0xF6, 0x8E,
- 0x69, 0x4F, 0xF6, 0xF1, 0x1A, 0xC7, 0x51, 0xDD,
- 0x7D, 0xD7, 0x3E, 0x38, 0x7E, 0xE4, 0xFC, 0x86,
- 0x6E, 0x1B, 0xE8, 0xEC, 0xC7, 0xDD, 0x95, 0x57
- };
- secp256k1_pubkey pubkey;
- /* signature (r,s) = (4,4), which can be recovered with all 4 recids. */
- const unsigned char sigb64[64] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
- };
- secp256k1_pubkey pubkeyb;
- secp256k1_ecdsa_recoverable_signature rsig;
- secp256k1_ecdsa_signature sig;
- int recid;
-
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sig64, 0));
- CHECK(!secp256k1_ecdsa_recover(ctx, &pubkey, &rsig, msg32));
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sig64, 1));
- CHECK(secp256k1_ecdsa_recover(ctx, &pubkey, &rsig, msg32));
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sig64, 2));
- CHECK(!secp256k1_ecdsa_recover(ctx, &pubkey, &rsig, msg32));
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sig64, 3));
- CHECK(!secp256k1_ecdsa_recover(ctx, &pubkey, &rsig, msg32));
-
- for (recid = 0; recid < 4; recid++) {
- int i;
- int recid2;
- /* (4,4) encoded in DER. */
- unsigned char sigbder[8] = {0x30, 0x06, 0x02, 0x01, 0x04, 0x02, 0x01, 0x04};
- unsigned char sigcder_zr[7] = {0x30, 0x05, 0x02, 0x00, 0x02, 0x01, 0x01};
- unsigned char sigcder_zs[7] = {0x30, 0x05, 0x02, 0x01, 0x01, 0x02, 0x00};
- unsigned char sigbderalt1[39] = {
- 0x30, 0x25, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x04, 0x02, 0x01, 0x04,
- };
- unsigned char sigbderalt2[39] = {
- 0x30, 0x25, 0x02, 0x01, 0x04, 0x02, 0x20, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
- };
- unsigned char sigbderalt3[40] = {
- 0x30, 0x26, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x01, 0x04,
- };
- unsigned char sigbderalt4[40] = {
- 0x30, 0x26, 0x02, 0x01, 0x04, 0x02, 0x21, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
- };
- /* (order + r,4) encoded in DER. */
- unsigned char sigbderlong[40] = {
- 0x30, 0x26, 0x02, 0x21, 0x00, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xBA, 0xAE, 0xDC,
- 0xE6, 0xAF, 0x48, 0xA0, 0x3B, 0xBF, 0xD2, 0x5E,
- 0x8C, 0xD0, 0x36, 0x41, 0x45, 0x02, 0x01, 0x04
- };
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigb64, recid) == 1);
- CHECK(secp256k1_ecdsa_recover(ctx, &pubkeyb, &rsig, msg32) == 1);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, sizeof(sigbder)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 1);
- for (recid2 = 0; recid2 < 4; recid2++) {
- secp256k1_pubkey pubkey2b;
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigb64, recid2) == 1);
- CHECK(secp256k1_ecdsa_recover(ctx, &pubkey2b, &rsig, msg32) == 1);
- /* Verifying with (order + r,4) should always fail. */
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderlong, sizeof(sigbderlong)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
- }
- /* DER parsing tests. */
- /* Zero length r/s. */
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder_zr, sizeof(sigcder_zr)) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder_zs, sizeof(sigcder_zs)) == 0);
- /* Leading zeros. */
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt1, sizeof(sigbderalt1)) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt2, sizeof(sigbderalt2)) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt3, sizeof(sigbderalt3)) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt4, sizeof(sigbderalt4)) == 0);
- sigbderalt3[4] = 1;
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt3, sizeof(sigbderalt3)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
- sigbderalt4[7] = 1;
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbderalt4, sizeof(sigbderalt4)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
- /* Damage signature. */
- sigbder[7]++;
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, sizeof(sigbder)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
- sigbder[7]--;
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, 6) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, sizeof(sigbder) - 1) == 0);
- for(i = 0; i < 8; i++) {
- int c;
- unsigned char orig = sigbder[i];
- /*Try every single-byte change.*/
- for (c = 0; c < 256; c++) {
- if (c == orig ) {
- continue;
- }
- sigbder[i] = c;
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigbder, sizeof(sigbder)) == 0 || secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyb) == 0);
- }
- sigbder[i] = orig;
- }
- }
-
- /* Test r/s equal to zero */
- {
- /* (1,1) encoded in DER. */
- unsigned char sigcder[8] = {0x30, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01};
- unsigned char sigc64[64] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- };
- secp256k1_pubkey pubkeyc;
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigc64, 0) == 1);
- CHECK(secp256k1_ecdsa_recover(ctx, &pubkeyc, &rsig, msg32) == 1);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder, sizeof(sigcder)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyc) == 1);
- sigcder[4] = 0;
- sigc64[31] = 0;
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigc64, 0) == 1);
- CHECK(secp256k1_ecdsa_recover(ctx, &pubkeyb, &rsig, msg32) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder, sizeof(sigcder)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyc) == 0);
- sigcder[4] = 1;
- sigcder[7] = 0;
- sigc64[31] = 1;
- sigc64[63] = 0;
- CHECK(secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &rsig, sigc64, 0) == 1);
- CHECK(secp256k1_ecdsa_recover(ctx, &pubkeyb, &rsig, msg32) == 0);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, sigcder, sizeof(sigcder)) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg32, &pubkeyc) == 0);
- }
-}
-
-void run_recovery_tests(void) {
- int i;
- for (i = 0; i < count; i++) {
- test_ecdsa_recovery_api();
- }
- for (i = 0; i < 64*count; i++) {
- test_ecdsa_recovery_end_to_end();
- }
- test_ecdsa_recovery_edge_cases();
-}
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/num.h b/crypto/secp256k1/libsecp256k1/src/num.h
deleted file mode 100644
index eff842200f..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/num.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_NUM_
-#define _SECP256K1_NUM_
-
-#ifndef USE_NUM_NONE
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#if defined(USE_NUM_GMP)
-#include "num_gmp.h"
-#else
-#error "Please select num implementation"
-#endif
-
-/** Copy a number. */
-static void secp256k1_num_copy(secp256k1_num *r, const secp256k1_num *a);
-
-/** Convert a number's absolute value to a binary big-endian string.
- * There must be enough place. */
-static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const secp256k1_num *a);
-
-/** Set a number to the value of a binary big-endian string. */
-static void secp256k1_num_set_bin(secp256k1_num *r, const unsigned char *a, unsigned int alen);
-
-/** Compute a modular inverse. The input must be less than the modulus. */
-static void secp256k1_num_mod_inverse(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *m);
-
-/** Compute the jacobi symbol (a|b). b must be positive and odd. */
-static int secp256k1_num_jacobi(const secp256k1_num *a, const secp256k1_num *b);
-
-/** Compare the absolute value of two numbers. */
-static int secp256k1_num_cmp(const secp256k1_num *a, const secp256k1_num *b);
-
-/** Test whether two number are equal (including sign). */
-static int secp256k1_num_eq(const secp256k1_num *a, const secp256k1_num *b);
-
-/** Add two (signed) numbers. */
-static void secp256k1_num_add(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b);
-
-/** Subtract two (signed) numbers. */
-static void secp256k1_num_sub(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b);
-
-/** Multiply two (signed) numbers. */
-static void secp256k1_num_mul(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b);
-
-/** Replace a number by its remainder modulo m. M's sign is ignored. The result is a number between 0 and m-1,
- even if r was negative. */
-static void secp256k1_num_mod(secp256k1_num *r, const secp256k1_num *m);
-
-/** Right-shift the passed number by bits. */
-static void secp256k1_num_shift(secp256k1_num *r, int bits);
-
-/** Check whether a number is zero. */
-static int secp256k1_num_is_zero(const secp256k1_num *a);
-
-/** Check whether a number is one. */
-static int secp256k1_num_is_one(const secp256k1_num *a);
-
-/** Check whether a number is strictly negative. */
-static int secp256k1_num_is_neg(const secp256k1_num *a);
-
-/** Change a number's sign. */
-static void secp256k1_num_negate(secp256k1_num *r);
-
-#endif
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/num_gmp.h b/crypto/secp256k1/libsecp256k1/src/num_gmp.h
deleted file mode 100644
index 7dd813088a..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/num_gmp.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_NUM_REPR_
-#define _SECP256K1_NUM_REPR_
-
-#include
-
-#define NUM_LIMBS ((256+GMP_NUMB_BITS-1)/GMP_NUMB_BITS)
-
-typedef struct {
- mp_limb_t data[2*NUM_LIMBS];
- int neg;
- int limbs;
-} secp256k1_num;
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/num_gmp_impl.h b/crypto/secp256k1/libsecp256k1/src/num_gmp_impl.h
deleted file mode 100644
index 3a46495eea..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/num_gmp_impl.h
+++ /dev/null
@@ -1,288 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_NUM_REPR_IMPL_H_
-#define _SECP256K1_NUM_REPR_IMPL_H_
-
-#include
-#include
-#include
-
-#include "util.h"
-#include "num.h"
-
-#ifdef VERIFY
-static void secp256k1_num_sanity(const secp256k1_num *a) {
- VERIFY_CHECK(a->limbs == 1 || (a->limbs > 1 && a->data[a->limbs-1] != 0));
-}
-#else
-#define secp256k1_num_sanity(a) do { } while(0)
-#endif
-
-static void secp256k1_num_copy(secp256k1_num *r, const secp256k1_num *a) {
- *r = *a;
-}
-
-static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, const secp256k1_num *a) {
- unsigned char tmp[65];
- int len = 0;
- int shift = 0;
- if (a->limbs>1 || a->data[0] != 0) {
- len = mpn_get_str(tmp, 256, (mp_limb_t*)a->data, a->limbs);
- }
- while (shift < len && tmp[shift] == 0) shift++;
- VERIFY_CHECK(len-shift <= (int)rlen);
- memset(r, 0, rlen - len + shift);
- if (len > shift) {
- memcpy(r + rlen - len + shift, tmp + shift, len - shift);
- }
- memset(tmp, 0, sizeof(tmp));
-}
-
-static void secp256k1_num_set_bin(secp256k1_num *r, const unsigned char *a, unsigned int alen) {
- int len;
- VERIFY_CHECK(alen > 0);
- VERIFY_CHECK(alen <= 64);
- len = mpn_set_str(r->data, a, alen, 256);
- if (len == 0) {
- r->data[0] = 0;
- len = 1;
- }
- VERIFY_CHECK(len <= NUM_LIMBS*2);
- r->limbs = len;
- r->neg = 0;
- while (r->limbs > 1 && r->data[r->limbs-1]==0) {
- r->limbs--;
- }
-}
-
-static void secp256k1_num_add_abs(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
- mp_limb_t c = mpn_add(r->data, a->data, a->limbs, b->data, b->limbs);
- r->limbs = a->limbs;
- if (c != 0) {
- VERIFY_CHECK(r->limbs < 2*NUM_LIMBS);
- r->data[r->limbs++] = c;
- }
-}
-
-static void secp256k1_num_sub_abs(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
- mp_limb_t c = mpn_sub(r->data, a->data, a->limbs, b->data, b->limbs);
- (void)c;
- VERIFY_CHECK(c == 0);
- r->limbs = a->limbs;
- while (r->limbs > 1 && r->data[r->limbs-1]==0) {
- r->limbs--;
- }
-}
-
-static void secp256k1_num_mod(secp256k1_num *r, const secp256k1_num *m) {
- secp256k1_num_sanity(r);
- secp256k1_num_sanity(m);
-
- if (r->limbs >= m->limbs) {
- mp_limb_t t[2*NUM_LIMBS];
- mpn_tdiv_qr(t, r->data, 0, r->data, r->limbs, m->data, m->limbs);
- memset(t, 0, sizeof(t));
- r->limbs = m->limbs;
- while (r->limbs > 1 && r->data[r->limbs-1]==0) {
- r->limbs--;
- }
- }
-
- if (r->neg && (r->limbs > 1 || r->data[0] != 0)) {
- secp256k1_num_sub_abs(r, m, r);
- r->neg = 0;
- }
-}
-
-static void secp256k1_num_mod_inverse(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *m) {
- int i;
- mp_limb_t g[NUM_LIMBS+1];
- mp_limb_t u[NUM_LIMBS+1];
- mp_limb_t v[NUM_LIMBS+1];
- mp_size_t sn;
- mp_size_t gn;
- secp256k1_num_sanity(a);
- secp256k1_num_sanity(m);
-
- /** mpn_gcdext computes: (G,S) = gcdext(U,V), where
- * * G = gcd(U,V)
- * * G = U*S + V*T
- * * U has equal or more limbs than V, and V has no padding
- * If we set U to be (a padded version of) a, and V = m:
- * G = a*S + m*T
- * G = a*S mod m
- * Assuming G=1:
- * S = 1/a mod m
- */
- VERIFY_CHECK(m->limbs <= NUM_LIMBS);
- VERIFY_CHECK(m->data[m->limbs-1] != 0);
- for (i = 0; i < m->limbs; i++) {
- u[i] = (i < a->limbs) ? a->data[i] : 0;
- v[i] = m->data[i];
- }
- sn = NUM_LIMBS+1;
- gn = mpn_gcdext(g, r->data, &sn, u, m->limbs, v, m->limbs);
- (void)gn;
- VERIFY_CHECK(gn == 1);
- VERIFY_CHECK(g[0] == 1);
- r->neg = a->neg ^ m->neg;
- if (sn < 0) {
- mpn_sub(r->data, m->data, m->limbs, r->data, -sn);
- r->limbs = m->limbs;
- while (r->limbs > 1 && r->data[r->limbs-1]==0) {
- r->limbs--;
- }
- } else {
- r->limbs = sn;
- }
- memset(g, 0, sizeof(g));
- memset(u, 0, sizeof(u));
- memset(v, 0, sizeof(v));
-}
-
-static int secp256k1_num_jacobi(const secp256k1_num *a, const secp256k1_num *b) {
- int ret;
- mpz_t ga, gb;
- secp256k1_num_sanity(a);
- secp256k1_num_sanity(b);
- VERIFY_CHECK(!b->neg && (b->limbs > 0) && (b->data[0] & 1));
-
- mpz_inits(ga, gb, NULL);
-
- mpz_import(gb, b->limbs, -1, sizeof(mp_limb_t), 0, 0, b->data);
- mpz_import(ga, a->limbs, -1, sizeof(mp_limb_t), 0, 0, a->data);
- if (a->neg) {
- mpz_neg(ga, ga);
- }
-
- ret = mpz_jacobi(ga, gb);
-
- mpz_clears(ga, gb, NULL);
-
- return ret;
-}
-
-static int secp256k1_num_is_one(const secp256k1_num *a) {
- return (a->limbs == 1 && a->data[0] == 1);
-}
-
-static int secp256k1_num_is_zero(const secp256k1_num *a) {
- return (a->limbs == 1 && a->data[0] == 0);
-}
-
-static int secp256k1_num_is_neg(const secp256k1_num *a) {
- return (a->limbs > 1 || a->data[0] != 0) && a->neg;
-}
-
-static int secp256k1_num_cmp(const secp256k1_num *a, const secp256k1_num *b) {
- if (a->limbs > b->limbs) {
- return 1;
- }
- if (a->limbs < b->limbs) {
- return -1;
- }
- return mpn_cmp(a->data, b->data, a->limbs);
-}
-
-static int secp256k1_num_eq(const secp256k1_num *a, const secp256k1_num *b) {
- if (a->limbs > b->limbs) {
- return 0;
- }
- if (a->limbs < b->limbs) {
- return 0;
- }
- if ((a->neg && !secp256k1_num_is_zero(a)) != (b->neg && !secp256k1_num_is_zero(b))) {
- return 0;
- }
- return mpn_cmp(a->data, b->data, a->limbs) == 0;
-}
-
-static void secp256k1_num_subadd(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b, int bneg) {
- if (!(b->neg ^ bneg ^ a->neg)) { /* a and b have the same sign */
- r->neg = a->neg;
- if (a->limbs >= b->limbs) {
- secp256k1_num_add_abs(r, a, b);
- } else {
- secp256k1_num_add_abs(r, b, a);
- }
- } else {
- if (secp256k1_num_cmp(a, b) > 0) {
- r->neg = a->neg;
- secp256k1_num_sub_abs(r, a, b);
- } else {
- r->neg = b->neg ^ bneg;
- secp256k1_num_sub_abs(r, b, a);
- }
- }
-}
-
-static void secp256k1_num_add(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
- secp256k1_num_sanity(a);
- secp256k1_num_sanity(b);
- secp256k1_num_subadd(r, a, b, 0);
-}
-
-static void secp256k1_num_sub(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
- secp256k1_num_sanity(a);
- secp256k1_num_sanity(b);
- secp256k1_num_subadd(r, a, b, 1);
-}
-
-static void secp256k1_num_mul(secp256k1_num *r, const secp256k1_num *a, const secp256k1_num *b) {
- mp_limb_t tmp[2*NUM_LIMBS+1];
- secp256k1_num_sanity(a);
- secp256k1_num_sanity(b);
-
- VERIFY_CHECK(a->limbs + b->limbs <= 2*NUM_LIMBS+1);
- if ((a->limbs==1 && a->data[0]==0) || (b->limbs==1 && b->data[0]==0)) {
- r->limbs = 1;
- r->neg = 0;
- r->data[0] = 0;
- return;
- }
- if (a->limbs >= b->limbs) {
- mpn_mul(tmp, a->data, a->limbs, b->data, b->limbs);
- } else {
- mpn_mul(tmp, b->data, b->limbs, a->data, a->limbs);
- }
- r->limbs = a->limbs + b->limbs;
- if (r->limbs > 1 && tmp[r->limbs - 1]==0) {
- r->limbs--;
- }
- VERIFY_CHECK(r->limbs <= 2*NUM_LIMBS);
- mpn_copyi(r->data, tmp, r->limbs);
- r->neg = a->neg ^ b->neg;
- memset(tmp, 0, sizeof(tmp));
-}
-
-static void secp256k1_num_shift(secp256k1_num *r, int bits) {
- if (bits % GMP_NUMB_BITS) {
- /* Shift within limbs. */
- mpn_rshift(r->data, r->data, r->limbs, bits % GMP_NUMB_BITS);
- }
- if (bits >= GMP_NUMB_BITS) {
- int i;
- /* Shift full limbs. */
- for (i = 0; i < r->limbs; i++) {
- int index = i + (bits / GMP_NUMB_BITS);
- if (index < r->limbs && index < 2*NUM_LIMBS) {
- r->data[i] = r->data[index];
- } else {
- r->data[i] = 0;
- }
- }
- }
- while (r->limbs>1 && r->data[r->limbs-1]==0) {
- r->limbs--;
- }
-}
-
-static void secp256k1_num_negate(secp256k1_num *r) {
- r->neg ^= 1;
-}
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/num_impl.h b/crypto/secp256k1/libsecp256k1/src/num_impl.h
deleted file mode 100644
index 0b0e3a072a..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/num_impl.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_NUM_IMPL_H_
-#define _SECP256K1_NUM_IMPL_H_
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#include "num.h"
-
-#if defined(USE_NUM_GMP)
-#include "num_gmp_impl.h"
-#elif defined(USE_NUM_NONE)
-/* Nothing. */
-#else
-#error "Please select num implementation"
-#endif
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/scalar.h b/crypto/secp256k1/libsecp256k1/src/scalar.h
deleted file mode 100644
index 27e9d8375e..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/scalar.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_
-#define _SECP256K1_SCALAR_
-
-#include "num.h"
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#if defined(EXHAUSTIVE_TEST_ORDER)
-#include "scalar_low.h"
-#elif defined(USE_SCALAR_4X64)
-#include "scalar_4x64.h"
-#elif defined(USE_SCALAR_8X32)
-#include "scalar_8x32.h"
-#else
-#error "Please select scalar implementation"
-#endif
-
-/** Clear a scalar to prevent the leak of sensitive data. */
-static void secp256k1_scalar_clear(secp256k1_scalar *r);
-
-/** Access bits from a scalar. All requested bits must belong to the same 32-bit limb. */
-static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count);
-
-/** Access bits from a scalar. Not constant time. */
-static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count);
-
-/** Set a scalar from a big endian byte array. */
-static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *bin, int *overflow);
-
-/** Set a scalar to an unsigned integer. */
-static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v);
-
-/** Convert a scalar to a byte array. */
-static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a);
-
-/** Add two scalars together (modulo the group order). Returns whether it overflowed. */
-static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b);
-
-/** Conditionally add a power of two to a scalar. The result is not allowed to overflow. */
-static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag);
-
-/** Multiply two scalars (modulo the group order). */
-static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b);
-
-/** Shift a scalar right by some amount strictly between 0 and 16, returning
- * the low bits that were shifted off */
-static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n);
-
-/** Compute the square of a scalar (modulo the group order). */
-static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a);
-
-/** Compute the inverse of a scalar (modulo the group order). */
-static void secp256k1_scalar_inverse(secp256k1_scalar *r, const secp256k1_scalar *a);
-
-/** Compute the inverse of a scalar (modulo the group order), without constant-time guarantee. */
-static void secp256k1_scalar_inverse_var(secp256k1_scalar *r, const secp256k1_scalar *a);
-
-/** Compute the complement of a scalar (modulo the group order). */
-static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a);
-
-/** Check whether a scalar equals zero. */
-static int secp256k1_scalar_is_zero(const secp256k1_scalar *a);
-
-/** Check whether a scalar equals one. */
-static int secp256k1_scalar_is_one(const secp256k1_scalar *a);
-
-/** Check whether a scalar, considered as an nonnegative integer, is even. */
-static int secp256k1_scalar_is_even(const secp256k1_scalar *a);
-
-/** Check whether a scalar is higher than the group order divided by 2. */
-static int secp256k1_scalar_is_high(const secp256k1_scalar *a);
-
-/** Conditionally negate a number, in constant time.
- * Returns -1 if the number was negated, 1 otherwise */
-static int secp256k1_scalar_cond_negate(secp256k1_scalar *a, int flag);
-
-#ifndef USE_NUM_NONE
-/** Convert a scalar to a number. */
-static void secp256k1_scalar_get_num(secp256k1_num *r, const secp256k1_scalar *a);
-
-/** Get the order of the group as a number. */
-static void secp256k1_scalar_order_get_num(secp256k1_num *r);
-#endif
-
-/** Compare two scalars. */
-static int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b);
-
-#ifdef USE_ENDOMORPHISM
-/** Find r1 and r2 such that r1+r2*2^128 = a. */
-static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a);
-/** Find r1 and r2 such that r1+r2*lambda = a, and r1 and r2 are maximum 128 bits long (see secp256k1_gej_mul_lambda). */
-static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a);
-#endif
-
-/** Multiply a and b (without taking the modulus!), divide by 2**shift, and round to the nearest integer. Shift must be at least 256. */
-static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift);
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/scalar_4x64.h b/crypto/secp256k1/libsecp256k1/src/scalar_4x64.h
deleted file mode 100644
index cff406038f..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/scalar_4x64.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_REPR_
-#define _SECP256K1_SCALAR_REPR_
-
-#include
-
-/** A scalar modulo the group order of the secp256k1 curve. */
-typedef struct {
- uint64_t d[4];
-} secp256k1_scalar;
-
-#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{((uint64_t)(d1)) << 32 | (d0), ((uint64_t)(d3)) << 32 | (d2), ((uint64_t)(d5)) << 32 | (d4), ((uint64_t)(d7)) << 32 | (d6)}}
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/scalar_4x64_impl.h b/crypto/secp256k1/libsecp256k1/src/scalar_4x64_impl.h
deleted file mode 100644
index 56e7bd82af..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/scalar_4x64_impl.h
+++ /dev/null
@@ -1,949 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_REPR_IMPL_H_
-#define _SECP256K1_SCALAR_REPR_IMPL_H_
-
-/* Limbs of the secp256k1 order. */
-#define SECP256K1_N_0 ((uint64_t)0xBFD25E8CD0364141ULL)
-#define SECP256K1_N_1 ((uint64_t)0xBAAEDCE6AF48A03BULL)
-#define SECP256K1_N_2 ((uint64_t)0xFFFFFFFFFFFFFFFEULL)
-#define SECP256K1_N_3 ((uint64_t)0xFFFFFFFFFFFFFFFFULL)
-
-/* Limbs of 2^256 minus the secp256k1 order. */
-#define SECP256K1_N_C_0 (~SECP256K1_N_0 + 1)
-#define SECP256K1_N_C_1 (~SECP256K1_N_1)
-#define SECP256K1_N_C_2 (1)
-
-/* Limbs of half the secp256k1 order. */
-#define SECP256K1_N_H_0 ((uint64_t)0xDFE92F46681B20A0ULL)
-#define SECP256K1_N_H_1 ((uint64_t)0x5D576E7357A4501DULL)
-#define SECP256K1_N_H_2 ((uint64_t)0xFFFFFFFFFFFFFFFFULL)
-#define SECP256K1_N_H_3 ((uint64_t)0x7FFFFFFFFFFFFFFFULL)
-
-SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) {
- r->d[0] = 0;
- r->d[1] = 0;
- r->d[2] = 0;
- r->d[3] = 0;
-}
-
-SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v) {
- r->d[0] = v;
- r->d[1] = 0;
- r->d[2] = 0;
- r->d[3] = 0;
-}
-
-SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
- VERIFY_CHECK((offset + count - 1) >> 6 == offset >> 6);
- return (a->d[offset >> 6] >> (offset & 0x3F)) & ((((uint64_t)1) << count) - 1);
-}
-
-SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
- VERIFY_CHECK(count < 32);
- VERIFY_CHECK(offset + count <= 256);
- if ((offset + count - 1) >> 6 == offset >> 6) {
- return secp256k1_scalar_get_bits(a, offset, count);
- } else {
- VERIFY_CHECK((offset >> 6) + 1 < 4);
- return ((a->d[offset >> 6] >> (offset & 0x3F)) | (a->d[(offset >> 6) + 1] << (64 - (offset & 0x3F)))) & ((((uint64_t)1) << count) - 1);
- }
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar *a) {
- int yes = 0;
- int no = 0;
- no |= (a->d[3] < SECP256K1_N_3); /* No need for a > check. */
- no |= (a->d[2] < SECP256K1_N_2);
- yes |= (a->d[2] > SECP256K1_N_2) & ~no;
- no |= (a->d[1] < SECP256K1_N_1);
- yes |= (a->d[1] > SECP256K1_N_1) & ~no;
- yes |= (a->d[0] >= SECP256K1_N_0) & ~no;
- return yes;
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar *r, unsigned int overflow) {
- uint128_t t;
- VERIFY_CHECK(overflow <= 1);
- t = (uint128_t)r->d[0] + overflow * SECP256K1_N_C_0;
- r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)r->d[1] + overflow * SECP256K1_N_C_1;
- r->d[1] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)r->d[2] + overflow * SECP256K1_N_C_2;
- r->d[2] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint64_t)r->d[3];
- r->d[3] = t & 0xFFFFFFFFFFFFFFFFULL;
- return overflow;
-}
-
-static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- int overflow;
- uint128_t t = (uint128_t)a->d[0] + b->d[0];
- r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)a->d[1] + b->d[1];
- r->d[1] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)a->d[2] + b->d[2];
- r->d[2] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)a->d[3] + b->d[3];
- r->d[3] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- overflow = t + secp256k1_scalar_check_overflow(r);
- VERIFY_CHECK(overflow == 0 || overflow == 1);
- secp256k1_scalar_reduce(r, overflow);
- return overflow;
-}
-
-static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag) {
- uint128_t t;
- VERIFY_CHECK(bit < 256);
- bit += ((uint32_t) flag - 1) & 0x100; /* forcing (bit >> 6) > 3 makes this a noop */
- t = (uint128_t)r->d[0] + (((uint64_t)((bit >> 6) == 0)) << (bit & 0x3F));
- r->d[0] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)r->d[1] + (((uint64_t)((bit >> 6) == 1)) << (bit & 0x3F));
- r->d[1] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)r->d[2] + (((uint64_t)((bit >> 6) == 2)) << (bit & 0x3F));
- r->d[2] = t & 0xFFFFFFFFFFFFFFFFULL; t >>= 64;
- t += (uint128_t)r->d[3] + (((uint64_t)((bit >> 6) == 3)) << (bit & 0x3F));
- r->d[3] = t & 0xFFFFFFFFFFFFFFFFULL;
-#ifdef VERIFY
- VERIFY_CHECK((t >> 64) == 0);
- VERIFY_CHECK(secp256k1_scalar_check_overflow(r) == 0);
-#endif
-}
-
-static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow) {
- int over;
- r->d[0] = (uint64_t)b32[31] | (uint64_t)b32[30] << 8 | (uint64_t)b32[29] << 16 | (uint64_t)b32[28] << 24 | (uint64_t)b32[27] << 32 | (uint64_t)b32[26] << 40 | (uint64_t)b32[25] << 48 | (uint64_t)b32[24] << 56;
- r->d[1] = (uint64_t)b32[23] | (uint64_t)b32[22] << 8 | (uint64_t)b32[21] << 16 | (uint64_t)b32[20] << 24 | (uint64_t)b32[19] << 32 | (uint64_t)b32[18] << 40 | (uint64_t)b32[17] << 48 | (uint64_t)b32[16] << 56;
- r->d[2] = (uint64_t)b32[15] | (uint64_t)b32[14] << 8 | (uint64_t)b32[13] << 16 | (uint64_t)b32[12] << 24 | (uint64_t)b32[11] << 32 | (uint64_t)b32[10] << 40 | (uint64_t)b32[9] << 48 | (uint64_t)b32[8] << 56;
- r->d[3] = (uint64_t)b32[7] | (uint64_t)b32[6] << 8 | (uint64_t)b32[5] << 16 | (uint64_t)b32[4] << 24 | (uint64_t)b32[3] << 32 | (uint64_t)b32[2] << 40 | (uint64_t)b32[1] << 48 | (uint64_t)b32[0] << 56;
- over = secp256k1_scalar_reduce(r, secp256k1_scalar_check_overflow(r));
- if (overflow) {
- *overflow = over;
- }
-}
-
-static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a) {
- bin[0] = a->d[3] >> 56; bin[1] = a->d[3] >> 48; bin[2] = a->d[3] >> 40; bin[3] = a->d[3] >> 32; bin[4] = a->d[3] >> 24; bin[5] = a->d[3] >> 16; bin[6] = a->d[3] >> 8; bin[7] = a->d[3];
- bin[8] = a->d[2] >> 56; bin[9] = a->d[2] >> 48; bin[10] = a->d[2] >> 40; bin[11] = a->d[2] >> 32; bin[12] = a->d[2] >> 24; bin[13] = a->d[2] >> 16; bin[14] = a->d[2] >> 8; bin[15] = a->d[2];
- bin[16] = a->d[1] >> 56; bin[17] = a->d[1] >> 48; bin[18] = a->d[1] >> 40; bin[19] = a->d[1] >> 32; bin[20] = a->d[1] >> 24; bin[21] = a->d[1] >> 16; bin[22] = a->d[1] >> 8; bin[23] = a->d[1];
- bin[24] = a->d[0] >> 56; bin[25] = a->d[0] >> 48; bin[26] = a->d[0] >> 40; bin[27] = a->d[0] >> 32; bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0];
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar *a) {
- return (a->d[0] | a->d[1] | a->d[2] | a->d[3]) == 0;
-}
-
-static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a) {
- uint64_t nonzero = 0xFFFFFFFFFFFFFFFFULL * (secp256k1_scalar_is_zero(a) == 0);
- uint128_t t = (uint128_t)(~a->d[0]) + SECP256K1_N_0 + 1;
- r->d[0] = t & nonzero; t >>= 64;
- t += (uint128_t)(~a->d[1]) + SECP256K1_N_1;
- r->d[1] = t & nonzero; t >>= 64;
- t += (uint128_t)(~a->d[2]) + SECP256K1_N_2;
- r->d[2] = t & nonzero; t >>= 64;
- t += (uint128_t)(~a->d[3]) + SECP256K1_N_3;
- r->d[3] = t & nonzero;
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar *a) {
- return ((a->d[0] ^ 1) | a->d[1] | a->d[2] | a->d[3]) == 0;
-}
-
-static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
- int yes = 0;
- int no = 0;
- no |= (a->d[3] < SECP256K1_N_H_3);
- yes |= (a->d[3] > SECP256K1_N_H_3) & ~no;
- no |= (a->d[2] < SECP256K1_N_H_2) & ~yes; /* No need for a > check. */
- no |= (a->d[1] < SECP256K1_N_H_1) & ~yes;
- yes |= (a->d[1] > SECP256K1_N_H_1) & ~no;
- yes |= (a->d[0] > SECP256K1_N_H_0) & ~no;
- return yes;
-}
-
-static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
- /* If we are flag = 0, mask = 00...00 and this is a no-op;
- * if we are flag = 1, mask = 11...11 and this is identical to secp256k1_scalar_negate */
- uint64_t mask = !flag - 1;
- uint64_t nonzero = (secp256k1_scalar_is_zero(r) != 0) - 1;
- uint128_t t = (uint128_t)(r->d[0] ^ mask) + ((SECP256K1_N_0 + 1) & mask);
- r->d[0] = t & nonzero; t >>= 64;
- t += (uint128_t)(r->d[1] ^ mask) + (SECP256K1_N_1 & mask);
- r->d[1] = t & nonzero; t >>= 64;
- t += (uint128_t)(r->d[2] ^ mask) + (SECP256K1_N_2 & mask);
- r->d[2] = t & nonzero; t >>= 64;
- t += (uint128_t)(r->d[3] ^ mask) + (SECP256K1_N_3 & mask);
- r->d[3] = t & nonzero;
- return 2 * (mask == 0) - 1;
-}
-
-/* Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. */
-
-/** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
-#define muladd(a,b) { \
- uint64_t tl, th; \
- { \
- uint128_t t = (uint128_t)a * b; \
- th = t >> 64; /* at most 0xFFFFFFFFFFFFFFFE */ \
- tl = t; \
- } \
- c0 += tl; /* overflow is handled on the next line */ \
- th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFFFFFFFFFF */ \
- c1 += th; /* overflow is handled on the next line */ \
- c2 += (c1 < th) ? 1 : 0; /* never overflows by contract (verified in the next line) */ \
- VERIFY_CHECK((c1 >= th) || (c2 != 0)); \
-}
-
-/** Add a*b to the number defined by (c0,c1). c1 must never overflow. */
-#define muladd_fast(a,b) { \
- uint64_t tl, th; \
- { \
- uint128_t t = (uint128_t)a * b; \
- th = t >> 64; /* at most 0xFFFFFFFFFFFFFFFE */ \
- tl = t; \
- } \
- c0 += tl; /* overflow is handled on the next line */ \
- th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFFFFFFFFFF */ \
- c1 += th; /* never overflows by contract (verified in the next line) */ \
- VERIFY_CHECK(c1 >= th); \
-}
-
-/** Add 2*a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
-#define muladd2(a,b) { \
- uint64_t tl, th, th2, tl2; \
- { \
- uint128_t t = (uint128_t)a * b; \
- th = t >> 64; /* at most 0xFFFFFFFFFFFFFFFE */ \
- tl = t; \
- } \
- th2 = th + th; /* at most 0xFFFFFFFFFFFFFFFE (in case th was 0x7FFFFFFFFFFFFFFF) */ \
- c2 += (th2 < th) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((th2 >= th) || (c2 != 0)); \
- tl2 = tl + tl; /* at most 0xFFFFFFFFFFFFFFFE (in case the lowest 63 bits of tl were 0x7FFFFFFFFFFFFFFF) */ \
- th2 += (tl2 < tl) ? 1 : 0; /* at most 0xFFFFFFFFFFFFFFFF */ \
- c0 += tl2; /* overflow is handled on the next line */ \
- th2 += (c0 < tl2) ? 1 : 0; /* second overflow is handled on the next line */ \
- c2 += (c0 < tl2) & (th2 == 0); /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((c0 >= tl2) || (th2 != 0) || (c2 != 0)); \
- c1 += th2; /* overflow is handled on the next line */ \
- c2 += (c1 < th2) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((c1 >= th2) || (c2 != 0)); \
-}
-
-/** Add a to the number defined by (c0,c1,c2). c2 must never overflow. */
-#define sumadd(a) { \
- unsigned int over; \
- c0 += (a); /* overflow is handled on the next line */ \
- over = (c0 < (a)) ? 1 : 0; \
- c1 += over; /* overflow is handled on the next line */ \
- c2 += (c1 < over) ? 1 : 0; /* never overflows by contract */ \
-}
-
-/** Add a to the number defined by (c0,c1). c1 must never overflow, c2 must be zero. */
-#define sumadd_fast(a) { \
- c0 += (a); /* overflow is handled on the next line */ \
- c1 += (c0 < (a)) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((c1 != 0) | (c0 >= (a))); \
- VERIFY_CHECK(c2 == 0); \
-}
-
-/** Extract the lowest 64 bits of (c0,c1,c2) into n, and left shift the number 64 bits. */
-#define extract(n) { \
- (n) = c0; \
- c0 = c1; \
- c1 = c2; \
- c2 = 0; \
-}
-
-/** Extract the lowest 64 bits of (c0,c1,c2) into n, and left shift the number 64 bits. c2 is required to be zero. */
-#define extract_fast(n) { \
- (n) = c0; \
- c0 = c1; \
- c1 = 0; \
- VERIFY_CHECK(c2 == 0); \
-}
-
-static void secp256k1_scalar_reduce_512(secp256k1_scalar *r, const uint64_t *l) {
-#ifdef USE_ASM_X86_64
- /* Reduce 512 bits into 385. */
- uint64_t m0, m1, m2, m3, m4, m5, m6;
- uint64_t p0, p1, p2, p3, p4;
- uint64_t c;
-
- __asm__ __volatile__(
- /* Preload. */
- "movq 32(%%rsi), %%r11\n"
- "movq 40(%%rsi), %%r12\n"
- "movq 48(%%rsi), %%r13\n"
- "movq 56(%%rsi), %%r14\n"
- /* Initialize r8,r9,r10 */
- "movq 0(%%rsi), %%r8\n"
- "xorq %%r9, %%r9\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9) += n0 * c0 */
- "movq %8, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- /* extract m0 */
- "movq %%r8, %q0\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10) += l1 */
- "addq 8(%%rsi), %%r9\n"
- "adcq $0, %%r10\n"
- /* (r9,r10,r8) += n1 * c0 */
- "movq %8, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += n0 * c1 */
- "movq %9, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* extract m1 */
- "movq %%r9, %q1\n"
- "xorq %%r9, %%r9\n"
- /* (r10,r8,r9) += l2 */
- "addq 16(%%rsi), %%r10\n"
- "adcq $0, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += n2 * c0 */
- "movq %8, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += n1 * c1 */
- "movq %9, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += n0 */
- "addq %%r11, %%r10\n"
- "adcq $0, %%r8\n"
- "adcq $0, %%r9\n"
- /* extract m2 */
- "movq %%r10, %q2\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9,r10) += l3 */
- "addq 24(%%rsi), %%r8\n"
- "adcq $0, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += n3 * c0 */
- "movq %8, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += n2 * c1 */
- "movq %9, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += n1 */
- "addq %%r12, %%r8\n"
- "adcq $0, %%r9\n"
- "adcq $0, %%r10\n"
- /* extract m3 */
- "movq %%r8, %q3\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10,r8) += n3 * c1 */
- "movq %9, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += n2 */
- "addq %%r13, %%r9\n"
- "adcq $0, %%r10\n"
- "adcq $0, %%r8\n"
- /* extract m4 */
- "movq %%r9, %q4\n"
- /* (r10,r8) += n3 */
- "addq %%r14, %%r10\n"
- "adcq $0, %%r8\n"
- /* extract m5 */
- "movq %%r10, %q5\n"
- /* extract m6 */
- "movq %%r8, %q6\n"
- : "=g"(m0), "=g"(m1), "=g"(m2), "=g"(m3), "=g"(m4), "=g"(m5), "=g"(m6)
- : "S"(l), "n"(SECP256K1_N_C_0), "n"(SECP256K1_N_C_1)
- : "rax", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "cc");
-
- /* Reduce 385 bits into 258. */
- __asm__ __volatile__(
- /* Preload */
- "movq %q9, %%r11\n"
- "movq %q10, %%r12\n"
- "movq %q11, %%r13\n"
- /* Initialize (r8,r9,r10) */
- "movq %q5, %%r8\n"
- "xorq %%r9, %%r9\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9) += m4 * c0 */
- "movq %12, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- /* extract p0 */
- "movq %%r8, %q0\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10) += m1 */
- "addq %q6, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r9,r10,r8) += m5 * c0 */
- "movq %12, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += m4 * c1 */
- "movq %13, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* extract p1 */
- "movq %%r9, %q1\n"
- "xorq %%r9, %%r9\n"
- /* (r10,r8,r9) += m2 */
- "addq %q7, %%r10\n"
- "adcq $0, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += m6 * c0 */
- "movq %12, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += m5 * c1 */
- "movq %13, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += m4 */
- "addq %%r11, %%r10\n"
- "adcq $0, %%r8\n"
- "adcq $0, %%r9\n"
- /* extract p2 */
- "movq %%r10, %q2\n"
- /* (r8,r9) += m3 */
- "addq %q8, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r8,r9) += m6 * c1 */
- "movq %13, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- /* (r8,r9) += m5 */
- "addq %%r12, %%r8\n"
- "adcq $0, %%r9\n"
- /* extract p3 */
- "movq %%r8, %q3\n"
- /* (r9) += m6 */
- "addq %%r13, %%r9\n"
- /* extract p4 */
- "movq %%r9, %q4\n"
- : "=&g"(p0), "=&g"(p1), "=&g"(p2), "=g"(p3), "=g"(p4)
- : "g"(m0), "g"(m1), "g"(m2), "g"(m3), "g"(m4), "g"(m5), "g"(m6), "n"(SECP256K1_N_C_0), "n"(SECP256K1_N_C_1)
- : "rax", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "cc");
-
- /* Reduce 258 bits into 256. */
- __asm__ __volatile__(
- /* Preload */
- "movq %q5, %%r10\n"
- /* (rax,rdx) = p4 * c0 */
- "movq %7, %%rax\n"
- "mulq %%r10\n"
- /* (rax,rdx) += p0 */
- "addq %q1, %%rax\n"
- "adcq $0, %%rdx\n"
- /* extract r0 */
- "movq %%rax, 0(%q6)\n"
- /* Move to (r8,r9) */
- "movq %%rdx, %%r8\n"
- "xorq %%r9, %%r9\n"
- /* (r8,r9) += p1 */
- "addq %q2, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r8,r9) += p4 * c1 */
- "movq %8, %%rax\n"
- "mulq %%r10\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- /* Extract r1 */
- "movq %%r8, 8(%q6)\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r8) += p4 */
- "addq %%r10, %%r9\n"
- "adcq $0, %%r8\n"
- /* (r9,r8) += p2 */
- "addq %q3, %%r9\n"
- "adcq $0, %%r8\n"
- /* Extract r2 */
- "movq %%r9, 16(%q6)\n"
- "xorq %%r9, %%r9\n"
- /* (r8,r9) += p3 */
- "addq %q4, %%r8\n"
- "adcq $0, %%r9\n"
- /* Extract r3 */
- "movq %%r8, 24(%q6)\n"
- /* Extract c */
- "movq %%r9, %q0\n"
- : "=g"(c)
- : "g"(p0), "g"(p1), "g"(p2), "g"(p3), "g"(p4), "D"(r), "n"(SECP256K1_N_C_0), "n"(SECP256K1_N_C_1)
- : "rax", "rdx", "r8", "r9", "r10", "cc", "memory");
-#else
- uint128_t c;
- uint64_t c0, c1, c2;
- uint64_t n0 = l[4], n1 = l[5], n2 = l[6], n3 = l[7];
- uint64_t m0, m1, m2, m3, m4, m5;
- uint32_t m6;
- uint64_t p0, p1, p2, p3;
- uint32_t p4;
-
- /* Reduce 512 bits into 385. */
- /* m[0..6] = l[0..3] + n[0..3] * SECP256K1_N_C. */
- c0 = l[0]; c1 = 0; c2 = 0;
- muladd_fast(n0, SECP256K1_N_C_0);
- extract_fast(m0);
- sumadd_fast(l[1]);
- muladd(n1, SECP256K1_N_C_0);
- muladd(n0, SECP256K1_N_C_1);
- extract(m1);
- sumadd(l[2]);
- muladd(n2, SECP256K1_N_C_0);
- muladd(n1, SECP256K1_N_C_1);
- sumadd(n0);
- extract(m2);
- sumadd(l[3]);
- muladd(n3, SECP256K1_N_C_0);
- muladd(n2, SECP256K1_N_C_1);
- sumadd(n1);
- extract(m3);
- muladd(n3, SECP256K1_N_C_1);
- sumadd(n2);
- extract(m4);
- sumadd_fast(n3);
- extract_fast(m5);
- VERIFY_CHECK(c0 <= 1);
- m6 = c0;
-
- /* Reduce 385 bits into 258. */
- /* p[0..4] = m[0..3] + m[4..6] * SECP256K1_N_C. */
- c0 = m0; c1 = 0; c2 = 0;
- muladd_fast(m4, SECP256K1_N_C_0);
- extract_fast(p0);
- sumadd_fast(m1);
- muladd(m5, SECP256K1_N_C_0);
- muladd(m4, SECP256K1_N_C_1);
- extract(p1);
- sumadd(m2);
- muladd(m6, SECP256K1_N_C_0);
- muladd(m5, SECP256K1_N_C_1);
- sumadd(m4);
- extract(p2);
- sumadd_fast(m3);
- muladd_fast(m6, SECP256K1_N_C_1);
- sumadd_fast(m5);
- extract_fast(p3);
- p4 = c0 + m6;
- VERIFY_CHECK(p4 <= 2);
-
- /* Reduce 258 bits into 256. */
- /* r[0..3] = p[0..3] + p[4] * SECP256K1_N_C. */
- c = p0 + (uint128_t)SECP256K1_N_C_0 * p4;
- r->d[0] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64;
- c += p1 + (uint128_t)SECP256K1_N_C_1 * p4;
- r->d[1] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64;
- c += p2 + (uint128_t)p4;
- r->d[2] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64;
- c += p3;
- r->d[3] = c & 0xFFFFFFFFFFFFFFFFULL; c >>= 64;
-#endif
-
- /* Final reduction of r. */
- secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r));
-}
-
-static void secp256k1_scalar_mul_512(uint64_t l[8], const secp256k1_scalar *a, const secp256k1_scalar *b) {
-#ifdef USE_ASM_X86_64
- const uint64_t *pb = b->d;
- __asm__ __volatile__(
- /* Preload */
- "movq 0(%%rdi), %%r15\n"
- "movq 8(%%rdi), %%rbx\n"
- "movq 16(%%rdi), %%rcx\n"
- "movq 0(%%rdx), %%r11\n"
- "movq 8(%%rdx), %%r12\n"
- "movq 16(%%rdx), %%r13\n"
- "movq 24(%%rdx), %%r14\n"
- /* (rax,rdx) = a0 * b0 */
- "movq %%r15, %%rax\n"
- "mulq %%r11\n"
- /* Extract l0 */
- "movq %%rax, 0(%%rsi)\n"
- /* (r8,r9,r10) = (rdx) */
- "movq %%rdx, %%r8\n"
- "xorq %%r9, %%r9\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9,r10) += a0 * b1 */
- "movq %%r15, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += a1 * b0 */
- "movq %%rbx, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* Extract l1 */
- "movq %%r8, 8(%%rsi)\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10,r8) += a0 * b2 */
- "movq %%r15, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += a1 * b1 */
- "movq %%rbx, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += a2 * b0 */
- "movq %%rcx, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* Extract l2 */
- "movq %%r9, 16(%%rsi)\n"
- "xorq %%r9, %%r9\n"
- /* (r10,r8,r9) += a0 * b3 */
- "movq %%r15, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* Preload a3 */
- "movq 24(%%rdi), %%r15\n"
- /* (r10,r8,r9) += a1 * b2 */
- "movq %%rbx, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += a2 * b1 */
- "movq %%rcx, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += a3 * b0 */
- "movq %%r15, %%rax\n"
- "mulq %%r11\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* Extract l3 */
- "movq %%r10, 24(%%rsi)\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9,r10) += a1 * b3 */
- "movq %%rbx, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += a2 * b2 */
- "movq %%rcx, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += a3 * b1 */
- "movq %%r15, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* Extract l4 */
- "movq %%r8, 32(%%rsi)\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10,r8) += a2 * b3 */
- "movq %%rcx, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += a3 * b2 */
- "movq %%r15, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* Extract l5 */
- "movq %%r9, 40(%%rsi)\n"
- /* (r10,r8) += a3 * b3 */
- "movq %%r15, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- /* Extract l6 */
- "movq %%r10, 48(%%rsi)\n"
- /* Extract l7 */
- "movq %%r8, 56(%%rsi)\n"
- : "+d"(pb)
- : "S"(l), "D"(a->d)
- : "rax", "rbx", "rcx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "cc", "memory");
-#else
- /* 160 bit accumulator. */
- uint64_t c0 = 0, c1 = 0;
- uint32_t c2 = 0;
-
- /* l[0..7] = a[0..3] * b[0..3]. */
- muladd_fast(a->d[0], b->d[0]);
- extract_fast(l[0]);
- muladd(a->d[0], b->d[1]);
- muladd(a->d[1], b->d[0]);
- extract(l[1]);
- muladd(a->d[0], b->d[2]);
- muladd(a->d[1], b->d[1]);
- muladd(a->d[2], b->d[0]);
- extract(l[2]);
- muladd(a->d[0], b->d[3]);
- muladd(a->d[1], b->d[2]);
- muladd(a->d[2], b->d[1]);
- muladd(a->d[3], b->d[0]);
- extract(l[3]);
- muladd(a->d[1], b->d[3]);
- muladd(a->d[2], b->d[2]);
- muladd(a->d[3], b->d[1]);
- extract(l[4]);
- muladd(a->d[2], b->d[3]);
- muladd(a->d[3], b->d[2]);
- extract(l[5]);
- muladd_fast(a->d[3], b->d[3]);
- extract_fast(l[6]);
- VERIFY_CHECK(c1 == 0);
- l[7] = c0;
-#endif
-}
-
-static void secp256k1_scalar_sqr_512(uint64_t l[8], const secp256k1_scalar *a) {
-#ifdef USE_ASM_X86_64
- __asm__ __volatile__(
- /* Preload */
- "movq 0(%%rdi), %%r11\n"
- "movq 8(%%rdi), %%r12\n"
- "movq 16(%%rdi), %%r13\n"
- "movq 24(%%rdi), %%r14\n"
- /* (rax,rdx) = a0 * a0 */
- "movq %%r11, %%rax\n"
- "mulq %%r11\n"
- /* Extract l0 */
- "movq %%rax, 0(%%rsi)\n"
- /* (r8,r9,r10) = (rdx,0) */
- "movq %%rdx, %%r8\n"
- "xorq %%r9, %%r9\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9,r10) += 2 * a0 * a1 */
- "movq %%r11, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* Extract l1 */
- "movq %%r8, 8(%%rsi)\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10,r8) += 2 * a0 * a2 */
- "movq %%r11, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* (r9,r10,r8) += a1 * a1 */
- "movq %%r12, %%rax\n"
- "mulq %%r12\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* Extract l2 */
- "movq %%r9, 16(%%rsi)\n"
- "xorq %%r9, %%r9\n"
- /* (r10,r8,r9) += 2 * a0 * a3 */
- "movq %%r11, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* (r10,r8,r9) += 2 * a1 * a2 */
- "movq %%r12, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- "adcq $0, %%r9\n"
- /* Extract l3 */
- "movq %%r10, 24(%%rsi)\n"
- "xorq %%r10, %%r10\n"
- /* (r8,r9,r10) += 2 * a1 * a3 */
- "movq %%r12, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* (r8,r9,r10) += a2 * a2 */
- "movq %%r13, %%rax\n"
- "mulq %%r13\n"
- "addq %%rax, %%r8\n"
- "adcq %%rdx, %%r9\n"
- "adcq $0, %%r10\n"
- /* Extract l4 */
- "movq %%r8, 32(%%rsi)\n"
- "xorq %%r8, %%r8\n"
- /* (r9,r10,r8) += 2 * a2 * a3 */
- "movq %%r13, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- "addq %%rax, %%r9\n"
- "adcq %%rdx, %%r10\n"
- "adcq $0, %%r8\n"
- /* Extract l5 */
- "movq %%r9, 40(%%rsi)\n"
- /* (r10,r8) += a3 * a3 */
- "movq %%r14, %%rax\n"
- "mulq %%r14\n"
- "addq %%rax, %%r10\n"
- "adcq %%rdx, %%r8\n"
- /* Extract l6 */
- "movq %%r10, 48(%%rsi)\n"
- /* Extract l7 */
- "movq %%r8, 56(%%rsi)\n"
- :
- : "S"(l), "D"(a->d)
- : "rax", "rdx", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "cc", "memory");
-#else
- /* 160 bit accumulator. */
- uint64_t c0 = 0, c1 = 0;
- uint32_t c2 = 0;
-
- /* l[0..7] = a[0..3] * b[0..3]. */
- muladd_fast(a->d[0], a->d[0]);
- extract_fast(l[0]);
- muladd2(a->d[0], a->d[1]);
- extract(l[1]);
- muladd2(a->d[0], a->d[2]);
- muladd(a->d[1], a->d[1]);
- extract(l[2]);
- muladd2(a->d[0], a->d[3]);
- muladd2(a->d[1], a->d[2]);
- extract(l[3]);
- muladd2(a->d[1], a->d[3]);
- muladd(a->d[2], a->d[2]);
- extract(l[4]);
- muladd2(a->d[2], a->d[3]);
- extract(l[5]);
- muladd_fast(a->d[3], a->d[3]);
- extract_fast(l[6]);
- VERIFY_CHECK(c1 == 0);
- l[7] = c0;
-#endif
-}
-
-#undef sumadd
-#undef sumadd_fast
-#undef muladd
-#undef muladd_fast
-#undef muladd2
-#undef extract
-#undef extract_fast
-
-static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- uint64_t l[8];
- secp256k1_scalar_mul_512(l, a, b);
- secp256k1_scalar_reduce_512(r, l);
-}
-
-static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
- int ret;
- VERIFY_CHECK(n > 0);
- VERIFY_CHECK(n < 16);
- ret = r->d[0] & ((1 << n) - 1);
- r->d[0] = (r->d[0] >> n) + (r->d[1] << (64 - n));
- r->d[1] = (r->d[1] >> n) + (r->d[2] << (64 - n));
- r->d[2] = (r->d[2] >> n) + (r->d[3] << (64 - n));
- r->d[3] = (r->d[3] >> n);
- return ret;
-}
-
-static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a) {
- uint64_t l[8];
- secp256k1_scalar_sqr_512(l, a);
- secp256k1_scalar_reduce_512(r, l);
-}
-
-#ifdef USE_ENDOMORPHISM
-static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
- r1->d[0] = a->d[0];
- r1->d[1] = a->d[1];
- r1->d[2] = 0;
- r1->d[3] = 0;
- r2->d[0] = a->d[2];
- r2->d[1] = a->d[3];
- r2->d[2] = 0;
- r2->d[3] = 0;
-}
-#endif
-
-SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b) {
- return ((a->d[0] ^ b->d[0]) | (a->d[1] ^ b->d[1]) | (a->d[2] ^ b->d[2]) | (a->d[3] ^ b->d[3])) == 0;
-}
-
-SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift) {
- uint64_t l[8];
- unsigned int shiftlimbs;
- unsigned int shiftlow;
- unsigned int shifthigh;
- VERIFY_CHECK(shift >= 256);
- secp256k1_scalar_mul_512(l, a, b);
- shiftlimbs = shift >> 6;
- shiftlow = shift & 0x3F;
- shifthigh = 64 - shiftlow;
- r->d[0] = shift < 512 ? (l[0 + shiftlimbs] >> shiftlow | (shift < 448 && shiftlow ? (l[1 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[1] = shift < 448 ? (l[1 + shiftlimbs] >> shiftlow | (shift < 384 && shiftlow ? (l[2 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[2] = shift < 384 ? (l[2 + shiftlimbs] >> shiftlow | (shift < 320 && shiftlow ? (l[3 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[3] = shift < 320 ? (l[3 + shiftlimbs] >> shiftlow) : 0;
- secp256k1_scalar_cadd_bit(r, 0, (l[(shift - 1) >> 6] >> ((shift - 1) & 0x3f)) & 1);
-}
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/scalar_8x32.h b/crypto/secp256k1/libsecp256k1/src/scalar_8x32.h
deleted file mode 100644
index 1319664f65..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/scalar_8x32.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_REPR_
-#define _SECP256K1_SCALAR_REPR_
-
-#include
-
-/** A scalar modulo the group order of the secp256k1 curve. */
-typedef struct {
- uint32_t d[8];
-} secp256k1_scalar;
-
-#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0) {{(d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7)}}
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/scalar_8x32_impl.h b/crypto/secp256k1/libsecp256k1/src/scalar_8x32_impl.h
deleted file mode 100644
index aae4f35c08..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/scalar_8x32_impl.h
+++ /dev/null
@@ -1,721 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_REPR_IMPL_H_
-#define _SECP256K1_SCALAR_REPR_IMPL_H_
-
-/* Limbs of the secp256k1 order. */
-#define SECP256K1_N_0 ((uint32_t)0xD0364141UL)
-#define SECP256K1_N_1 ((uint32_t)0xBFD25E8CUL)
-#define SECP256K1_N_2 ((uint32_t)0xAF48A03BUL)
-#define SECP256K1_N_3 ((uint32_t)0xBAAEDCE6UL)
-#define SECP256K1_N_4 ((uint32_t)0xFFFFFFFEUL)
-#define SECP256K1_N_5 ((uint32_t)0xFFFFFFFFUL)
-#define SECP256K1_N_6 ((uint32_t)0xFFFFFFFFUL)
-#define SECP256K1_N_7 ((uint32_t)0xFFFFFFFFUL)
-
-/* Limbs of 2^256 minus the secp256k1 order. */
-#define SECP256K1_N_C_0 (~SECP256K1_N_0 + 1)
-#define SECP256K1_N_C_1 (~SECP256K1_N_1)
-#define SECP256K1_N_C_2 (~SECP256K1_N_2)
-#define SECP256K1_N_C_3 (~SECP256K1_N_3)
-#define SECP256K1_N_C_4 (1)
-
-/* Limbs of half the secp256k1 order. */
-#define SECP256K1_N_H_0 ((uint32_t)0x681B20A0UL)
-#define SECP256K1_N_H_1 ((uint32_t)0xDFE92F46UL)
-#define SECP256K1_N_H_2 ((uint32_t)0x57A4501DUL)
-#define SECP256K1_N_H_3 ((uint32_t)0x5D576E73UL)
-#define SECP256K1_N_H_4 ((uint32_t)0xFFFFFFFFUL)
-#define SECP256K1_N_H_5 ((uint32_t)0xFFFFFFFFUL)
-#define SECP256K1_N_H_6 ((uint32_t)0xFFFFFFFFUL)
-#define SECP256K1_N_H_7 ((uint32_t)0x7FFFFFFFUL)
-
-SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) {
- r->d[0] = 0;
- r->d[1] = 0;
- r->d[2] = 0;
- r->d[3] = 0;
- r->d[4] = 0;
- r->d[5] = 0;
- r->d[6] = 0;
- r->d[7] = 0;
-}
-
-SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v) {
- r->d[0] = v;
- r->d[1] = 0;
- r->d[2] = 0;
- r->d[3] = 0;
- r->d[4] = 0;
- r->d[5] = 0;
- r->d[6] = 0;
- r->d[7] = 0;
-}
-
-SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
- VERIFY_CHECK((offset + count - 1) >> 5 == offset >> 5);
- return (a->d[offset >> 5] >> (offset & 0x1F)) & ((1 << count) - 1);
-}
-
-SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
- VERIFY_CHECK(count < 32);
- VERIFY_CHECK(offset + count <= 256);
- if ((offset + count - 1) >> 5 == offset >> 5) {
- return secp256k1_scalar_get_bits(a, offset, count);
- } else {
- VERIFY_CHECK((offset >> 5) + 1 < 8);
- return ((a->d[offset >> 5] >> (offset & 0x1F)) | (a->d[(offset >> 5) + 1] << (32 - (offset & 0x1F)))) & ((((uint32_t)1) << count) - 1);
- }
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar *a) {
- int yes = 0;
- int no = 0;
- no |= (a->d[7] < SECP256K1_N_7); /* No need for a > check. */
- no |= (a->d[6] < SECP256K1_N_6); /* No need for a > check. */
- no |= (a->d[5] < SECP256K1_N_5); /* No need for a > check. */
- no |= (a->d[4] < SECP256K1_N_4);
- yes |= (a->d[4] > SECP256K1_N_4) & ~no;
- no |= (a->d[3] < SECP256K1_N_3) & ~yes;
- yes |= (a->d[3] > SECP256K1_N_3) & ~no;
- no |= (a->d[2] < SECP256K1_N_2) & ~yes;
- yes |= (a->d[2] > SECP256K1_N_2) & ~no;
- no |= (a->d[1] < SECP256K1_N_1) & ~yes;
- yes |= (a->d[1] > SECP256K1_N_1) & ~no;
- yes |= (a->d[0] >= SECP256K1_N_0) & ~no;
- return yes;
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar *r, uint32_t overflow) {
- uint64_t t;
- VERIFY_CHECK(overflow <= 1);
- t = (uint64_t)r->d[0] + overflow * SECP256K1_N_C_0;
- r->d[0] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[1] + overflow * SECP256K1_N_C_1;
- r->d[1] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[2] + overflow * SECP256K1_N_C_2;
- r->d[2] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[3] + overflow * SECP256K1_N_C_3;
- r->d[3] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[4] + overflow * SECP256K1_N_C_4;
- r->d[4] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[5];
- r->d[5] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[6];
- r->d[6] = t & 0xFFFFFFFFUL; t >>= 32;
- t += (uint64_t)r->d[7];
- r->d[7] = t & 0xFFFFFFFFUL;
- return overflow;
-}
-
-static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- int overflow;
- uint64_t t = (uint64_t)a->d[0] + b->d[0];
- r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[1] + b->d[1];
- r->d[1] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[2] + b->d[2];
- r->d[2] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[3] + b->d[3];
- r->d[3] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[4] + b->d[4];
- r->d[4] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[5] + b->d[5];
- r->d[5] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[6] + b->d[6];
- r->d[6] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)a->d[7] + b->d[7];
- r->d[7] = t & 0xFFFFFFFFULL; t >>= 32;
- overflow = t + secp256k1_scalar_check_overflow(r);
- VERIFY_CHECK(overflow == 0 || overflow == 1);
- secp256k1_scalar_reduce(r, overflow);
- return overflow;
-}
-
-static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag) {
- uint64_t t;
- VERIFY_CHECK(bit < 256);
- bit += ((uint32_t) flag - 1) & 0x100; /* forcing (bit >> 5) > 7 makes this a noop */
- t = (uint64_t)r->d[0] + (((uint32_t)((bit >> 5) == 0)) << (bit & 0x1F));
- r->d[0] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[1] + (((uint32_t)((bit >> 5) == 1)) << (bit & 0x1F));
- r->d[1] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[2] + (((uint32_t)((bit >> 5) == 2)) << (bit & 0x1F));
- r->d[2] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[3] + (((uint32_t)((bit >> 5) == 3)) << (bit & 0x1F));
- r->d[3] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[4] + (((uint32_t)((bit >> 5) == 4)) << (bit & 0x1F));
- r->d[4] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[5] + (((uint32_t)((bit >> 5) == 5)) << (bit & 0x1F));
- r->d[5] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[6] + (((uint32_t)((bit >> 5) == 6)) << (bit & 0x1F));
- r->d[6] = t & 0xFFFFFFFFULL; t >>= 32;
- t += (uint64_t)r->d[7] + (((uint32_t)((bit >> 5) == 7)) << (bit & 0x1F));
- r->d[7] = t & 0xFFFFFFFFULL;
-#ifdef VERIFY
- VERIFY_CHECK((t >> 32) == 0);
- VERIFY_CHECK(secp256k1_scalar_check_overflow(r) == 0);
-#endif
-}
-
-static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow) {
- int over;
- r->d[0] = (uint32_t)b32[31] | (uint32_t)b32[30] << 8 | (uint32_t)b32[29] << 16 | (uint32_t)b32[28] << 24;
- r->d[1] = (uint32_t)b32[27] | (uint32_t)b32[26] << 8 | (uint32_t)b32[25] << 16 | (uint32_t)b32[24] << 24;
- r->d[2] = (uint32_t)b32[23] | (uint32_t)b32[22] << 8 | (uint32_t)b32[21] << 16 | (uint32_t)b32[20] << 24;
- r->d[3] = (uint32_t)b32[19] | (uint32_t)b32[18] << 8 | (uint32_t)b32[17] << 16 | (uint32_t)b32[16] << 24;
- r->d[4] = (uint32_t)b32[15] | (uint32_t)b32[14] << 8 | (uint32_t)b32[13] << 16 | (uint32_t)b32[12] << 24;
- r->d[5] = (uint32_t)b32[11] | (uint32_t)b32[10] << 8 | (uint32_t)b32[9] << 16 | (uint32_t)b32[8] << 24;
- r->d[6] = (uint32_t)b32[7] | (uint32_t)b32[6] << 8 | (uint32_t)b32[5] << 16 | (uint32_t)b32[4] << 24;
- r->d[7] = (uint32_t)b32[3] | (uint32_t)b32[2] << 8 | (uint32_t)b32[1] << 16 | (uint32_t)b32[0] << 24;
- over = secp256k1_scalar_reduce(r, secp256k1_scalar_check_overflow(r));
- if (overflow) {
- *overflow = over;
- }
-}
-
-static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a) {
- bin[0] = a->d[7] >> 24; bin[1] = a->d[7] >> 16; bin[2] = a->d[7] >> 8; bin[3] = a->d[7];
- bin[4] = a->d[6] >> 24; bin[5] = a->d[6] >> 16; bin[6] = a->d[6] >> 8; bin[7] = a->d[6];
- bin[8] = a->d[5] >> 24; bin[9] = a->d[5] >> 16; bin[10] = a->d[5] >> 8; bin[11] = a->d[5];
- bin[12] = a->d[4] >> 24; bin[13] = a->d[4] >> 16; bin[14] = a->d[4] >> 8; bin[15] = a->d[4];
- bin[16] = a->d[3] >> 24; bin[17] = a->d[3] >> 16; bin[18] = a->d[3] >> 8; bin[19] = a->d[3];
- bin[20] = a->d[2] >> 24; bin[21] = a->d[2] >> 16; bin[22] = a->d[2] >> 8; bin[23] = a->d[2];
- bin[24] = a->d[1] >> 24; bin[25] = a->d[1] >> 16; bin[26] = a->d[1] >> 8; bin[27] = a->d[1];
- bin[28] = a->d[0] >> 24; bin[29] = a->d[0] >> 16; bin[30] = a->d[0] >> 8; bin[31] = a->d[0];
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar *a) {
- return (a->d[0] | a->d[1] | a->d[2] | a->d[3] | a->d[4] | a->d[5] | a->d[6] | a->d[7]) == 0;
-}
-
-static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a) {
- uint32_t nonzero = 0xFFFFFFFFUL * (secp256k1_scalar_is_zero(a) == 0);
- uint64_t t = (uint64_t)(~a->d[0]) + SECP256K1_N_0 + 1;
- r->d[0] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[1]) + SECP256K1_N_1;
- r->d[1] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[2]) + SECP256K1_N_2;
- r->d[2] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[3]) + SECP256K1_N_3;
- r->d[3] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[4]) + SECP256K1_N_4;
- r->d[4] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[5]) + SECP256K1_N_5;
- r->d[5] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[6]) + SECP256K1_N_6;
- r->d[6] = t & nonzero; t >>= 32;
- t += (uint64_t)(~a->d[7]) + SECP256K1_N_7;
- r->d[7] = t & nonzero;
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar *a) {
- return ((a->d[0] ^ 1) | a->d[1] | a->d[2] | a->d[3] | a->d[4] | a->d[5] | a->d[6] | a->d[7]) == 0;
-}
-
-static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
- int yes = 0;
- int no = 0;
- no |= (a->d[7] < SECP256K1_N_H_7);
- yes |= (a->d[7] > SECP256K1_N_H_7) & ~no;
- no |= (a->d[6] < SECP256K1_N_H_6) & ~yes; /* No need for a > check. */
- no |= (a->d[5] < SECP256K1_N_H_5) & ~yes; /* No need for a > check. */
- no |= (a->d[4] < SECP256K1_N_H_4) & ~yes; /* No need for a > check. */
- no |= (a->d[3] < SECP256K1_N_H_3) & ~yes;
- yes |= (a->d[3] > SECP256K1_N_H_3) & ~no;
- no |= (a->d[2] < SECP256K1_N_H_2) & ~yes;
- yes |= (a->d[2] > SECP256K1_N_H_2) & ~no;
- no |= (a->d[1] < SECP256K1_N_H_1) & ~yes;
- yes |= (a->d[1] > SECP256K1_N_H_1) & ~no;
- yes |= (a->d[0] > SECP256K1_N_H_0) & ~no;
- return yes;
-}
-
-static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
- /* If we are flag = 0, mask = 00...00 and this is a no-op;
- * if we are flag = 1, mask = 11...11 and this is identical to secp256k1_scalar_negate */
- uint32_t mask = !flag - 1;
- uint32_t nonzero = 0xFFFFFFFFUL * (secp256k1_scalar_is_zero(r) == 0);
- uint64_t t = (uint64_t)(r->d[0] ^ mask) + ((SECP256K1_N_0 + 1) & mask);
- r->d[0] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[1] ^ mask) + (SECP256K1_N_1 & mask);
- r->d[1] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[2] ^ mask) + (SECP256K1_N_2 & mask);
- r->d[2] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[3] ^ mask) + (SECP256K1_N_3 & mask);
- r->d[3] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[4] ^ mask) + (SECP256K1_N_4 & mask);
- r->d[4] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[5] ^ mask) + (SECP256K1_N_5 & mask);
- r->d[5] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[6] ^ mask) + (SECP256K1_N_6 & mask);
- r->d[6] = t & nonzero; t >>= 32;
- t += (uint64_t)(r->d[7] ^ mask) + (SECP256K1_N_7 & mask);
- r->d[7] = t & nonzero;
- return 2 * (mask == 0) - 1;
-}
-
-
-/* Inspired by the macros in OpenSSL's crypto/bn/asm/x86_64-gcc.c. */
-
-/** Add a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
-#define muladd(a,b) { \
- uint32_t tl, th; \
- { \
- uint64_t t = (uint64_t)a * b; \
- th = t >> 32; /* at most 0xFFFFFFFE */ \
- tl = t; \
- } \
- c0 += tl; /* overflow is handled on the next line */ \
- th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFF */ \
- c1 += th; /* overflow is handled on the next line */ \
- c2 += (c1 < th) ? 1 : 0; /* never overflows by contract (verified in the next line) */ \
- VERIFY_CHECK((c1 >= th) || (c2 != 0)); \
-}
-
-/** Add a*b to the number defined by (c0,c1). c1 must never overflow. */
-#define muladd_fast(a,b) { \
- uint32_t tl, th; \
- { \
- uint64_t t = (uint64_t)a * b; \
- th = t >> 32; /* at most 0xFFFFFFFE */ \
- tl = t; \
- } \
- c0 += tl; /* overflow is handled on the next line */ \
- th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFF */ \
- c1 += th; /* never overflows by contract (verified in the next line) */ \
- VERIFY_CHECK(c1 >= th); \
-}
-
-/** Add 2*a*b to the number defined by (c0,c1,c2). c2 must never overflow. */
-#define muladd2(a,b) { \
- uint32_t tl, th, th2, tl2; \
- { \
- uint64_t t = (uint64_t)a * b; \
- th = t >> 32; /* at most 0xFFFFFFFE */ \
- tl = t; \
- } \
- th2 = th + th; /* at most 0xFFFFFFFE (in case th was 0x7FFFFFFF) */ \
- c2 += (th2 < th) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((th2 >= th) || (c2 != 0)); \
- tl2 = tl + tl; /* at most 0xFFFFFFFE (in case the lowest 63 bits of tl were 0x7FFFFFFF) */ \
- th2 += (tl2 < tl) ? 1 : 0; /* at most 0xFFFFFFFF */ \
- c0 += tl2; /* overflow is handled on the next line */ \
- th2 += (c0 < tl2) ? 1 : 0; /* second overflow is handled on the next line */ \
- c2 += (c0 < tl2) & (th2 == 0); /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((c0 >= tl2) || (th2 != 0) || (c2 != 0)); \
- c1 += th2; /* overflow is handled on the next line */ \
- c2 += (c1 < th2) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((c1 >= th2) || (c2 != 0)); \
-}
-
-/** Add a to the number defined by (c0,c1,c2). c2 must never overflow. */
-#define sumadd(a) { \
- unsigned int over; \
- c0 += (a); /* overflow is handled on the next line */ \
- over = (c0 < (a)) ? 1 : 0; \
- c1 += over; /* overflow is handled on the next line */ \
- c2 += (c1 < over) ? 1 : 0; /* never overflows by contract */ \
-}
-
-/** Add a to the number defined by (c0,c1). c1 must never overflow, c2 must be zero. */
-#define sumadd_fast(a) { \
- c0 += (a); /* overflow is handled on the next line */ \
- c1 += (c0 < (a)) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
- VERIFY_CHECK((c1 != 0) | (c0 >= (a))); \
- VERIFY_CHECK(c2 == 0); \
-}
-
-/** Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. */
-#define extract(n) { \
- (n) = c0; \
- c0 = c1; \
- c1 = c2; \
- c2 = 0; \
-}
-
-/** Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. c2 is required to be zero. */
-#define extract_fast(n) { \
- (n) = c0; \
- c0 = c1; \
- c1 = 0; \
- VERIFY_CHECK(c2 == 0); \
-}
-
-static void secp256k1_scalar_reduce_512(secp256k1_scalar *r, const uint32_t *l) {
- uint64_t c;
- uint32_t n0 = l[8], n1 = l[9], n2 = l[10], n3 = l[11], n4 = l[12], n5 = l[13], n6 = l[14], n7 = l[15];
- uint32_t m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12;
- uint32_t p0, p1, p2, p3, p4, p5, p6, p7, p8;
-
- /* 96 bit accumulator. */
- uint32_t c0, c1, c2;
-
- /* Reduce 512 bits into 385. */
- /* m[0..12] = l[0..7] + n[0..7] * SECP256K1_N_C. */
- c0 = l[0]; c1 = 0; c2 = 0;
- muladd_fast(n0, SECP256K1_N_C_0);
- extract_fast(m0);
- sumadd_fast(l[1]);
- muladd(n1, SECP256K1_N_C_0);
- muladd(n0, SECP256K1_N_C_1);
- extract(m1);
- sumadd(l[2]);
- muladd(n2, SECP256K1_N_C_0);
- muladd(n1, SECP256K1_N_C_1);
- muladd(n0, SECP256K1_N_C_2);
- extract(m2);
- sumadd(l[3]);
- muladd(n3, SECP256K1_N_C_0);
- muladd(n2, SECP256K1_N_C_1);
- muladd(n1, SECP256K1_N_C_2);
- muladd(n0, SECP256K1_N_C_3);
- extract(m3);
- sumadd(l[4]);
- muladd(n4, SECP256K1_N_C_0);
- muladd(n3, SECP256K1_N_C_1);
- muladd(n2, SECP256K1_N_C_2);
- muladd(n1, SECP256K1_N_C_3);
- sumadd(n0);
- extract(m4);
- sumadd(l[5]);
- muladd(n5, SECP256K1_N_C_0);
- muladd(n4, SECP256K1_N_C_1);
- muladd(n3, SECP256K1_N_C_2);
- muladd(n2, SECP256K1_N_C_3);
- sumadd(n1);
- extract(m5);
- sumadd(l[6]);
- muladd(n6, SECP256K1_N_C_0);
- muladd(n5, SECP256K1_N_C_1);
- muladd(n4, SECP256K1_N_C_2);
- muladd(n3, SECP256K1_N_C_3);
- sumadd(n2);
- extract(m6);
- sumadd(l[7]);
- muladd(n7, SECP256K1_N_C_0);
- muladd(n6, SECP256K1_N_C_1);
- muladd(n5, SECP256K1_N_C_2);
- muladd(n4, SECP256K1_N_C_3);
- sumadd(n3);
- extract(m7);
- muladd(n7, SECP256K1_N_C_1);
- muladd(n6, SECP256K1_N_C_2);
- muladd(n5, SECP256K1_N_C_3);
- sumadd(n4);
- extract(m8);
- muladd(n7, SECP256K1_N_C_2);
- muladd(n6, SECP256K1_N_C_3);
- sumadd(n5);
- extract(m9);
- muladd(n7, SECP256K1_N_C_3);
- sumadd(n6);
- extract(m10);
- sumadd_fast(n7);
- extract_fast(m11);
- VERIFY_CHECK(c0 <= 1);
- m12 = c0;
-
- /* Reduce 385 bits into 258. */
- /* p[0..8] = m[0..7] + m[8..12] * SECP256K1_N_C. */
- c0 = m0; c1 = 0; c2 = 0;
- muladd_fast(m8, SECP256K1_N_C_0);
- extract_fast(p0);
- sumadd_fast(m1);
- muladd(m9, SECP256K1_N_C_0);
- muladd(m8, SECP256K1_N_C_1);
- extract(p1);
- sumadd(m2);
- muladd(m10, SECP256K1_N_C_0);
- muladd(m9, SECP256K1_N_C_1);
- muladd(m8, SECP256K1_N_C_2);
- extract(p2);
- sumadd(m3);
- muladd(m11, SECP256K1_N_C_0);
- muladd(m10, SECP256K1_N_C_1);
- muladd(m9, SECP256K1_N_C_2);
- muladd(m8, SECP256K1_N_C_3);
- extract(p3);
- sumadd(m4);
- muladd(m12, SECP256K1_N_C_0);
- muladd(m11, SECP256K1_N_C_1);
- muladd(m10, SECP256K1_N_C_2);
- muladd(m9, SECP256K1_N_C_3);
- sumadd(m8);
- extract(p4);
- sumadd(m5);
- muladd(m12, SECP256K1_N_C_1);
- muladd(m11, SECP256K1_N_C_2);
- muladd(m10, SECP256K1_N_C_3);
- sumadd(m9);
- extract(p5);
- sumadd(m6);
- muladd(m12, SECP256K1_N_C_2);
- muladd(m11, SECP256K1_N_C_3);
- sumadd(m10);
- extract(p6);
- sumadd_fast(m7);
- muladd_fast(m12, SECP256K1_N_C_3);
- sumadd_fast(m11);
- extract_fast(p7);
- p8 = c0 + m12;
- VERIFY_CHECK(p8 <= 2);
-
- /* Reduce 258 bits into 256. */
- /* r[0..7] = p[0..7] + p[8] * SECP256K1_N_C. */
- c = p0 + (uint64_t)SECP256K1_N_C_0 * p8;
- r->d[0] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p1 + (uint64_t)SECP256K1_N_C_1 * p8;
- r->d[1] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p2 + (uint64_t)SECP256K1_N_C_2 * p8;
- r->d[2] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p3 + (uint64_t)SECP256K1_N_C_3 * p8;
- r->d[3] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p4 + (uint64_t)p8;
- r->d[4] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p5;
- r->d[5] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p6;
- r->d[6] = c & 0xFFFFFFFFUL; c >>= 32;
- c += p7;
- r->d[7] = c & 0xFFFFFFFFUL; c >>= 32;
-
- /* Final reduction of r. */
- secp256k1_scalar_reduce(r, c + secp256k1_scalar_check_overflow(r));
-}
-
-static void secp256k1_scalar_mul_512(uint32_t *l, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- /* 96 bit accumulator. */
- uint32_t c0 = 0, c1 = 0, c2 = 0;
-
- /* l[0..15] = a[0..7] * b[0..7]. */
- muladd_fast(a->d[0], b->d[0]);
- extract_fast(l[0]);
- muladd(a->d[0], b->d[1]);
- muladd(a->d[1], b->d[0]);
- extract(l[1]);
- muladd(a->d[0], b->d[2]);
- muladd(a->d[1], b->d[1]);
- muladd(a->d[2], b->d[0]);
- extract(l[2]);
- muladd(a->d[0], b->d[3]);
- muladd(a->d[1], b->d[2]);
- muladd(a->d[2], b->d[1]);
- muladd(a->d[3], b->d[0]);
- extract(l[3]);
- muladd(a->d[0], b->d[4]);
- muladd(a->d[1], b->d[3]);
- muladd(a->d[2], b->d[2]);
- muladd(a->d[3], b->d[1]);
- muladd(a->d[4], b->d[0]);
- extract(l[4]);
- muladd(a->d[0], b->d[5]);
- muladd(a->d[1], b->d[4]);
- muladd(a->d[2], b->d[3]);
- muladd(a->d[3], b->d[2]);
- muladd(a->d[4], b->d[1]);
- muladd(a->d[5], b->d[0]);
- extract(l[5]);
- muladd(a->d[0], b->d[6]);
- muladd(a->d[1], b->d[5]);
- muladd(a->d[2], b->d[4]);
- muladd(a->d[3], b->d[3]);
- muladd(a->d[4], b->d[2]);
- muladd(a->d[5], b->d[1]);
- muladd(a->d[6], b->d[0]);
- extract(l[6]);
- muladd(a->d[0], b->d[7]);
- muladd(a->d[1], b->d[6]);
- muladd(a->d[2], b->d[5]);
- muladd(a->d[3], b->d[4]);
- muladd(a->d[4], b->d[3]);
- muladd(a->d[5], b->d[2]);
- muladd(a->d[6], b->d[1]);
- muladd(a->d[7], b->d[0]);
- extract(l[7]);
- muladd(a->d[1], b->d[7]);
- muladd(a->d[2], b->d[6]);
- muladd(a->d[3], b->d[5]);
- muladd(a->d[4], b->d[4]);
- muladd(a->d[5], b->d[3]);
- muladd(a->d[6], b->d[2]);
- muladd(a->d[7], b->d[1]);
- extract(l[8]);
- muladd(a->d[2], b->d[7]);
- muladd(a->d[3], b->d[6]);
- muladd(a->d[4], b->d[5]);
- muladd(a->d[5], b->d[4]);
- muladd(a->d[6], b->d[3]);
- muladd(a->d[7], b->d[2]);
- extract(l[9]);
- muladd(a->d[3], b->d[7]);
- muladd(a->d[4], b->d[6]);
- muladd(a->d[5], b->d[5]);
- muladd(a->d[6], b->d[4]);
- muladd(a->d[7], b->d[3]);
- extract(l[10]);
- muladd(a->d[4], b->d[7]);
- muladd(a->d[5], b->d[6]);
- muladd(a->d[6], b->d[5]);
- muladd(a->d[7], b->d[4]);
- extract(l[11]);
- muladd(a->d[5], b->d[7]);
- muladd(a->d[6], b->d[6]);
- muladd(a->d[7], b->d[5]);
- extract(l[12]);
- muladd(a->d[6], b->d[7]);
- muladd(a->d[7], b->d[6]);
- extract(l[13]);
- muladd_fast(a->d[7], b->d[7]);
- extract_fast(l[14]);
- VERIFY_CHECK(c1 == 0);
- l[15] = c0;
-}
-
-static void secp256k1_scalar_sqr_512(uint32_t *l, const secp256k1_scalar *a) {
- /* 96 bit accumulator. */
- uint32_t c0 = 0, c1 = 0, c2 = 0;
-
- /* l[0..15] = a[0..7]^2. */
- muladd_fast(a->d[0], a->d[0]);
- extract_fast(l[0]);
- muladd2(a->d[0], a->d[1]);
- extract(l[1]);
- muladd2(a->d[0], a->d[2]);
- muladd(a->d[1], a->d[1]);
- extract(l[2]);
- muladd2(a->d[0], a->d[3]);
- muladd2(a->d[1], a->d[2]);
- extract(l[3]);
- muladd2(a->d[0], a->d[4]);
- muladd2(a->d[1], a->d[3]);
- muladd(a->d[2], a->d[2]);
- extract(l[4]);
- muladd2(a->d[0], a->d[5]);
- muladd2(a->d[1], a->d[4]);
- muladd2(a->d[2], a->d[3]);
- extract(l[5]);
- muladd2(a->d[0], a->d[6]);
- muladd2(a->d[1], a->d[5]);
- muladd2(a->d[2], a->d[4]);
- muladd(a->d[3], a->d[3]);
- extract(l[6]);
- muladd2(a->d[0], a->d[7]);
- muladd2(a->d[1], a->d[6]);
- muladd2(a->d[2], a->d[5]);
- muladd2(a->d[3], a->d[4]);
- extract(l[7]);
- muladd2(a->d[1], a->d[7]);
- muladd2(a->d[2], a->d[6]);
- muladd2(a->d[3], a->d[5]);
- muladd(a->d[4], a->d[4]);
- extract(l[8]);
- muladd2(a->d[2], a->d[7]);
- muladd2(a->d[3], a->d[6]);
- muladd2(a->d[4], a->d[5]);
- extract(l[9]);
- muladd2(a->d[3], a->d[7]);
- muladd2(a->d[4], a->d[6]);
- muladd(a->d[5], a->d[5]);
- extract(l[10]);
- muladd2(a->d[4], a->d[7]);
- muladd2(a->d[5], a->d[6]);
- extract(l[11]);
- muladd2(a->d[5], a->d[7]);
- muladd(a->d[6], a->d[6]);
- extract(l[12]);
- muladd2(a->d[6], a->d[7]);
- extract(l[13]);
- muladd_fast(a->d[7], a->d[7]);
- extract_fast(l[14]);
- VERIFY_CHECK(c1 == 0);
- l[15] = c0;
-}
-
-#undef sumadd
-#undef sumadd_fast
-#undef muladd
-#undef muladd_fast
-#undef muladd2
-#undef extract
-#undef extract_fast
-
-static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- uint32_t l[16];
- secp256k1_scalar_mul_512(l, a, b);
- secp256k1_scalar_reduce_512(r, l);
-}
-
-static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
- int ret;
- VERIFY_CHECK(n > 0);
- VERIFY_CHECK(n < 16);
- ret = r->d[0] & ((1 << n) - 1);
- r->d[0] = (r->d[0] >> n) + (r->d[1] << (32 - n));
- r->d[1] = (r->d[1] >> n) + (r->d[2] << (32 - n));
- r->d[2] = (r->d[2] >> n) + (r->d[3] << (32 - n));
- r->d[3] = (r->d[3] >> n) + (r->d[4] << (32 - n));
- r->d[4] = (r->d[4] >> n) + (r->d[5] << (32 - n));
- r->d[5] = (r->d[5] >> n) + (r->d[6] << (32 - n));
- r->d[6] = (r->d[6] >> n) + (r->d[7] << (32 - n));
- r->d[7] = (r->d[7] >> n);
- return ret;
-}
-
-static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a) {
- uint32_t l[16];
- secp256k1_scalar_sqr_512(l, a);
- secp256k1_scalar_reduce_512(r, l);
-}
-
-#ifdef USE_ENDOMORPHISM
-static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
- r1->d[0] = a->d[0];
- r1->d[1] = a->d[1];
- r1->d[2] = a->d[2];
- r1->d[3] = a->d[3];
- r1->d[4] = 0;
- r1->d[5] = 0;
- r1->d[6] = 0;
- r1->d[7] = 0;
- r2->d[0] = a->d[4];
- r2->d[1] = a->d[5];
- r2->d[2] = a->d[6];
- r2->d[3] = a->d[7];
- r2->d[4] = 0;
- r2->d[5] = 0;
- r2->d[6] = 0;
- r2->d[7] = 0;
-}
-#endif
-
-SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b) {
- return ((a->d[0] ^ b->d[0]) | (a->d[1] ^ b->d[1]) | (a->d[2] ^ b->d[2]) | (a->d[3] ^ b->d[3]) | (a->d[4] ^ b->d[4]) | (a->d[5] ^ b->d[5]) | (a->d[6] ^ b->d[6]) | (a->d[7] ^ b->d[7])) == 0;
-}
-
-SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift) {
- uint32_t l[16];
- unsigned int shiftlimbs;
- unsigned int shiftlow;
- unsigned int shifthigh;
- VERIFY_CHECK(shift >= 256);
- secp256k1_scalar_mul_512(l, a, b);
- shiftlimbs = shift >> 5;
- shiftlow = shift & 0x1F;
- shifthigh = 32 - shiftlow;
- r->d[0] = shift < 512 ? (l[0 + shiftlimbs] >> shiftlow | (shift < 480 && shiftlow ? (l[1 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[1] = shift < 480 ? (l[1 + shiftlimbs] >> shiftlow | (shift < 448 && shiftlow ? (l[2 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[2] = shift < 448 ? (l[2 + shiftlimbs] >> shiftlow | (shift < 416 && shiftlow ? (l[3 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[3] = shift < 416 ? (l[3 + shiftlimbs] >> shiftlow | (shift < 384 && shiftlow ? (l[4 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[4] = shift < 384 ? (l[4 + shiftlimbs] >> shiftlow | (shift < 352 && shiftlow ? (l[5 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[5] = shift < 352 ? (l[5 + shiftlimbs] >> shiftlow | (shift < 320 && shiftlow ? (l[6 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[6] = shift < 320 ? (l[6 + shiftlimbs] >> shiftlow | (shift < 288 && shiftlow ? (l[7 + shiftlimbs] << shifthigh) : 0)) : 0;
- r->d[7] = shift < 288 ? (l[7 + shiftlimbs] >> shiftlow) : 0;
- secp256k1_scalar_cadd_bit(r, 0, (l[(shift - 1) >> 5] >> ((shift - 1) & 0x1f)) & 1);
-}
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/scalar_impl.h b/crypto/secp256k1/libsecp256k1/src/scalar_impl.h
deleted file mode 100644
index f5b2376407..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/scalar_impl.h
+++ /dev/null
@@ -1,370 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_IMPL_H_
-#define _SECP256K1_SCALAR_IMPL_H_
-
-#include "group.h"
-#include "scalar.h"
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#if defined(EXHAUSTIVE_TEST_ORDER)
-#include "scalar_low_impl.h"
-#elif defined(USE_SCALAR_4X64)
-#include "scalar_4x64_impl.h"
-#elif defined(USE_SCALAR_8X32)
-#include "scalar_8x32_impl.h"
-#else
-#error "Please select scalar implementation"
-#endif
-
-#ifndef USE_NUM_NONE
-static void secp256k1_scalar_get_num(secp256k1_num *r, const secp256k1_scalar *a) {
- unsigned char c[32];
- secp256k1_scalar_get_b32(c, a);
- secp256k1_num_set_bin(r, c, 32);
-}
-
-/** secp256k1 curve order, see secp256k1_ecdsa_const_order_as_fe in ecdsa_impl.h */
-static void secp256k1_scalar_order_get_num(secp256k1_num *r) {
-#if defined(EXHAUSTIVE_TEST_ORDER)
- static const unsigned char order[32] = {
- 0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,EXHAUSTIVE_TEST_ORDER
- };
-#else
- static const unsigned char order[32] = {
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
- 0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,
- 0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x41
- };
-#endif
- secp256k1_num_set_bin(r, order, 32);
-}
-#endif
-
-static void secp256k1_scalar_inverse(secp256k1_scalar *r, const secp256k1_scalar *x) {
-#if defined(EXHAUSTIVE_TEST_ORDER)
- int i;
- *r = 0;
- for (i = 0; i < EXHAUSTIVE_TEST_ORDER; i++)
- if ((i * *x) % EXHAUSTIVE_TEST_ORDER == 1)
- *r = i;
- /* If this VERIFY_CHECK triggers we were given a noninvertible scalar (and thus
- * have a composite group order; fix it in exhaustive_tests.c). */
- VERIFY_CHECK(*r != 0);
-}
-#else
- secp256k1_scalar *t;
- int i;
- /* First compute x ^ (2^N - 1) for some values of N. */
- secp256k1_scalar x2, x3, x4, x6, x7, x8, x15, x30, x60, x120, x127;
-
- secp256k1_scalar_sqr(&x2, x);
- secp256k1_scalar_mul(&x2, &x2, x);
-
- secp256k1_scalar_sqr(&x3, &x2);
- secp256k1_scalar_mul(&x3, &x3, x);
-
- secp256k1_scalar_sqr(&x4, &x3);
- secp256k1_scalar_mul(&x4, &x4, x);
-
- secp256k1_scalar_sqr(&x6, &x4);
- secp256k1_scalar_sqr(&x6, &x6);
- secp256k1_scalar_mul(&x6, &x6, &x2);
-
- secp256k1_scalar_sqr(&x7, &x6);
- secp256k1_scalar_mul(&x7, &x7, x);
-
- secp256k1_scalar_sqr(&x8, &x7);
- secp256k1_scalar_mul(&x8, &x8, x);
-
- secp256k1_scalar_sqr(&x15, &x8);
- for (i = 0; i < 6; i++) {
- secp256k1_scalar_sqr(&x15, &x15);
- }
- secp256k1_scalar_mul(&x15, &x15, &x7);
-
- secp256k1_scalar_sqr(&x30, &x15);
- for (i = 0; i < 14; i++) {
- secp256k1_scalar_sqr(&x30, &x30);
- }
- secp256k1_scalar_mul(&x30, &x30, &x15);
-
- secp256k1_scalar_sqr(&x60, &x30);
- for (i = 0; i < 29; i++) {
- secp256k1_scalar_sqr(&x60, &x60);
- }
- secp256k1_scalar_mul(&x60, &x60, &x30);
-
- secp256k1_scalar_sqr(&x120, &x60);
- for (i = 0; i < 59; i++) {
- secp256k1_scalar_sqr(&x120, &x120);
- }
- secp256k1_scalar_mul(&x120, &x120, &x60);
-
- secp256k1_scalar_sqr(&x127, &x120);
- for (i = 0; i < 6; i++) {
- secp256k1_scalar_sqr(&x127, &x127);
- }
- secp256k1_scalar_mul(&x127, &x127, &x7);
-
- /* Then accumulate the final result (t starts at x127). */
- t = &x127;
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 4; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x3); /* 111 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 4; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x3); /* 111 */
- for (i = 0; i < 3; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x2); /* 11 */
- for (i = 0; i < 4; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x3); /* 111 */
- for (i = 0; i < 5; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x3); /* 111 */
- for (i = 0; i < 4; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x2); /* 11 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 5; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x4); /* 1111 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 3; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 4; i++) { /* 000 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 10; i++) { /* 0000000 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x3); /* 111 */
- for (i = 0; i < 4; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x3); /* 111 */
- for (i = 0; i < 9; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x8); /* 11111111 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 3; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 3; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 5; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x4); /* 1111 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 5; i++) { /* 000 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x2); /* 11 */
- for (i = 0; i < 4; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x2); /* 11 */
- for (i = 0; i < 2; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 8; i++) { /* 000000 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x2); /* 11 */
- for (i = 0; i < 3; i++) { /* 0 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, &x2); /* 11 */
- for (i = 0; i < 3; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 6; i++) { /* 00000 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(t, t, x); /* 1 */
- for (i = 0; i < 8; i++) { /* 00 */
- secp256k1_scalar_sqr(t, t);
- }
- secp256k1_scalar_mul(r, t, &x6); /* 111111 */
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_even(const secp256k1_scalar *a) {
- return !(a->d[0] & 1);
-}
-#endif
-
-static void secp256k1_scalar_inverse_var(secp256k1_scalar *r, const secp256k1_scalar *x) {
-#if defined(USE_SCALAR_INV_BUILTIN)
- secp256k1_scalar_inverse(r, x);
-#elif defined(USE_SCALAR_INV_NUM)
- unsigned char b[32];
- secp256k1_num n, m;
- secp256k1_scalar t = *x;
- secp256k1_scalar_get_b32(b, &t);
- secp256k1_num_set_bin(&n, b, 32);
- secp256k1_scalar_order_get_num(&m);
- secp256k1_num_mod_inverse(&n, &n, &m);
- secp256k1_num_get_bin(b, 32, &n);
- secp256k1_scalar_set_b32(r, b, NULL);
- /* Verify that the inverse was computed correctly, without GMP code. */
- secp256k1_scalar_mul(&t, &t, r);
- CHECK(secp256k1_scalar_is_one(&t));
-#else
-#error "Please select scalar inverse implementation"
-#endif
-}
-
-#ifdef USE_ENDOMORPHISM
-#if defined(EXHAUSTIVE_TEST_ORDER)
-/**
- * Find k1 and k2 given k, such that k1 + k2 * lambda == k mod n; unlike in the
- * full case we don't bother making k1 and k2 be small, we just want them to be
- * nontrivial to get full test coverage for the exhaustive tests. We therefore
- * (arbitrarily) set k2 = k + 5 and k1 = k - k2 * lambda.
- */
-static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
- *r2 = (*a + 5) % EXHAUSTIVE_TEST_ORDER;
- *r1 = (*a + (EXHAUSTIVE_TEST_ORDER - *r2) * EXHAUSTIVE_TEST_LAMBDA) % EXHAUSTIVE_TEST_ORDER;
-}
-#else
-/**
- * The Secp256k1 curve has an endomorphism, where lambda * (x, y) = (beta * x, y), where
- * lambda is {0x53,0x63,0xad,0x4c,0xc0,0x5c,0x30,0xe0,0xa5,0x26,0x1c,0x02,0x88,0x12,0x64,0x5a,
- * 0x12,0x2e,0x22,0xea,0x20,0x81,0x66,0x78,0xdf,0x02,0x96,0x7c,0x1b,0x23,0xbd,0x72}
- *
- * "Guide to Elliptic Curve Cryptography" (Hankerson, Menezes, Vanstone) gives an algorithm
- * (algorithm 3.74) to find k1 and k2 given k, such that k1 + k2 * lambda == k mod n, and k1
- * and k2 have a small size.
- * It relies on constants a1, b1, a2, b2. These constants for the value of lambda above are:
- *
- * - a1 = {0x30,0x86,0xd2,0x21,0xa7,0xd4,0x6b,0xcd,0xe8,0x6c,0x90,0xe4,0x92,0x84,0xeb,0x15}
- * - b1 = -{0xe4,0x43,0x7e,0xd6,0x01,0x0e,0x88,0x28,0x6f,0x54,0x7f,0xa9,0x0a,0xbf,0xe4,0xc3}
- * - a2 = {0x01,0x14,0xca,0x50,0xf7,0xa8,0xe2,0xf3,0xf6,0x57,0xc1,0x10,0x8d,0x9d,0x44,0xcf,0xd8}
- * - b2 = {0x30,0x86,0xd2,0x21,0xa7,0xd4,0x6b,0xcd,0xe8,0x6c,0x90,0xe4,0x92,0x84,0xeb,0x15}
- *
- * The algorithm then computes c1 = round(b1 * k / n) and c2 = round(b2 * k / n), and gives
- * k1 = k - (c1*a1 + c2*a2) and k2 = -(c1*b1 + c2*b2). Instead, we use modular arithmetic, and
- * compute k1 as k - k2 * lambda, avoiding the need for constants a1 and a2.
- *
- * g1, g2 are precomputed constants used to replace division with a rounded multiplication
- * when decomposing the scalar for an endomorphism-based point multiplication.
- *
- * The possibility of using precomputed estimates is mentioned in "Guide to Elliptic Curve
- * Cryptography" (Hankerson, Menezes, Vanstone) in section 3.5.
- *
- * The derivation is described in the paper "Efficient Software Implementation of Public-Key
- * Cryptography on Sensor Networks Using the MSP430X Microcontroller" (Gouvea, Oliveira, Lopez),
- * Section 4.3 (here we use a somewhat higher-precision estimate):
- * d = a1*b2 - b1*a2
- * g1 = round((2^272)*b2/d)
- * g2 = round((2^272)*b1/d)
- *
- * (Note that 'd' is also equal to the curve order here because [a1,b1] and [a2,b2] are found
- * as outputs of the Extended Euclidean Algorithm on inputs 'order' and 'lambda').
- *
- * The function below splits a in r1 and r2, such that r1 + lambda * r2 == a (mod order).
- */
-
-static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
- secp256k1_scalar c1, c2;
- static const secp256k1_scalar minus_lambda = SECP256K1_SCALAR_CONST(
- 0xAC9C52B3UL, 0x3FA3CF1FUL, 0x5AD9E3FDUL, 0x77ED9BA4UL,
- 0xA880B9FCUL, 0x8EC739C2UL, 0xE0CFC810UL, 0xB51283CFUL
- );
- static const secp256k1_scalar minus_b1 = SECP256K1_SCALAR_CONST(
- 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,
- 0xE4437ED6UL, 0x010E8828UL, 0x6F547FA9UL, 0x0ABFE4C3UL
- );
- static const secp256k1_scalar minus_b2 = SECP256K1_SCALAR_CONST(
- 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL,
- 0x8A280AC5UL, 0x0774346DUL, 0xD765CDA8UL, 0x3DB1562CUL
- );
- static const secp256k1_scalar g1 = SECP256K1_SCALAR_CONST(
- 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00003086UL,
- 0xD221A7D4UL, 0x6BCDE86CUL, 0x90E49284UL, 0xEB153DABUL
- );
- static const secp256k1_scalar g2 = SECP256K1_SCALAR_CONST(
- 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x0000E443UL,
- 0x7ED6010EUL, 0x88286F54UL, 0x7FA90ABFUL, 0xE4C42212UL
- );
- VERIFY_CHECK(r1 != a);
- VERIFY_CHECK(r2 != a);
- /* these _var calls are constant time since the shift amount is constant */
- secp256k1_scalar_mul_shift_var(&c1, a, &g1, 272);
- secp256k1_scalar_mul_shift_var(&c2, a, &g2, 272);
- secp256k1_scalar_mul(&c1, &c1, &minus_b1);
- secp256k1_scalar_mul(&c2, &c2, &minus_b2);
- secp256k1_scalar_add(r2, &c1, &c2);
- secp256k1_scalar_mul(r1, r2, &minus_lambda);
- secp256k1_scalar_add(r1, r1, a);
-}
-#endif
-#endif
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/scalar_low.h b/crypto/secp256k1/libsecp256k1/src/scalar_low.h
deleted file mode 100644
index 5574c44c7a..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/scalar_low.h
+++ /dev/null
@@ -1,15 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_REPR_
-#define _SECP256K1_SCALAR_REPR_
-
-#include
-
-/** A scalar modulo the group order of the secp256k1 curve. */
-typedef uint32_t secp256k1_scalar;
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/scalar_low_impl.h b/crypto/secp256k1/libsecp256k1/src/scalar_low_impl.h
deleted file mode 100644
index 4f94441f49..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/scalar_low_impl.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2015 Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_SCALAR_REPR_IMPL_H_
-#define _SECP256K1_SCALAR_REPR_IMPL_H_
-
-#include "scalar.h"
-
-#include
-
-SECP256K1_INLINE static int secp256k1_scalar_is_even(const secp256k1_scalar *a) {
- return !(*a & 1);
-}
-
-SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) { *r = 0; }
-SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v) { *r = v; }
-
-SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
- if (offset < 32)
- return ((*a >> offset) & ((((uint32_t)1) << count) - 1));
- else
- return 0;
-}
-
-SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
- return secp256k1_scalar_get_bits(a, offset, count);
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar *a) { return *a >= EXHAUSTIVE_TEST_ORDER; }
-
-static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- *r = (*a + *b) % EXHAUSTIVE_TEST_ORDER;
- return *r < *b;
-}
-
-static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag) {
- if (flag && bit < 32)
- *r += (1 << bit);
-#ifdef VERIFY
- VERIFY_CHECK(secp256k1_scalar_check_overflow(r) == 0);
-#endif
-}
-
-static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow) {
- const int base = 0x100 % EXHAUSTIVE_TEST_ORDER;
- int i;
- *r = 0;
- for (i = 0; i < 32; i++) {
- *r = ((*r * base) + b32[i]) % EXHAUSTIVE_TEST_ORDER;
- }
- /* just deny overflow, it basically always happens */
- if (overflow) *overflow = 0;
-}
-
-static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a) {
- memset(bin, 0, 32);
- bin[28] = *a >> 24; bin[29] = *a >> 16; bin[30] = *a >> 8; bin[31] = *a;
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_scalar *a) {
- return *a == 0;
-}
-
-static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a) {
- if (*a == 0) {
- *r = 0;
- } else {
- *r = EXHAUSTIVE_TEST_ORDER - *a;
- }
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scalar *a) {
- return *a == 1;
-}
-
-static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
- return *a > EXHAUSTIVE_TEST_ORDER / 2;
-}
-
-static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
- if (flag) secp256k1_scalar_negate(r, r);
- return flag ? -1 : 1;
-}
-
-static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
- *r = (*a * *b) % EXHAUSTIVE_TEST_ORDER;
-}
-
-static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
- int ret;
- VERIFY_CHECK(n > 0);
- VERIFY_CHECK(n < 16);
- ret = *r & ((1 << n) - 1);
- *r >>= n;
- return ret;
-}
-
-static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a) {
- *r = (*a * *a) % EXHAUSTIVE_TEST_ORDER;
-}
-
-static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
- *r1 = *a;
- *r2 = 0;
-}
-
-SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b) {
- return *a == *b;
-}
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/secp256k1.c b/crypto/secp256k1/libsecp256k1/src/secp256k1.c
deleted file mode 100755
index 7d637bfad1..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/secp256k1.c
+++ /dev/null
@@ -1,559 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013-2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#include "include/secp256k1.h"
-
-#include "util.h"
-#include "num_impl.h"
-#include "field_impl.h"
-#include "scalar_impl.h"
-#include "group_impl.h"
-#include "ecmult_impl.h"
-#include "ecmult_const_impl.h"
-#include "ecmult_gen_impl.h"
-#include "ecdsa_impl.h"
-#include "eckey_impl.h"
-#include "hash_impl.h"
-
-#define ARG_CHECK(cond) do { \
- if (EXPECT(!(cond), 0)) { \
- secp256k1_callback_call(&ctx->illegal_callback, #cond); \
- return 0; \
- } \
-} while(0)
-
-static void default_illegal_callback_fn(const char* str, void* data) {
- fprintf(stderr, "[libsecp256k1] illegal argument: %s\n", str);
- abort();
-}
-
-static const secp256k1_callback default_illegal_callback = {
- default_illegal_callback_fn,
- NULL
-};
-
-static void default_error_callback_fn(const char* str, void* data) {
- fprintf(stderr, "[libsecp256k1] internal consistency check failed: %s\n", str);
- abort();
-}
-
-static const secp256k1_callback default_error_callback = {
- default_error_callback_fn,
- NULL
-};
-
-
-struct secp256k1_context_struct {
- secp256k1_ecmult_context ecmult_ctx;
- secp256k1_ecmult_gen_context ecmult_gen_ctx;
- secp256k1_callback illegal_callback;
- secp256k1_callback error_callback;
-};
-
-secp256k1_context* secp256k1_context_create(unsigned int flags) {
- secp256k1_context* ret = (secp256k1_context*)checked_malloc(&default_error_callback, sizeof(secp256k1_context));
- ret->illegal_callback = default_illegal_callback;
- ret->error_callback = default_error_callback;
-
- if (EXPECT((flags & SECP256K1_FLAGS_TYPE_MASK) != SECP256K1_FLAGS_TYPE_CONTEXT, 0)) {
- secp256k1_callback_call(&ret->illegal_callback,
- "Invalid flags");
- free(ret);
- return NULL;
- }
-
- secp256k1_ecmult_context_init(&ret->ecmult_ctx);
- secp256k1_ecmult_gen_context_init(&ret->ecmult_gen_ctx);
-
- if (flags & SECP256K1_FLAGS_BIT_CONTEXT_SIGN) {
- secp256k1_ecmult_gen_context_build(&ret->ecmult_gen_ctx, &ret->error_callback);
- }
- if (flags & SECP256K1_FLAGS_BIT_CONTEXT_VERIFY) {
- secp256k1_ecmult_context_build(&ret->ecmult_ctx, &ret->error_callback);
- }
-
- return ret;
-}
-
-secp256k1_context* secp256k1_context_clone(const secp256k1_context* ctx) {
- secp256k1_context* ret = (secp256k1_context*)checked_malloc(&ctx->error_callback, sizeof(secp256k1_context));
- ret->illegal_callback = ctx->illegal_callback;
- ret->error_callback = ctx->error_callback;
- secp256k1_ecmult_context_clone(&ret->ecmult_ctx, &ctx->ecmult_ctx, &ctx->error_callback);
- secp256k1_ecmult_gen_context_clone(&ret->ecmult_gen_ctx, &ctx->ecmult_gen_ctx, &ctx->error_callback);
- return ret;
-}
-
-void secp256k1_context_destroy(secp256k1_context* ctx) {
- if (ctx != NULL) {
- secp256k1_ecmult_context_clear(&ctx->ecmult_ctx);
- secp256k1_ecmult_gen_context_clear(&ctx->ecmult_gen_ctx);
-
- free(ctx);
- }
-}
-
-void secp256k1_context_set_illegal_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
- if (fun == NULL) {
- fun = default_illegal_callback_fn;
- }
- ctx->illegal_callback.fn = fun;
- ctx->illegal_callback.data = data;
-}
-
-void secp256k1_context_set_error_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
- if (fun == NULL) {
- fun = default_error_callback_fn;
- }
- ctx->error_callback.fn = fun;
- ctx->error_callback.data = data;
-}
-
-static int secp256k1_pubkey_load(const secp256k1_context* ctx, secp256k1_ge* ge, const secp256k1_pubkey* pubkey) {
- if (sizeof(secp256k1_ge_storage) == 64) {
- /* When the secp256k1_ge_storage type is exactly 64 byte, use its
- * representation inside secp256k1_pubkey, as conversion is very fast.
- * Note that secp256k1_pubkey_save must use the same representation. */
- secp256k1_ge_storage s;
- memcpy(&s, &pubkey->data[0], 64);
- secp256k1_ge_from_storage(ge, &s);
- } else {
- /* Otherwise, fall back to 32-byte big endian for X and Y. */
- secp256k1_fe x, y;
- secp256k1_fe_set_b32(&x, pubkey->data);
- secp256k1_fe_set_b32(&y, pubkey->data + 32);
- secp256k1_ge_set_xy(ge, &x, &y);
- }
- ARG_CHECK(!secp256k1_fe_is_zero(&ge->x));
- return 1;
-}
-
-static void secp256k1_pubkey_save(secp256k1_pubkey* pubkey, secp256k1_ge* ge) {
- if (sizeof(secp256k1_ge_storage) == 64) {
- secp256k1_ge_storage s;
- secp256k1_ge_to_storage(&s, ge);
- memcpy(&pubkey->data[0], &s, 64);
- } else {
- VERIFY_CHECK(!secp256k1_ge_is_infinity(ge));
- secp256k1_fe_normalize_var(&ge->x);
- secp256k1_fe_normalize_var(&ge->y);
- secp256k1_fe_get_b32(pubkey->data, &ge->x);
- secp256k1_fe_get_b32(pubkey->data + 32, &ge->y);
- }
-}
-
-int secp256k1_ec_pubkey_parse(const secp256k1_context* ctx, secp256k1_pubkey* pubkey, const unsigned char *input, size_t inputlen) {
- secp256k1_ge Q;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(pubkey != NULL);
- memset(pubkey, 0, sizeof(*pubkey));
- ARG_CHECK(input != NULL);
- if (!secp256k1_eckey_pubkey_parse(&Q, input, inputlen)) {
- return 0;
- }
- secp256k1_pubkey_save(pubkey, &Q);
- secp256k1_ge_clear(&Q);
- return 1;
-}
-
-int secp256k1_ec_pubkey_serialize(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_pubkey* pubkey, unsigned int flags) {
- secp256k1_ge Q;
- size_t len;
- int ret = 0;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(outputlen != NULL);
- ARG_CHECK(*outputlen >= ((flags & SECP256K1_FLAGS_BIT_COMPRESSION) ? 33 : 65));
- len = *outputlen;
- *outputlen = 0;
- ARG_CHECK(output != NULL);
- memset(output, 0, len);
- ARG_CHECK(pubkey != NULL);
- ARG_CHECK((flags & SECP256K1_FLAGS_TYPE_MASK) == SECP256K1_FLAGS_TYPE_COMPRESSION);
- if (secp256k1_pubkey_load(ctx, &Q, pubkey)) {
- ret = secp256k1_eckey_pubkey_serialize(&Q, output, &len, flags & SECP256K1_FLAGS_BIT_COMPRESSION);
- if (ret) {
- *outputlen = len;
- }
- }
- return ret;
-}
-
-static void secp256k1_ecdsa_signature_load(const secp256k1_context* ctx, secp256k1_scalar* r, secp256k1_scalar* s, const secp256k1_ecdsa_signature* sig) {
- (void)ctx;
- if (sizeof(secp256k1_scalar) == 32) {
- /* When the secp256k1_scalar type is exactly 32 byte, use its
- * representation inside secp256k1_ecdsa_signature, as conversion is very fast.
- * Note that secp256k1_ecdsa_signature_save must use the same representation. */
- memcpy(r, &sig->data[0], 32);
- memcpy(s, &sig->data[32], 32);
- } else {
- secp256k1_scalar_set_b32(r, &sig->data[0], NULL);
- secp256k1_scalar_set_b32(s, &sig->data[32], NULL);
- }
-}
-
-static void secp256k1_ecdsa_signature_save(secp256k1_ecdsa_signature* sig, const secp256k1_scalar* r, const secp256k1_scalar* s) {
- if (sizeof(secp256k1_scalar) == 32) {
- memcpy(&sig->data[0], r, 32);
- memcpy(&sig->data[32], s, 32);
- } else {
- secp256k1_scalar_get_b32(&sig->data[0], r);
- secp256k1_scalar_get_b32(&sig->data[32], s);
- }
-}
-
-int secp256k1_ecdsa_signature_parse_der(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
- secp256k1_scalar r, s;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(sig != NULL);
- ARG_CHECK(input != NULL);
-
- if (secp256k1_ecdsa_sig_parse(&r, &s, input, inputlen)) {
- secp256k1_ecdsa_signature_save(sig, &r, &s);
- return 1;
- } else {
- memset(sig, 0, sizeof(*sig));
- return 0;
- }
-}
-
-int secp256k1_ecdsa_signature_parse_compact(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char *input64) {
- secp256k1_scalar r, s;
- int ret = 1;
- int overflow = 0;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(sig != NULL);
- ARG_CHECK(input64 != NULL);
-
- secp256k1_scalar_set_b32(&r, &input64[0], &overflow);
- ret &= !overflow;
- secp256k1_scalar_set_b32(&s, &input64[32], &overflow);
- ret &= !overflow;
- if (ret) {
- secp256k1_ecdsa_signature_save(sig, &r, &s);
- } else {
- memset(sig, 0, sizeof(*sig));
- }
- return ret;
-}
-
-int secp256k1_ecdsa_signature_serialize_der(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_ecdsa_signature* sig) {
- secp256k1_scalar r, s;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(output != NULL);
- ARG_CHECK(outputlen != NULL);
- ARG_CHECK(sig != NULL);
-
- secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
- return secp256k1_ecdsa_sig_serialize(output, outputlen, &r, &s);
-}
-
-int secp256k1_ecdsa_signature_serialize_compact(const secp256k1_context* ctx, unsigned char *output64, const secp256k1_ecdsa_signature* sig) {
- secp256k1_scalar r, s;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(output64 != NULL);
- ARG_CHECK(sig != NULL);
-
- secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
- secp256k1_scalar_get_b32(&output64[0], &r);
- secp256k1_scalar_get_b32(&output64[32], &s);
- return 1;
-}
-
-int secp256k1_ecdsa_signature_normalize(const secp256k1_context* ctx, secp256k1_ecdsa_signature *sigout, const secp256k1_ecdsa_signature *sigin) {
- secp256k1_scalar r, s;
- int ret = 0;
-
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(sigin != NULL);
-
- secp256k1_ecdsa_signature_load(ctx, &r, &s, sigin);
- ret = secp256k1_scalar_is_high(&s);
- if (sigout != NULL) {
- if (ret) {
- secp256k1_scalar_negate(&s, &s);
- }
- secp256k1_ecdsa_signature_save(sigout, &r, &s);
- }
-
- return ret;
-}
-
-int secp256k1_ecdsa_verify(const secp256k1_context* ctx, const secp256k1_ecdsa_signature *sig, const unsigned char *msg32, const secp256k1_pubkey *pubkey) {
- secp256k1_ge q;
- secp256k1_scalar r, s;
- secp256k1_scalar m;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
- ARG_CHECK(msg32 != NULL);
- ARG_CHECK(sig != NULL);
- ARG_CHECK(pubkey != NULL);
-
- secp256k1_scalar_set_b32(&m, msg32, NULL);
- secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
- return (!secp256k1_scalar_is_high(&s) &&
- secp256k1_pubkey_load(ctx, &q, pubkey) &&
- secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &r, &s, &q, &m));
-}
-
-static int nonce_function_rfc6979(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
- unsigned char keydata[112];
- int keylen = 64;
- secp256k1_rfc6979_hmac_sha256_t rng;
- unsigned int i;
- /* We feed a byte array to the PRNG as input, consisting of:
- * - the private key (32 bytes) and message (32 bytes), see RFC 6979 3.2d.
- * - optionally 32 extra bytes of data, see RFC 6979 3.6 Additional Data.
- * - optionally 16 extra bytes with the algorithm name.
- * Because the arguments have distinct fixed lengths it is not possible for
- * different argument mixtures to emulate each other and result in the same
- * nonces.
- */
- memcpy(keydata, key32, 32);
- memcpy(keydata + 32, msg32, 32);
- if (data != NULL) {
- memcpy(keydata + 64, data, 32);
- keylen = 96;
- }
- if (algo16 != NULL) {
- memcpy(keydata + keylen, algo16, 16);
- keylen += 16;
- }
- secp256k1_rfc6979_hmac_sha256_initialize(&rng, keydata, keylen);
- memset(keydata, 0, sizeof(keydata));
- for (i = 0; i <= counter; i++) {
- secp256k1_rfc6979_hmac_sha256_generate(&rng, nonce32, 32);
- }
- secp256k1_rfc6979_hmac_sha256_finalize(&rng);
- return 1;
-}
-
-const secp256k1_nonce_function secp256k1_nonce_function_rfc6979 = nonce_function_rfc6979;
-const secp256k1_nonce_function secp256k1_nonce_function_default = nonce_function_rfc6979;
-
-int secp256k1_ecdsa_sign(const secp256k1_context* ctx, secp256k1_ecdsa_signature *signature, const unsigned char *msg32, const unsigned char *seckey, secp256k1_nonce_function noncefp, const void* noncedata) {
- secp256k1_scalar r, s;
- secp256k1_scalar sec, non, msg;
- int ret = 0;
- int overflow = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
- ARG_CHECK(msg32 != NULL);
- ARG_CHECK(signature != NULL);
- ARG_CHECK(seckey != NULL);
- if (noncefp == NULL) {
- noncefp = secp256k1_nonce_function_default;
- }
-
- secp256k1_scalar_set_b32(&sec, seckey, &overflow);
- /* Fail if the secret key is invalid. */
- if (!overflow && !secp256k1_scalar_is_zero(&sec)) {
- unsigned char nonce32[32];
- unsigned int count = 0;
- secp256k1_scalar_set_b32(&msg, msg32, NULL);
- while (1) {
- ret = noncefp(nonce32, msg32, seckey, NULL, (void*)noncedata, count);
- if (!ret) {
- break;
- }
- secp256k1_scalar_set_b32(&non, nonce32, &overflow);
- if (!overflow && !secp256k1_scalar_is_zero(&non)) {
- if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &r, &s, &sec, &msg, &non, NULL)) {
- break;
- }
- }
- count++;
- }
- memset(nonce32, 0, 32);
- secp256k1_scalar_clear(&msg);
- secp256k1_scalar_clear(&non);
- secp256k1_scalar_clear(&sec);
- }
- if (ret) {
- secp256k1_ecdsa_signature_save(signature, &r, &s);
- } else {
- memset(signature, 0, sizeof(*signature));
- }
- return ret;
-}
-
-int secp256k1_ec_seckey_verify(const secp256k1_context* ctx, const unsigned char *seckey) {
- secp256k1_scalar sec;
- int ret;
- int overflow;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(seckey != NULL);
-
- secp256k1_scalar_set_b32(&sec, seckey, &overflow);
- ret = !overflow && !secp256k1_scalar_is_zero(&sec);
- secp256k1_scalar_clear(&sec);
- return ret;
-}
-
-int secp256k1_ec_pubkey_create(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *seckey) {
- secp256k1_gej pj;
- secp256k1_ge p;
- secp256k1_scalar sec;
- int overflow;
- int ret = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(pubkey != NULL);
- memset(pubkey, 0, sizeof(*pubkey));
- ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
- ARG_CHECK(seckey != NULL);
-
- secp256k1_scalar_set_b32(&sec, seckey, &overflow);
- ret = (!overflow) & (!secp256k1_scalar_is_zero(&sec));
- if (ret) {
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pj, &sec);
- secp256k1_ge_set_gej(&p, &pj);
- secp256k1_pubkey_save(pubkey, &p);
- }
- secp256k1_scalar_clear(&sec);
- return ret;
-}
-
-int secp256k1_ec_privkey_tweak_add(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) {
- secp256k1_scalar term;
- secp256k1_scalar sec;
- int ret = 0;
- int overflow = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(seckey != NULL);
- ARG_CHECK(tweak != NULL);
-
- secp256k1_scalar_set_b32(&term, tweak, &overflow);
- secp256k1_scalar_set_b32(&sec, seckey, NULL);
-
- ret = !overflow && secp256k1_eckey_privkey_tweak_add(&sec, &term);
- memset(seckey, 0, 32);
- if (ret) {
- secp256k1_scalar_get_b32(seckey, &sec);
- }
-
- secp256k1_scalar_clear(&sec);
- secp256k1_scalar_clear(&term);
- return ret;
-}
-
-int secp256k1_ec_pubkey_tweak_add(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak) {
- secp256k1_ge p;
- secp256k1_scalar term;
- int ret = 0;
- int overflow = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
- ARG_CHECK(pubkey != NULL);
- ARG_CHECK(tweak != NULL);
-
- secp256k1_scalar_set_b32(&term, tweak, &overflow);
- ret = !overflow && secp256k1_pubkey_load(ctx, &p, pubkey);
- memset(pubkey, 0, sizeof(*pubkey));
- if (ret) {
- if (secp256k1_eckey_pubkey_tweak_add(&ctx->ecmult_ctx, &p, &term)) {
- secp256k1_pubkey_save(pubkey, &p);
- } else {
- ret = 0;
- }
- }
-
- return ret;
-}
-
-int secp256k1_ec_privkey_tweak_mul(const secp256k1_context* ctx, unsigned char *seckey, const unsigned char *tweak) {
- secp256k1_scalar factor;
- secp256k1_scalar sec;
- int ret = 0;
- int overflow = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(seckey != NULL);
- ARG_CHECK(tweak != NULL);
-
- secp256k1_scalar_set_b32(&factor, tweak, &overflow);
- secp256k1_scalar_set_b32(&sec, seckey, NULL);
- ret = !overflow && secp256k1_eckey_privkey_tweak_mul(&sec, &factor);
- memset(seckey, 0, 32);
- if (ret) {
- secp256k1_scalar_get_b32(seckey, &sec);
- }
-
- secp256k1_scalar_clear(&sec);
- secp256k1_scalar_clear(&factor);
- return ret;
-}
-
-int secp256k1_ec_pubkey_tweak_mul(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak) {
- secp256k1_ge p;
- secp256k1_scalar factor;
- int ret = 0;
- int overflow = 0;
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
- ARG_CHECK(pubkey != NULL);
- ARG_CHECK(tweak != NULL);
-
- secp256k1_scalar_set_b32(&factor, tweak, &overflow);
- ret = !overflow && secp256k1_pubkey_load(ctx, &p, pubkey);
- memset(pubkey, 0, sizeof(*pubkey));
- if (ret) {
- if (secp256k1_eckey_pubkey_tweak_mul(&ctx->ecmult_ctx, &p, &factor)) {
- secp256k1_pubkey_save(pubkey, &p);
- } else {
- ret = 0;
- }
- }
-
- return ret;
-}
-
-int secp256k1_context_randomize(secp256k1_context* ctx, const unsigned char *seed32) {
- VERIFY_CHECK(ctx != NULL);
- ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx));
- secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, seed32);
- return 1;
-}
-
-int secp256k1_ec_pubkey_combine(const secp256k1_context* ctx, secp256k1_pubkey *pubnonce, const secp256k1_pubkey * const *pubnonces, size_t n) {
- size_t i;
- secp256k1_gej Qj;
- secp256k1_ge Q;
-
- ARG_CHECK(pubnonce != NULL);
- memset(pubnonce, 0, sizeof(*pubnonce));
- ARG_CHECK(n >= 1);
- ARG_CHECK(pubnonces != NULL);
-
- secp256k1_gej_set_infinity(&Qj);
-
- for (i = 0; i < n; i++) {
- secp256k1_pubkey_load(ctx, &Q, pubnonces[i]);
- secp256k1_gej_add_ge(&Qj, &Qj, &Q);
- }
- if (secp256k1_gej_is_infinity(&Qj)) {
- return 0;
- }
- secp256k1_ge_set_gej(&Q, &Qj);
- secp256k1_pubkey_save(pubnonce, &Q);
- return 1;
-}
-
-#ifdef ENABLE_MODULE_ECDH
-# include "modules/ecdh/main_impl.h"
-#endif
-
-#ifdef ENABLE_MODULE_SCHNORR
-# include "modules/schnorr/main_impl.h"
-#endif
-
-#ifdef ENABLE_MODULE_RECOVERY
-# include "modules/recovery/main_impl.h"
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/testrand.h b/crypto/secp256k1/libsecp256k1/src/testrand.h
deleted file mode 100644
index f8efa93c7c..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/testrand.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_TESTRAND_H_
-#define _SECP256K1_TESTRAND_H_
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-/* A non-cryptographic RNG used only for test infrastructure. */
-
-/** Seed the pseudorandom number generator for testing. */
-SECP256K1_INLINE static void secp256k1_rand_seed(const unsigned char *seed16);
-
-/** Generate a pseudorandom number in the range [0..2**32-1]. */
-static uint32_t secp256k1_rand32(void);
-
-/** Generate a pseudorandom number in the range [0..2**bits-1]. Bits must be 1 or
- * more. */
-static uint32_t secp256k1_rand_bits(int bits);
-
-/** Generate a pseudorandom number in the range [0..range-1]. */
-static uint32_t secp256k1_rand_int(uint32_t range);
-
-/** Generate a pseudorandom 32-byte array. */
-static void secp256k1_rand256(unsigned char *b32);
-
-/** Generate a pseudorandom 32-byte array with long sequences of zero and one bits. */
-static void secp256k1_rand256_test(unsigned char *b32);
-
-/** Generate pseudorandom bytes with long sequences of zero and one bits. */
-static void secp256k1_rand_bytes_test(unsigned char *bytes, size_t len);
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/testrand_impl.h b/crypto/secp256k1/libsecp256k1/src/testrand_impl.h
deleted file mode 100644
index 15c7b9f12d..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/testrand_impl.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013-2015 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_TESTRAND_IMPL_H_
-#define _SECP256K1_TESTRAND_IMPL_H_
-
-#include
-#include
-
-#include "testrand.h"
-#include "hash.h"
-
-static secp256k1_rfc6979_hmac_sha256_t secp256k1_test_rng;
-static uint32_t secp256k1_test_rng_precomputed[8];
-static int secp256k1_test_rng_precomputed_used = 8;
-static uint64_t secp256k1_test_rng_integer;
-static int secp256k1_test_rng_integer_bits_left = 0;
-
-SECP256K1_INLINE static void secp256k1_rand_seed(const unsigned char *seed16) {
- secp256k1_rfc6979_hmac_sha256_initialize(&secp256k1_test_rng, seed16, 16);
-}
-
-SECP256K1_INLINE static uint32_t secp256k1_rand32(void) {
- if (secp256k1_test_rng_precomputed_used == 8) {
- secp256k1_rfc6979_hmac_sha256_generate(&secp256k1_test_rng, (unsigned char*)(&secp256k1_test_rng_precomputed[0]), sizeof(secp256k1_test_rng_precomputed));
- secp256k1_test_rng_precomputed_used = 0;
- }
- return secp256k1_test_rng_precomputed[secp256k1_test_rng_precomputed_used++];
-}
-
-static uint32_t secp256k1_rand_bits(int bits) {
- uint32_t ret;
- if (secp256k1_test_rng_integer_bits_left < bits) {
- secp256k1_test_rng_integer |= (((uint64_t)secp256k1_rand32()) << secp256k1_test_rng_integer_bits_left);
- secp256k1_test_rng_integer_bits_left += 32;
- }
- ret = secp256k1_test_rng_integer;
- secp256k1_test_rng_integer >>= bits;
- secp256k1_test_rng_integer_bits_left -= bits;
- ret &= ((~((uint32_t)0)) >> (32 - bits));
- return ret;
-}
-
-static uint32_t secp256k1_rand_int(uint32_t range) {
- /* We want a uniform integer between 0 and range-1, inclusive.
- * B is the smallest number such that range <= 2**B.
- * two mechanisms implemented here:
- * - generate B bits numbers until one below range is found, and return it
- * - find the largest multiple M of range that is <= 2**(B+A), generate B+A
- * bits numbers until one below M is found, and return it modulo range
- * The second mechanism consumes A more bits of entropy in every iteration,
- * but may need fewer iterations due to M being closer to 2**(B+A) then
- * range is to 2**B. The array below (indexed by B) contains a 0 when the
- * first mechanism is to be used, and the number A otherwise.
- */
- static const int addbits[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0};
- uint32_t trange, mult;
- int bits = 0;
- if (range <= 1) {
- return 0;
- }
- trange = range - 1;
- while (trange > 0) {
- trange >>= 1;
- bits++;
- }
- if (addbits[bits]) {
- bits = bits + addbits[bits];
- mult = ((~((uint32_t)0)) >> (32 - bits)) / range;
- trange = range * mult;
- } else {
- trange = range;
- mult = 1;
- }
- while(1) {
- uint32_t x = secp256k1_rand_bits(bits);
- if (x < trange) {
- return (mult == 1) ? x : (x % range);
- }
- }
-}
-
-static void secp256k1_rand256(unsigned char *b32) {
- secp256k1_rfc6979_hmac_sha256_generate(&secp256k1_test_rng, b32, 32);
-}
-
-static void secp256k1_rand_bytes_test(unsigned char *bytes, size_t len) {
- size_t bits = 0;
- memset(bytes, 0, len);
- while (bits < len * 8) {
- int now;
- uint32_t val;
- now = 1 + (secp256k1_rand_bits(6) * secp256k1_rand_bits(5) + 16) / 31;
- val = secp256k1_rand_bits(1);
- while (now > 0 && bits < len * 8) {
- bytes[bits / 8] |= val << (bits % 8);
- now--;
- bits++;
- }
- }
-}
-
-static void secp256k1_rand256_test(unsigned char *b32) {
- secp256k1_rand_bytes_test(b32, 32);
-}
-
-#endif
diff --git a/crypto/secp256k1/libsecp256k1/src/tests.c b/crypto/secp256k1/libsecp256k1/src/tests.c
deleted file mode 100644
index 9ae7d30281..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/tests.c
+++ /dev/null
@@ -1,4525 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014, 2015 Pieter Wuille, Gregory Maxwell *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#include
-#include
-
-#include
-
-#include "secp256k1.c"
-#include "include/secp256k1.h"
-#include "testrand_impl.h"
-
-#ifdef ENABLE_OPENSSL_TESTS
-#include "openssl/bn.h"
-#include "openssl/ec.h"
-#include "openssl/ecdsa.h"
-#include "openssl/obj_mac.h"
-#endif
-
-#include "contrib/lax_der_parsing.c"
-#include "contrib/lax_der_privatekey_parsing.c"
-
-#if !defined(VG_CHECK)
-# if defined(VALGRIND)
-# include
-# define VG_UNDEF(x,y) VALGRIND_MAKE_MEM_UNDEFINED((x),(y))
-# define VG_CHECK(x,y) VALGRIND_CHECK_MEM_IS_DEFINED((x),(y))
-# else
-# define VG_UNDEF(x,y)
-# define VG_CHECK(x,y)
-# endif
-#endif
-
-static int count = 64;
-static secp256k1_context *ctx = NULL;
-
-static void counting_illegal_callback_fn(const char* str, void* data) {
- /* Dummy callback function that just counts. */
- int32_t *p;
- (void)str;
- p = data;
- (*p)++;
-}
-
-static void uncounting_illegal_callback_fn(const char* str, void* data) {
- /* Dummy callback function that just counts (backwards). */
- int32_t *p;
- (void)str;
- p = data;
- (*p)--;
-}
-
-void random_field_element_test(secp256k1_fe *fe) {
- do {
- unsigned char b32[32];
- secp256k1_rand256_test(b32);
- if (secp256k1_fe_set_b32(fe, b32)) {
- break;
- }
- } while(1);
-}
-
-void random_field_element_magnitude(secp256k1_fe *fe) {
- secp256k1_fe zero;
- int n = secp256k1_rand_int(9);
- secp256k1_fe_normalize(fe);
- if (n == 0) {
- return;
- }
- secp256k1_fe_clear(&zero);
- secp256k1_fe_negate(&zero, &zero, 0);
- secp256k1_fe_mul_int(&zero, n - 1);
- secp256k1_fe_add(fe, &zero);
- VERIFY_CHECK(fe->magnitude == n);
-}
-
-void random_group_element_test(secp256k1_ge *ge) {
- secp256k1_fe fe;
- do {
- random_field_element_test(&fe);
- if (secp256k1_ge_set_xo_var(ge, &fe, secp256k1_rand_bits(1))) {
- secp256k1_fe_normalize(&ge->y);
- break;
- }
- } while(1);
-}
-
-void random_group_element_jacobian_test(secp256k1_gej *gej, const secp256k1_ge *ge) {
- secp256k1_fe z2, z3;
- do {
- random_field_element_test(&gej->z);
- if (!secp256k1_fe_is_zero(&gej->z)) {
- break;
- }
- } while(1);
- secp256k1_fe_sqr(&z2, &gej->z);
- secp256k1_fe_mul(&z3, &z2, &gej->z);
- secp256k1_fe_mul(&gej->x, &ge->x, &z2);
- secp256k1_fe_mul(&gej->y, &ge->y, &z3);
- gej->infinity = ge->infinity;
-}
-
-void random_scalar_order_test(secp256k1_scalar *num) {
- do {
- unsigned char b32[32];
- int overflow = 0;
- secp256k1_rand256_test(b32);
- secp256k1_scalar_set_b32(num, b32, &overflow);
- if (overflow || secp256k1_scalar_is_zero(num)) {
- continue;
- }
- break;
- } while(1);
-}
-
-void random_scalar_order(secp256k1_scalar *num) {
- do {
- unsigned char b32[32];
- int overflow = 0;
- secp256k1_rand256(b32);
- secp256k1_scalar_set_b32(num, b32, &overflow);
- if (overflow || secp256k1_scalar_is_zero(num)) {
- continue;
- }
- break;
- } while(1);
-}
-
-void run_context_tests(void) {
- secp256k1_pubkey pubkey;
- secp256k1_ecdsa_signature sig;
- unsigned char ctmp[32];
- int32_t ecount;
- int32_t ecount2;
- secp256k1_context *none = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
- secp256k1_context *sign = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
- secp256k1_context *vrfy = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);
- secp256k1_context *both = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
-
- secp256k1_gej pubj;
- secp256k1_ge pub;
- secp256k1_scalar msg, key, nonce;
- secp256k1_scalar sigr, sigs;
-
- ecount = 0;
- ecount2 = 10;
- secp256k1_context_set_illegal_callback(vrfy, counting_illegal_callback_fn, &ecount);
- secp256k1_context_set_illegal_callback(sign, counting_illegal_callback_fn, &ecount2);
- secp256k1_context_set_error_callback(sign, counting_illegal_callback_fn, NULL);
- CHECK(vrfy->error_callback.fn != sign->error_callback.fn);
-
- /*** clone and destroy all of them to make sure cloning was complete ***/
- {
- secp256k1_context *ctx_tmp;
-
- ctx_tmp = none; none = secp256k1_context_clone(none); secp256k1_context_destroy(ctx_tmp);
- ctx_tmp = sign; sign = secp256k1_context_clone(sign); secp256k1_context_destroy(ctx_tmp);
- ctx_tmp = vrfy; vrfy = secp256k1_context_clone(vrfy); secp256k1_context_destroy(ctx_tmp);
- ctx_tmp = both; both = secp256k1_context_clone(both); secp256k1_context_destroy(ctx_tmp);
- }
-
- /* Verify that the error callback makes it across the clone. */
- CHECK(vrfy->error_callback.fn != sign->error_callback.fn);
- /* And that it resets back to default. */
- secp256k1_context_set_error_callback(sign, NULL, NULL);
- CHECK(vrfy->error_callback.fn == sign->error_callback.fn);
-
- /*** attempt to use them ***/
- random_scalar_order_test(&msg);
- random_scalar_order_test(&key);
- secp256k1_ecmult_gen(&both->ecmult_gen_ctx, &pubj, &key);
- secp256k1_ge_set_gej(&pub, &pubj);
-
- /* Verify context-type checking illegal-argument errors. */
- memset(ctmp, 1, 32);
- CHECK(secp256k1_ec_pubkey_create(vrfy, &pubkey, ctmp) == 0);
- CHECK(ecount == 1);
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(sign, &pubkey, ctmp) == 1);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ecdsa_sign(vrfy, &sig, ctmp, ctmp, NULL, NULL) == 0);
- CHECK(ecount == 2);
- VG_UNDEF(&sig, sizeof(sig));
- CHECK(secp256k1_ecdsa_sign(sign, &sig, ctmp, ctmp, NULL, NULL) == 1);
- VG_CHECK(&sig, sizeof(sig));
- CHECK(ecount2 == 10);
- CHECK(secp256k1_ecdsa_verify(sign, &sig, ctmp, &pubkey) == 0);
- CHECK(ecount2 == 11);
- CHECK(secp256k1_ecdsa_verify(vrfy, &sig, ctmp, &pubkey) == 1);
- CHECK(ecount == 2);
- CHECK(secp256k1_ec_pubkey_tweak_add(sign, &pubkey, ctmp) == 0);
- CHECK(ecount2 == 12);
- CHECK(secp256k1_ec_pubkey_tweak_add(vrfy, &pubkey, ctmp) == 1);
- CHECK(ecount == 2);
- CHECK(secp256k1_ec_pubkey_tweak_mul(sign, &pubkey, ctmp) == 0);
- CHECK(ecount2 == 13);
- CHECK(secp256k1_ec_pubkey_tweak_mul(vrfy, &pubkey, ctmp) == 1);
- CHECK(ecount == 2);
- CHECK(secp256k1_context_randomize(vrfy, ctmp) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_context_randomize(sign, NULL) == 1);
- CHECK(ecount2 == 13);
- secp256k1_context_set_illegal_callback(vrfy, NULL, NULL);
- secp256k1_context_set_illegal_callback(sign, NULL, NULL);
-
- /* This shouldn't leak memory, due to already-set tests. */
- secp256k1_ecmult_gen_context_build(&sign->ecmult_gen_ctx, NULL);
- secp256k1_ecmult_context_build(&vrfy->ecmult_ctx, NULL);
-
- /* obtain a working nonce */
- do {
- random_scalar_order_test(&nonce);
- } while(!secp256k1_ecdsa_sig_sign(&both->ecmult_gen_ctx, &sigr, &sigs, &key, &msg, &nonce, NULL));
-
- /* try signing */
- CHECK(secp256k1_ecdsa_sig_sign(&sign->ecmult_gen_ctx, &sigr, &sigs, &key, &msg, &nonce, NULL));
- CHECK(secp256k1_ecdsa_sig_sign(&both->ecmult_gen_ctx, &sigr, &sigs, &key, &msg, &nonce, NULL));
-
- /* try verifying */
- CHECK(secp256k1_ecdsa_sig_verify(&vrfy->ecmult_ctx, &sigr, &sigs, &pub, &msg));
- CHECK(secp256k1_ecdsa_sig_verify(&both->ecmult_ctx, &sigr, &sigs, &pub, &msg));
-
- /* cleanup */
- secp256k1_context_destroy(none);
- secp256k1_context_destroy(sign);
- secp256k1_context_destroy(vrfy);
- secp256k1_context_destroy(both);
- /* Defined as no-op. */
- secp256k1_context_destroy(NULL);
-}
-
-/***** HASH TESTS *****/
-
-void run_sha256_tests(void) {
- static const char *inputs[8] = {
- "", "abc", "message digest", "secure hash algorithm", "SHA256 is considered to be safe",
- "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
- "For this sample, this 63-byte string will be used as input data",
- "This is exactly 64 bytes long, not counting the terminating byte"
- };
- static const unsigned char outputs[8][32] = {
- {0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55},
- {0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad},
- {0xf7, 0x84, 0x6f, 0x55, 0xcf, 0x23, 0xe1, 0x4e, 0xeb, 0xea, 0xb5, 0xb4, 0xe1, 0x55, 0x0c, 0xad, 0x5b, 0x50, 0x9e, 0x33, 0x48, 0xfb, 0xc4, 0xef, 0xa3, 0xa1, 0x41, 0x3d, 0x39, 0x3c, 0xb6, 0x50},
- {0xf3, 0x0c, 0xeb, 0x2b, 0xb2, 0x82, 0x9e, 0x79, 0xe4, 0xca, 0x97, 0x53, 0xd3, 0x5a, 0x8e, 0xcc, 0x00, 0x26, 0x2d, 0x16, 0x4c, 0xc0, 0x77, 0x08, 0x02, 0x95, 0x38, 0x1c, 0xbd, 0x64, 0x3f, 0x0d},
- {0x68, 0x19, 0xd9, 0x15, 0xc7, 0x3f, 0x4d, 0x1e, 0x77, 0xe4, 0xe1, 0xb5, 0x2d, 0x1f, 0xa0, 0xf9, 0xcf, 0x9b, 0xea, 0xea, 0xd3, 0x93, 0x9f, 0x15, 0x87, 0x4b, 0xd9, 0x88, 0xe2, 0xa2, 0x36, 0x30},
- {0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8, 0xe5, 0xc0, 0x26, 0x93, 0x0c, 0x3e, 0x60, 0x39, 0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67, 0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1},
- {0xf0, 0x8a, 0x78, 0xcb, 0xba, 0xee, 0x08, 0x2b, 0x05, 0x2a, 0xe0, 0x70, 0x8f, 0x32, 0xfa, 0x1e, 0x50, 0xc5, 0xc4, 0x21, 0xaa, 0x77, 0x2b, 0xa5, 0xdb, 0xb4, 0x06, 0xa2, 0xea, 0x6b, 0xe3, 0x42},
- {0xab, 0x64, 0xef, 0xf7, 0xe8, 0x8e, 0x2e, 0x46, 0x16, 0x5e, 0x29, 0xf2, 0xbc, 0xe4, 0x18, 0x26, 0xbd, 0x4c, 0x7b, 0x35, 0x52, 0xf6, 0xb3, 0x82, 0xa9, 0xe7, 0xd3, 0xaf, 0x47, 0xc2, 0x45, 0xf8}
- };
- int i;
- for (i = 0; i < 8; i++) {
- unsigned char out[32];
- secp256k1_sha256_t hasher;
- secp256k1_sha256_initialize(&hasher);
- secp256k1_sha256_write(&hasher, (const unsigned char*)(inputs[i]), strlen(inputs[i]));
- secp256k1_sha256_finalize(&hasher, out);
- CHECK(memcmp(out, outputs[i], 32) == 0);
- if (strlen(inputs[i]) > 0) {
- int split = secp256k1_rand_int(strlen(inputs[i]));
- secp256k1_sha256_initialize(&hasher);
- secp256k1_sha256_write(&hasher, (const unsigned char*)(inputs[i]), split);
- secp256k1_sha256_write(&hasher, (const unsigned char*)(inputs[i] + split), strlen(inputs[i]) - split);
- secp256k1_sha256_finalize(&hasher, out);
- CHECK(memcmp(out, outputs[i], 32) == 0);
- }
- }
-}
-
-void run_hmac_sha256_tests(void) {
- static const char *keys[6] = {
- "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
- "\x4a\x65\x66\x65",
- "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
- "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
- "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
- "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
- };
- static const char *inputs[6] = {
- "\x48\x69\x20\x54\x68\x65\x72\x65",
- "\x77\x68\x61\x74\x20\x64\x6f\x20\x79\x61\x20\x77\x61\x6e\x74\x20\x66\x6f\x72\x20\x6e\x6f\x74\x68\x69\x6e\x67\x3f",
- "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd",
- "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd",
- "\x54\x65\x73\x74\x20\x55\x73\x69\x6e\x67\x20\x4c\x61\x72\x67\x65\x72\x20\x54\x68\x61\x6e\x20\x42\x6c\x6f\x63\x6b\x2d\x53\x69\x7a\x65\x20\x4b\x65\x79\x20\x2d\x20\x48\x61\x73\x68\x20\x4b\x65\x79\x20\x46\x69\x72\x73\x74",
- "\x54\x68\x69\x73\x20\x69\x73\x20\x61\x20\x74\x65\x73\x74\x20\x75\x73\x69\x6e\x67\x20\x61\x20\x6c\x61\x72\x67\x65\x72\x20\x74\x68\x61\x6e\x20\x62\x6c\x6f\x63\x6b\x2d\x73\x69\x7a\x65\x20\x6b\x65\x79\x20\x61\x6e\x64\x20\x61\x20\x6c\x61\x72\x67\x65\x72\x20\x74\x68\x61\x6e\x20\x62\x6c\x6f\x63\x6b\x2d\x73\x69\x7a\x65\x20\x64\x61\x74\x61\x2e\x20\x54\x68\x65\x20\x6b\x65\x79\x20\x6e\x65\x65\x64\x73\x20\x74\x6f\x20\x62\x65\x20\x68\x61\x73\x68\x65\x64\x20\x62\x65\x66\x6f\x72\x65\x20\x62\x65\x69\x6e\x67\x20\x75\x73\x65\x64\x20\x62\x79\x20\x74\x68\x65\x20\x48\x4d\x41\x43\x20\x61\x6c\x67\x6f\x72\x69\x74\x68\x6d\x2e"
- };
- static const unsigned char outputs[6][32] = {
- {0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53, 0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b, 0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7, 0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7},
- {0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e, 0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7, 0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83, 0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43},
- {0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46, 0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7, 0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22, 0xd9, 0x63, 0x55, 0x14, 0xce, 0xd5, 0x65, 0xfe},
- {0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e, 0xa4, 0xcc, 0x81, 0x98, 0x99, 0xf2, 0x08, 0x3a, 0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07, 0x7a, 0x2e, 0x3f, 0xf4, 0x67, 0x29, 0x66, 0x5b},
- {0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f, 0x0d, 0x8a, 0x26, 0xaa, 0xcb, 0xf5, 0xb7, 0x7f, 0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14, 0x05, 0x46, 0x04, 0x0f, 0x0e, 0xe3, 0x7f, 0x54},
- {0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb, 0x27, 0x63, 0x5f, 0xbc, 0xd5, 0xb0, 0xe9, 0x44, 0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93, 0x8a, 0x7f, 0x51, 0x53, 0x5c, 0x3a, 0x35, 0xe2}
- };
- int i;
- for (i = 0; i < 6; i++) {
- secp256k1_hmac_sha256_t hasher;
- unsigned char out[32];
- secp256k1_hmac_sha256_initialize(&hasher, (const unsigned char*)(keys[i]), strlen(keys[i]));
- secp256k1_hmac_sha256_write(&hasher, (const unsigned char*)(inputs[i]), strlen(inputs[i]));
- secp256k1_hmac_sha256_finalize(&hasher, out);
- CHECK(memcmp(out, outputs[i], 32) == 0);
- if (strlen(inputs[i]) > 0) {
- int split = secp256k1_rand_int(strlen(inputs[i]));
- secp256k1_hmac_sha256_initialize(&hasher, (const unsigned char*)(keys[i]), strlen(keys[i]));
- secp256k1_hmac_sha256_write(&hasher, (const unsigned char*)(inputs[i]), split);
- secp256k1_hmac_sha256_write(&hasher, (const unsigned char*)(inputs[i] + split), strlen(inputs[i]) - split);
- secp256k1_hmac_sha256_finalize(&hasher, out);
- CHECK(memcmp(out, outputs[i], 32) == 0);
- }
- }
-}
-
-void run_rfc6979_hmac_sha256_tests(void) {
- static const unsigned char key1[65] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x00, 0x4b, 0xf5, 0x12, 0x2f, 0x34, 0x45, 0x54, 0xc5, 0x3b, 0xde, 0x2e, 0xbb, 0x8c, 0xd2, 0xb7, 0xe3, 0xd1, 0x60, 0x0a, 0xd6, 0x31, 0xc3, 0x85, 0xa5, 0xd7, 0xcc, 0xe2, 0x3c, 0x77, 0x85, 0x45, 0x9a, 0};
- static const unsigned char out1[3][32] = {
- {0x4f, 0xe2, 0x95, 0x25, 0xb2, 0x08, 0x68, 0x09, 0x15, 0x9a, 0xcd, 0xf0, 0x50, 0x6e, 0xfb, 0x86, 0xb0, 0xec, 0x93, 0x2c, 0x7b, 0xa4, 0x42, 0x56, 0xab, 0x32, 0x1e, 0x42, 0x1e, 0x67, 0xe9, 0xfb},
- {0x2b, 0xf0, 0xff, 0xf1, 0xd3, 0xc3, 0x78, 0xa2, 0x2d, 0xc5, 0xde, 0x1d, 0x85, 0x65, 0x22, 0x32, 0x5c, 0x65, 0xb5, 0x04, 0x49, 0x1a, 0x0c, 0xbd, 0x01, 0xcb, 0x8f, 0x3a, 0xa6, 0x7f, 0xfd, 0x4a},
- {0xf5, 0x28, 0xb4, 0x10, 0xcb, 0x54, 0x1f, 0x77, 0x00, 0x0d, 0x7a, 0xfb, 0x6c, 0x5b, 0x53, 0xc5, 0xc4, 0x71, 0xea, 0xb4, 0x3e, 0x46, 0x6d, 0x9a, 0xc5, 0x19, 0x0c, 0x39, 0xc8, 0x2f, 0xd8, 0x2e}
- };
-
- static const unsigned char key2[64] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55};
- static const unsigned char out2[3][32] = {
- {0x9c, 0x23, 0x6c, 0x16, 0x5b, 0x82, 0xae, 0x0c, 0xd5, 0x90, 0x65, 0x9e, 0x10, 0x0b, 0x6b, 0xab, 0x30, 0x36, 0xe7, 0xba, 0x8b, 0x06, 0x74, 0x9b, 0xaf, 0x69, 0x81, 0xe1, 0x6f, 0x1a, 0x2b, 0x95},
- {0xdf, 0x47, 0x10, 0x61, 0x62, 0x5b, 0xc0, 0xea, 0x14, 0xb6, 0x82, 0xfe, 0xee, 0x2c, 0x9c, 0x02, 0xf2, 0x35, 0xda, 0x04, 0x20, 0x4c, 0x1d, 0x62, 0xa1, 0x53, 0x6c, 0x6e, 0x17, 0xae, 0xd7, 0xa9},
- {0x75, 0x97, 0x88, 0x7c, 0xbd, 0x76, 0x32, 0x1f, 0x32, 0xe3, 0x04, 0x40, 0x67, 0x9a, 0x22, 0xcf, 0x7f, 0x8d, 0x9d, 0x2e, 0xac, 0x39, 0x0e, 0x58, 0x1f, 0xea, 0x09, 0x1c, 0xe2, 0x02, 0xba, 0x94}
- };
-
- secp256k1_rfc6979_hmac_sha256_t rng;
- unsigned char out[32];
- int i;
-
- secp256k1_rfc6979_hmac_sha256_initialize(&rng, key1, 64);
- for (i = 0; i < 3; i++) {
- secp256k1_rfc6979_hmac_sha256_generate(&rng, out, 32);
- CHECK(memcmp(out, out1[i], 32) == 0);
- }
- secp256k1_rfc6979_hmac_sha256_finalize(&rng);
-
- secp256k1_rfc6979_hmac_sha256_initialize(&rng, key1, 65);
- for (i = 0; i < 3; i++) {
- secp256k1_rfc6979_hmac_sha256_generate(&rng, out, 32);
- CHECK(memcmp(out, out1[i], 32) != 0);
- }
- secp256k1_rfc6979_hmac_sha256_finalize(&rng);
-
- secp256k1_rfc6979_hmac_sha256_initialize(&rng, key2, 64);
- for (i = 0; i < 3; i++) {
- secp256k1_rfc6979_hmac_sha256_generate(&rng, out, 32);
- CHECK(memcmp(out, out2[i], 32) == 0);
- }
- secp256k1_rfc6979_hmac_sha256_finalize(&rng);
-}
-
-/***** RANDOM TESTS *****/
-
-void test_rand_bits(int rand32, int bits) {
- /* (1-1/2^B)^rounds[B] < 1/10^9, so rounds is the number of iterations to
- * get a false negative chance below once in a billion */
- static const unsigned int rounds[7] = {1, 30, 73, 156, 322, 653, 1316};
- /* We try multiplying the results with various odd numbers, which shouldn't
- * influence the uniform distribution modulo a power of 2. */
- static const uint32_t mults[6] = {1, 3, 21, 289, 0x9999, 0x80402011};
- /* We only select up to 6 bits from the output to analyse */
- unsigned int usebits = bits > 6 ? 6 : bits;
- unsigned int maxshift = bits - usebits;
- /* For each of the maxshift+1 usebits-bit sequences inside a bits-bit
- number, track all observed outcomes, one per bit in a uint64_t. */
- uint64_t x[6][27] = {{0}};
- unsigned int i, shift, m;
- /* Multiply the output of all rand calls with the odd number m, which
- should not change the uniformity of its distribution. */
- for (i = 0; i < rounds[usebits]; i++) {
- uint32_t r = (rand32 ? secp256k1_rand32() : secp256k1_rand_bits(bits));
- CHECK((((uint64_t)r) >> bits) == 0);
- for (m = 0; m < sizeof(mults) / sizeof(mults[0]); m++) {
- uint32_t rm = r * mults[m];
- for (shift = 0; shift <= maxshift; shift++) {
- x[m][shift] |= (((uint64_t)1) << ((rm >> shift) & ((1 << usebits) - 1)));
- }
- }
- }
- for (m = 0; m < sizeof(mults) / sizeof(mults[0]); m++) {
- for (shift = 0; shift <= maxshift; shift++) {
- /* Test that the lower usebits bits of x[shift] are 1 */
- CHECK(((~x[m][shift]) << (64 - (1 << usebits))) == 0);
- }
- }
-}
-
-/* Subrange must be a whole divisor of range, and at most 64 */
-void test_rand_int(uint32_t range, uint32_t subrange) {
- /* (1-1/subrange)^rounds < 1/10^9 */
- int rounds = (subrange * 2073) / 100;
- int i;
- uint64_t x = 0;
- CHECK((range % subrange) == 0);
- for (i = 0; i < rounds; i++) {
- uint32_t r = secp256k1_rand_int(range);
- CHECK(r < range);
- r = r % subrange;
- x |= (((uint64_t)1) << r);
- }
- /* Test that the lower subrange bits of x are 1. */
- CHECK(((~x) << (64 - subrange)) == 0);
-}
-
-void run_rand_bits(void) {
- size_t b;
- test_rand_bits(1, 32);
- for (b = 1; b <= 32; b++) {
- test_rand_bits(0, b);
- }
-}
-
-void run_rand_int(void) {
- static const uint32_t ms[] = {1, 3, 17, 1000, 13771, 999999, 33554432};
- static const uint32_t ss[] = {1, 3, 6, 9, 13, 31, 64};
- unsigned int m, s;
- for (m = 0; m < sizeof(ms) / sizeof(ms[0]); m++) {
- for (s = 0; s < sizeof(ss) / sizeof(ss[0]); s++) {
- test_rand_int(ms[m] * ss[s], ss[s]);
- }
- }
-}
-
-/***** NUM TESTS *****/
-
-#ifndef USE_NUM_NONE
-void random_num_negate(secp256k1_num *num) {
- if (secp256k1_rand_bits(1)) {
- secp256k1_num_negate(num);
- }
-}
-
-void random_num_order_test(secp256k1_num *num) {
- secp256k1_scalar sc;
- random_scalar_order_test(&sc);
- secp256k1_scalar_get_num(num, &sc);
-}
-
-void random_num_order(secp256k1_num *num) {
- secp256k1_scalar sc;
- random_scalar_order(&sc);
- secp256k1_scalar_get_num(num, &sc);
-}
-
-void test_num_negate(void) {
- secp256k1_num n1;
- secp256k1_num n2;
- random_num_order_test(&n1); /* n1 = R */
- random_num_negate(&n1);
- secp256k1_num_copy(&n2, &n1); /* n2 = R */
- secp256k1_num_sub(&n1, &n2, &n1); /* n1 = n2-n1 = 0 */
- CHECK(secp256k1_num_is_zero(&n1));
- secp256k1_num_copy(&n1, &n2); /* n1 = R */
- secp256k1_num_negate(&n1); /* n1 = -R */
- CHECK(!secp256k1_num_is_zero(&n1));
- secp256k1_num_add(&n1, &n2, &n1); /* n1 = n2+n1 = 0 */
- CHECK(secp256k1_num_is_zero(&n1));
- secp256k1_num_copy(&n1, &n2); /* n1 = R */
- secp256k1_num_negate(&n1); /* n1 = -R */
- CHECK(secp256k1_num_is_neg(&n1) != secp256k1_num_is_neg(&n2));
- secp256k1_num_negate(&n1); /* n1 = R */
- CHECK(secp256k1_num_eq(&n1, &n2));
-}
-
-void test_num_add_sub(void) {
- int i;
- secp256k1_scalar s;
- secp256k1_num n1;
- secp256k1_num n2;
- secp256k1_num n1p2, n2p1, n1m2, n2m1;
- random_num_order_test(&n1); /* n1 = R1 */
- if (secp256k1_rand_bits(1)) {
- random_num_negate(&n1);
- }
- random_num_order_test(&n2); /* n2 = R2 */
- if (secp256k1_rand_bits(1)) {
- random_num_negate(&n2);
- }
- secp256k1_num_add(&n1p2, &n1, &n2); /* n1p2 = R1 + R2 */
- secp256k1_num_add(&n2p1, &n2, &n1); /* n2p1 = R2 + R1 */
- secp256k1_num_sub(&n1m2, &n1, &n2); /* n1m2 = R1 - R2 */
- secp256k1_num_sub(&n2m1, &n2, &n1); /* n2m1 = R2 - R1 */
- CHECK(secp256k1_num_eq(&n1p2, &n2p1));
- CHECK(!secp256k1_num_eq(&n1p2, &n1m2));
- secp256k1_num_negate(&n2m1); /* n2m1 = -R2 + R1 */
- CHECK(secp256k1_num_eq(&n2m1, &n1m2));
- CHECK(!secp256k1_num_eq(&n2m1, &n1));
- secp256k1_num_add(&n2m1, &n2m1, &n2); /* n2m1 = -R2 + R1 + R2 = R1 */
- CHECK(secp256k1_num_eq(&n2m1, &n1));
- CHECK(!secp256k1_num_eq(&n2p1, &n1));
- secp256k1_num_sub(&n2p1, &n2p1, &n2); /* n2p1 = R2 + R1 - R2 = R1 */
- CHECK(secp256k1_num_eq(&n2p1, &n1));
-
- /* check is_one */
- secp256k1_scalar_set_int(&s, 1);
- secp256k1_scalar_get_num(&n1, &s);
- CHECK(secp256k1_num_is_one(&n1));
- /* check that 2^n + 1 is never 1 */
- secp256k1_scalar_get_num(&n2, &s);
- for (i = 0; i < 250; ++i) {
- secp256k1_num_add(&n1, &n1, &n1); /* n1 *= 2 */
- secp256k1_num_add(&n1p2, &n1, &n2); /* n1p2 = n1 + 1 */
- CHECK(!secp256k1_num_is_one(&n1p2));
- }
-}
-
-void test_num_mod(void) {
- int i;
- secp256k1_scalar s;
- secp256k1_num order, n;
-
- /* check that 0 mod anything is 0 */
- random_scalar_order_test(&s);
- secp256k1_scalar_get_num(&order, &s);
- secp256k1_scalar_set_int(&s, 0);
- secp256k1_scalar_get_num(&n, &s);
- secp256k1_num_mod(&n, &order);
- CHECK(secp256k1_num_is_zero(&n));
-
- /* check that anything mod 1 is 0 */
- secp256k1_scalar_set_int(&s, 1);
- secp256k1_scalar_get_num(&order, &s);
- secp256k1_scalar_get_num(&n, &s);
- secp256k1_num_mod(&n, &order);
- CHECK(secp256k1_num_is_zero(&n));
-
- /* check that increasing the number past 2^256 does not break this */
- random_scalar_order_test(&s);
- secp256k1_scalar_get_num(&n, &s);
- /* multiply by 2^8, which'll test this case with high probability */
- for (i = 0; i < 8; ++i) {
- secp256k1_num_add(&n, &n, &n);
- }
- secp256k1_num_mod(&n, &order);
- CHECK(secp256k1_num_is_zero(&n));
-}
-
-void test_num_jacobi(void) {
- secp256k1_scalar sqr;
- secp256k1_scalar small;
- secp256k1_scalar five; /* five is not a quadratic residue */
- secp256k1_num order, n;
- int i;
- /* squares mod 5 are 1, 4 */
- const int jacobi5[10] = { 0, 1, -1, -1, 1, 0, 1, -1, -1, 1 };
-
- /* check some small values with 5 as the order */
- secp256k1_scalar_set_int(&five, 5);
- secp256k1_scalar_get_num(&order, &five);
- for (i = 0; i < 10; ++i) {
- secp256k1_scalar_set_int(&small, i);
- secp256k1_scalar_get_num(&n, &small);
- CHECK(secp256k1_num_jacobi(&n, &order) == jacobi5[i]);
- }
-
- /** test large values with 5 as group order */
- secp256k1_scalar_get_num(&order, &five);
- /* we first need a scalar which is not a multiple of 5 */
- do {
- secp256k1_num fiven;
- random_scalar_order_test(&sqr);
- secp256k1_scalar_get_num(&fiven, &five);
- secp256k1_scalar_get_num(&n, &sqr);
- secp256k1_num_mod(&n, &fiven);
- } while (secp256k1_num_is_zero(&n));
- /* next force it to be a residue. 2 is a nonresidue mod 5 so we can
- * just multiply by two, i.e. add the number to itself */
- if (secp256k1_num_jacobi(&n, &order) == -1) {
- secp256k1_num_add(&n, &n, &n);
- }
-
- /* test residue */
- CHECK(secp256k1_num_jacobi(&n, &order) == 1);
- /* test nonresidue */
- secp256k1_num_add(&n, &n, &n);
- CHECK(secp256k1_num_jacobi(&n, &order) == -1);
-
- /** test with secp group order as order */
- secp256k1_scalar_order_get_num(&order);
- random_scalar_order_test(&sqr);
- secp256k1_scalar_sqr(&sqr, &sqr);
- /* test residue */
- secp256k1_scalar_get_num(&n, &sqr);
- CHECK(secp256k1_num_jacobi(&n, &order) == 1);
- /* test nonresidue */
- secp256k1_scalar_mul(&sqr, &sqr, &five);
- secp256k1_scalar_get_num(&n, &sqr);
- CHECK(secp256k1_num_jacobi(&n, &order) == -1);
- /* test multiple of the order*/
- CHECK(secp256k1_num_jacobi(&order, &order) == 0);
-
- /* check one less than the order */
- secp256k1_scalar_set_int(&small, 1);
- secp256k1_scalar_get_num(&n, &small);
- secp256k1_num_sub(&n, &order, &n);
- CHECK(secp256k1_num_jacobi(&n, &order) == 1); /* sage confirms this is 1 */
-}
-
-void run_num_smalltests(void) {
- int i;
- for (i = 0; i < 100*count; i++) {
- test_num_negate();
- test_num_add_sub();
- test_num_mod();
- test_num_jacobi();
- }
-}
-#endif
-
-/***** SCALAR TESTS *****/
-
-void scalar_test(void) {
- secp256k1_scalar s;
- secp256k1_scalar s1;
- secp256k1_scalar s2;
-#ifndef USE_NUM_NONE
- secp256k1_num snum, s1num, s2num;
- secp256k1_num order, half_order;
-#endif
- unsigned char c[32];
-
- /* Set 's' to a random scalar, with value 'snum'. */
- random_scalar_order_test(&s);
-
- /* Set 's1' to a random scalar, with value 's1num'. */
- random_scalar_order_test(&s1);
-
- /* Set 's2' to a random scalar, with value 'snum2', and byte array representation 'c'. */
- random_scalar_order_test(&s2);
- secp256k1_scalar_get_b32(c, &s2);
-
-#ifndef USE_NUM_NONE
- secp256k1_scalar_get_num(&snum, &s);
- secp256k1_scalar_get_num(&s1num, &s1);
- secp256k1_scalar_get_num(&s2num, &s2);
-
- secp256k1_scalar_order_get_num(&order);
- half_order = order;
- secp256k1_num_shift(&half_order, 1);
-#endif
-
- {
- int i;
- /* Test that fetching groups of 4 bits from a scalar and recursing n(i)=16*n(i-1)+p(i) reconstructs it. */
- secp256k1_scalar n;
- secp256k1_scalar_set_int(&n, 0);
- for (i = 0; i < 256; i += 4) {
- secp256k1_scalar t;
- int j;
- secp256k1_scalar_set_int(&t, secp256k1_scalar_get_bits(&s, 256 - 4 - i, 4));
- for (j = 0; j < 4; j++) {
- secp256k1_scalar_add(&n, &n, &n);
- }
- secp256k1_scalar_add(&n, &n, &t);
- }
- CHECK(secp256k1_scalar_eq(&n, &s));
- }
-
- {
- /* Test that fetching groups of randomly-sized bits from a scalar and recursing n(i)=b*n(i-1)+p(i) reconstructs it. */
- secp256k1_scalar n;
- int i = 0;
- secp256k1_scalar_set_int(&n, 0);
- while (i < 256) {
- secp256k1_scalar t;
- int j;
- int now = secp256k1_rand_int(15) + 1;
- if (now + i > 256) {
- now = 256 - i;
- }
- secp256k1_scalar_set_int(&t, secp256k1_scalar_get_bits_var(&s, 256 - now - i, now));
- for (j = 0; j < now; j++) {
- secp256k1_scalar_add(&n, &n, &n);
- }
- secp256k1_scalar_add(&n, &n, &t);
- i += now;
- }
- CHECK(secp256k1_scalar_eq(&n, &s));
- }
-
-#ifndef USE_NUM_NONE
- {
- /* Test that adding the scalars together is equal to adding their numbers together modulo the order. */
- secp256k1_num rnum;
- secp256k1_num r2num;
- secp256k1_scalar r;
- secp256k1_num_add(&rnum, &snum, &s2num);
- secp256k1_num_mod(&rnum, &order);
- secp256k1_scalar_add(&r, &s, &s2);
- secp256k1_scalar_get_num(&r2num, &r);
- CHECK(secp256k1_num_eq(&rnum, &r2num));
- }
-
- {
- /* Test that multiplying the scalars is equal to multiplying their numbers modulo the order. */
- secp256k1_scalar r;
- secp256k1_num r2num;
- secp256k1_num rnum;
- secp256k1_num_mul(&rnum, &snum, &s2num);
- secp256k1_num_mod(&rnum, &order);
- secp256k1_scalar_mul(&r, &s, &s2);
- secp256k1_scalar_get_num(&r2num, &r);
- CHECK(secp256k1_num_eq(&rnum, &r2num));
- /* The result can only be zero if at least one of the factors was zero. */
- CHECK(secp256k1_scalar_is_zero(&r) == (secp256k1_scalar_is_zero(&s) || secp256k1_scalar_is_zero(&s2)));
- /* The results can only be equal to one of the factors if that factor was zero, or the other factor was one. */
- CHECK(secp256k1_num_eq(&rnum, &snum) == (secp256k1_scalar_is_zero(&s) || secp256k1_scalar_is_one(&s2)));
- CHECK(secp256k1_num_eq(&rnum, &s2num) == (secp256k1_scalar_is_zero(&s2) || secp256k1_scalar_is_one(&s)));
- }
-
- {
- secp256k1_scalar neg;
- secp256k1_num negnum;
- secp256k1_num negnum2;
- /* Check that comparison with zero matches comparison with zero on the number. */
- CHECK(secp256k1_num_is_zero(&snum) == secp256k1_scalar_is_zero(&s));
- /* Check that comparison with the half order is equal to testing for high scalar. */
- CHECK(secp256k1_scalar_is_high(&s) == (secp256k1_num_cmp(&snum, &half_order) > 0));
- secp256k1_scalar_negate(&neg, &s);
- secp256k1_num_sub(&negnum, &order, &snum);
- secp256k1_num_mod(&negnum, &order);
- /* Check that comparison with the half order is equal to testing for high scalar after negation. */
- CHECK(secp256k1_scalar_is_high(&neg) == (secp256k1_num_cmp(&negnum, &half_order) > 0));
- /* Negating should change the high property, unless the value was already zero. */
- CHECK((secp256k1_scalar_is_high(&s) == secp256k1_scalar_is_high(&neg)) == secp256k1_scalar_is_zero(&s));
- secp256k1_scalar_get_num(&negnum2, &neg);
- /* Negating a scalar should be equal to (order - n) mod order on the number. */
- CHECK(secp256k1_num_eq(&negnum, &negnum2));
- secp256k1_scalar_add(&neg, &neg, &s);
- /* Adding a number to its negation should result in zero. */
- CHECK(secp256k1_scalar_is_zero(&neg));
- secp256k1_scalar_negate(&neg, &neg);
- /* Negating zero should still result in zero. */
- CHECK(secp256k1_scalar_is_zero(&neg));
- }
-
- {
- /* Test secp256k1_scalar_mul_shift_var. */
- secp256k1_scalar r;
- secp256k1_num one;
- secp256k1_num rnum;
- secp256k1_num rnum2;
- unsigned char cone[1] = {0x01};
- unsigned int shift = 256 + secp256k1_rand_int(257);
- secp256k1_scalar_mul_shift_var(&r, &s1, &s2, shift);
- secp256k1_num_mul(&rnum, &s1num, &s2num);
- secp256k1_num_shift(&rnum, shift - 1);
- secp256k1_num_set_bin(&one, cone, 1);
- secp256k1_num_add(&rnum, &rnum, &one);
- secp256k1_num_shift(&rnum, 1);
- secp256k1_scalar_get_num(&rnum2, &r);
- CHECK(secp256k1_num_eq(&rnum, &rnum2));
- }
-
- {
- /* test secp256k1_scalar_shr_int */
- secp256k1_scalar r;
- int i;
- random_scalar_order_test(&r);
- for (i = 0; i < 100; ++i) {
- int low;
- int shift = 1 + secp256k1_rand_int(15);
- int expected = r.d[0] % (1 << shift);
- low = secp256k1_scalar_shr_int(&r, shift);
- CHECK(expected == low);
- }
- }
-#endif
-
- {
- /* Test that scalar inverses are equal to the inverse of their number modulo the order. */
- if (!secp256k1_scalar_is_zero(&s)) {
- secp256k1_scalar inv;
-#ifndef USE_NUM_NONE
- secp256k1_num invnum;
- secp256k1_num invnum2;
-#endif
- secp256k1_scalar_inverse(&inv, &s);
-#ifndef USE_NUM_NONE
- secp256k1_num_mod_inverse(&invnum, &snum, &order);
- secp256k1_scalar_get_num(&invnum2, &inv);
- CHECK(secp256k1_num_eq(&invnum, &invnum2));
-#endif
- secp256k1_scalar_mul(&inv, &inv, &s);
- /* Multiplying a scalar with its inverse must result in one. */
- CHECK(secp256k1_scalar_is_one(&inv));
- secp256k1_scalar_inverse(&inv, &inv);
- /* Inverting one must result in one. */
- CHECK(secp256k1_scalar_is_one(&inv));
-#ifndef USE_NUM_NONE
- secp256k1_scalar_get_num(&invnum, &inv);
- CHECK(secp256k1_num_is_one(&invnum));
-#endif
- }
- }
-
- {
- /* Test commutativity of add. */
- secp256k1_scalar r1, r2;
- secp256k1_scalar_add(&r1, &s1, &s2);
- secp256k1_scalar_add(&r2, &s2, &s1);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
-
- {
- secp256k1_scalar r1, r2;
- secp256k1_scalar b;
- int i;
- /* Test add_bit. */
- int bit = secp256k1_rand_bits(8);
- secp256k1_scalar_set_int(&b, 1);
- CHECK(secp256k1_scalar_is_one(&b));
- for (i = 0; i < bit; i++) {
- secp256k1_scalar_add(&b, &b, &b);
- }
- r1 = s1;
- r2 = s1;
- if (!secp256k1_scalar_add(&r1, &r1, &b)) {
- /* No overflow happened. */
- secp256k1_scalar_cadd_bit(&r2, bit, 1);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- /* cadd is a noop when flag is zero */
- secp256k1_scalar_cadd_bit(&r2, bit, 0);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
- }
-
- {
- /* Test commutativity of mul. */
- secp256k1_scalar r1, r2;
- secp256k1_scalar_mul(&r1, &s1, &s2);
- secp256k1_scalar_mul(&r2, &s2, &s1);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
-
- {
- /* Test associativity of add. */
- secp256k1_scalar r1, r2;
- secp256k1_scalar_add(&r1, &s1, &s2);
- secp256k1_scalar_add(&r1, &r1, &s);
- secp256k1_scalar_add(&r2, &s2, &s);
- secp256k1_scalar_add(&r2, &s1, &r2);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
-
- {
- /* Test associativity of mul. */
- secp256k1_scalar r1, r2;
- secp256k1_scalar_mul(&r1, &s1, &s2);
- secp256k1_scalar_mul(&r1, &r1, &s);
- secp256k1_scalar_mul(&r2, &s2, &s);
- secp256k1_scalar_mul(&r2, &s1, &r2);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
-
- {
- /* Test distributitivity of mul over add. */
- secp256k1_scalar r1, r2, t;
- secp256k1_scalar_add(&r1, &s1, &s2);
- secp256k1_scalar_mul(&r1, &r1, &s);
- secp256k1_scalar_mul(&r2, &s1, &s);
- secp256k1_scalar_mul(&t, &s2, &s);
- secp256k1_scalar_add(&r2, &r2, &t);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
-
- {
- /* Test square. */
- secp256k1_scalar r1, r2;
- secp256k1_scalar_sqr(&r1, &s1);
- secp256k1_scalar_mul(&r2, &s1, &s1);
- CHECK(secp256k1_scalar_eq(&r1, &r2));
- }
-
- {
- /* Test multiplicative identity. */
- secp256k1_scalar r1, v1;
- secp256k1_scalar_set_int(&v1,1);
- secp256k1_scalar_mul(&r1, &s1, &v1);
- CHECK(secp256k1_scalar_eq(&r1, &s1));
- }
-
- {
- /* Test additive identity. */
- secp256k1_scalar r1, v0;
- secp256k1_scalar_set_int(&v0,0);
- secp256k1_scalar_add(&r1, &s1, &v0);
- CHECK(secp256k1_scalar_eq(&r1, &s1));
- }
-
- {
- /* Test zero product property. */
- secp256k1_scalar r1, v0;
- secp256k1_scalar_set_int(&v0,0);
- secp256k1_scalar_mul(&r1, &s1, &v0);
- CHECK(secp256k1_scalar_eq(&r1, &v0));
- }
-
-}
-
-void run_scalar_tests(void) {
- int i;
- for (i = 0; i < 128 * count; i++) {
- scalar_test();
- }
-
- {
- /* (-1)+1 should be zero. */
- secp256k1_scalar s, o;
- secp256k1_scalar_set_int(&s, 1);
- CHECK(secp256k1_scalar_is_one(&s));
- secp256k1_scalar_negate(&o, &s);
- secp256k1_scalar_add(&o, &o, &s);
- CHECK(secp256k1_scalar_is_zero(&o));
- secp256k1_scalar_negate(&o, &o);
- CHECK(secp256k1_scalar_is_zero(&o));
- }
-
-#ifndef USE_NUM_NONE
- {
- /* A scalar with value of the curve order should be 0. */
- secp256k1_num order;
- secp256k1_scalar zero;
- unsigned char bin[32];
- int overflow = 0;
- secp256k1_scalar_order_get_num(&order);
- secp256k1_num_get_bin(bin, 32, &order);
- secp256k1_scalar_set_b32(&zero, bin, &overflow);
- CHECK(overflow == 1);
- CHECK(secp256k1_scalar_is_zero(&zero));
- }
-#endif
-
- {
- /* Does check_overflow check catch all ones? */
- static const secp256k1_scalar overflowed = SECP256K1_SCALAR_CONST(
- 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL,
- 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL
- );
- CHECK(secp256k1_scalar_check_overflow(&overflowed));
- }
-
- {
- /* Static test vectors.
- * These were reduced from ~10^12 random vectors based on comparison-decision
- * and edge-case coverage on 32-bit and 64-bit implementations.
- * The responses were generated with Sage 5.9.
- */
- secp256k1_scalar x;
- secp256k1_scalar y;
- secp256k1_scalar z;
- secp256k1_scalar zz;
- secp256k1_scalar one;
- secp256k1_scalar r1;
- secp256k1_scalar r2;
-#if defined(USE_SCALAR_INV_NUM)
- secp256k1_scalar zzv;
-#endif
- int overflow;
- unsigned char chal[33][2][32] = {
- {{0xff, 0xff, 0x03, 0x07, 0x00, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff,
- 0xff, 0xff, 0x03, 0x00, 0xc0, 0xff, 0xff, 0xff},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff}},
- {{0xef, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
- {0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0,
- 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x80, 0xff}},
- {{0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
- 0x80, 0x00, 0x00, 0x80, 0xff, 0x3f, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x00},
- {0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xe0,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff}},
- {{0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0x1e, 0xf8, 0xff, 0xff, 0xff, 0xfd, 0xff},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f,
- 0x00, 0x00, 0x00, 0xf8, 0xff, 0x03, 0x00, 0xe0,
- 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff,
- 0xf3, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00}},
- {{0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0x1c, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xe0, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00,
- 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x1f, 0x00, 0x00, 0x80, 0xff, 0xff, 0x3f,
- 0x00, 0xfe, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff}},
- {{0xff, 0xff, 0xff, 0xff, 0x00, 0x0f, 0xfc, 0x9f,
- 0xff, 0xff, 0xff, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0x0f, 0xfc, 0xff, 0x7f, 0x00, 0x00, 0x00,
- 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00},
- {0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
- 0x00, 0x00, 0xf8, 0xff, 0x0f, 0xc0, 0xff, 0xff,
- 0xff, 0x1f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0x07, 0x80, 0xff, 0xff, 0xff}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00,
- 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff,
- 0xf7, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0x00,
- 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xf0},
- {0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
- {{0x00, 0xf8, 0xff, 0x03, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0x03, 0xc0, 0xff, 0x0f, 0xfc, 0xff},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0xff, 0xff,
- 0xff, 0x01, 0x00, 0x00, 0x00, 0x3f, 0x00, 0xc0,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
- {{0x8f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x7f, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
- {{0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0x03, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0x00, 0x00, 0x80, 0xff, 0x7f},
- {0xff, 0xcf, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
- 0x00, 0xc0, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff,
- 0xbf, 0xff, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x80, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff,
- 0xff, 0xff, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0x01, 0xfc, 0xff, 0x01, 0x00, 0xfe, 0xff},
- {0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00}},
- {{0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0x7f, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0xf8, 0xff, 0x01, 0x00, 0xf0, 0xff, 0xff,
- 0xe0, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x00},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
- 0xfc, 0xff, 0xff, 0x3f, 0xf0, 0xff, 0xff, 0x3f,
- 0x00, 0x00, 0xf8, 0x07, 0x00, 0x00, 0x00, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0x0f, 0x7e, 0x00, 0x00}},
- {{0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0x1f, 0x00, 0x00, 0xfe, 0x07, 0x00},
- {0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xfb, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60}},
- {{0xff, 0x01, 0x00, 0xff, 0xff, 0xff, 0x0f, 0x00,
- 0x80, 0x7f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x03,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
- {0xff, 0xff, 0x1f, 0x00, 0xf0, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00}},
- {{0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03,
- 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xc0, 0xff, 0xff, 0xcf, 0xff, 0x1f, 0x00, 0x00,
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x7e,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x00},
- {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0x7f, 0x00, 0x80, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00},
- {0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x80,
- 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
- 0xff, 0x7f, 0xf8, 0xff, 0xff, 0x1f, 0x00, 0xfe}},
- {{0xff, 0xff, 0xff, 0x3f, 0xf8, 0xff, 0xff, 0xff,
- 0xff, 0x03, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x00,
- 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0x01, 0x80, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x40}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
- {{0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
- {0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xc0,
- 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00,
- 0xf0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff}},
- {{0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x40},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0x7e, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x07, 0x00,
- 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
- 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
- {0xff, 0x01, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
- {{0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01,
- 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff,
- 0xff, 0xff, 0x3f, 0x00, 0xf8, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x3f, 0x00, 0x00, 0xc0, 0xf1, 0x7f, 0x00}},
- {{0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x80, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x00},
- {0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff,
- 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1f,
- 0x00, 0x00, 0xfc, 0xff, 0xff, 0x01, 0xff, 0xff}},
- {{0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x80, 0x00, 0x00, 0x80, 0xff, 0x03, 0xe0, 0x01,
- 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xfc, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00},
- {0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
- 0xfe, 0xff, 0xff, 0xf0, 0x07, 0x00, 0x3c, 0x80,
- 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0x07, 0xe0, 0xff, 0x00, 0x00, 0x00}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf8,
- 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80},
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x80, 0x00,
- 0x00, 0x00, 0x00, 0xc0, 0x7f, 0xfe, 0xff, 0x1f,
- 0x00, 0xfe, 0xff, 0x03, 0x00, 0x00, 0xfe, 0xff}},
- {{0xff, 0xff, 0x81, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x83,
- 0xff, 0xff, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80,
- 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xf0},
- {0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00,
- 0xf8, 0x07, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xc7, 0xff, 0xff, 0xe0, 0xff, 0xff, 0xff}},
- {{0x82, 0xc9, 0xfa, 0xb0, 0x68, 0x04, 0xa0, 0x00,
- 0x82, 0xc9, 0xfa, 0xb0, 0x68, 0x04, 0xa0, 0x00,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x6f, 0x03, 0xfb,
- 0xfa, 0x8a, 0x7d, 0xdf, 0x13, 0x86, 0xe2, 0x03},
- {0x82, 0xc9, 0xfa, 0xb0, 0x68, 0x04, 0xa0, 0x00,
- 0x82, 0xc9, 0xfa, 0xb0, 0x68, 0x04, 0xa0, 0x00,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x6f, 0x03, 0xfb,
- 0xfa, 0x8a, 0x7d, 0xdf, 0x13, 0x86, 0xe2, 0x03}}
- };
- unsigned char res[33][2][32] = {
- {{0x0c, 0x3b, 0x0a, 0xca, 0x8d, 0x1a, 0x2f, 0xb9,
- 0x8a, 0x7b, 0x53, 0x5a, 0x1f, 0xc5, 0x22, 0xa1,
- 0x07, 0x2a, 0x48, 0xea, 0x02, 0xeb, 0xb3, 0xd6,
- 0x20, 0x1e, 0x86, 0xd0, 0x95, 0xf6, 0x92, 0x35},
- {0xdc, 0x90, 0x7a, 0x07, 0x2e, 0x1e, 0x44, 0x6d,
- 0xf8, 0x15, 0x24, 0x5b, 0x5a, 0x96, 0x37, 0x9c,
- 0x37, 0x7b, 0x0d, 0xac, 0x1b, 0x65, 0x58, 0x49,
- 0x43, 0xb7, 0x31, 0xbb, 0xa7, 0xf4, 0x97, 0x15}},
- {{0xf1, 0xf7, 0x3a, 0x50, 0xe6, 0x10, 0xba, 0x22,
- 0x43, 0x4d, 0x1f, 0x1f, 0x7c, 0x27, 0xca, 0x9c,
- 0xb8, 0xb6, 0xa0, 0xfc, 0xd8, 0xc0, 0x05, 0x2f,
- 0xf7, 0x08, 0xe1, 0x76, 0xdd, 0xd0, 0x80, 0xc8},
- {0xe3, 0x80, 0x80, 0xb8, 0xdb, 0xe3, 0xa9, 0x77,
- 0x00, 0xb0, 0xf5, 0x2e, 0x27, 0xe2, 0x68, 0xc4,
- 0x88, 0xe8, 0x04, 0xc1, 0x12, 0xbf, 0x78, 0x59,
- 0xe6, 0xa9, 0x7c, 0xe1, 0x81, 0xdd, 0xb9, 0xd5}},
- {{0x96, 0xe2, 0xee, 0x01, 0xa6, 0x80, 0x31, 0xef,
- 0x5c, 0xd0, 0x19, 0xb4, 0x7d, 0x5f, 0x79, 0xab,
- 0xa1, 0x97, 0xd3, 0x7e, 0x33, 0xbb, 0x86, 0x55,
- 0x60, 0x20, 0x10, 0x0d, 0x94, 0x2d, 0x11, 0x7c},
- {0xcc, 0xab, 0xe0, 0xe8, 0x98, 0x65, 0x12, 0x96,
- 0x38, 0x5a, 0x1a, 0xf2, 0x85, 0x23, 0x59, 0x5f,
- 0xf9, 0xf3, 0xc2, 0x81, 0x70, 0x92, 0x65, 0x12,
- 0x9c, 0x65, 0x1e, 0x96, 0x00, 0xef, 0xe7, 0x63}},
- {{0xac, 0x1e, 0x62, 0xc2, 0x59, 0xfc, 0x4e, 0x5c,
- 0x83, 0xb0, 0xd0, 0x6f, 0xce, 0x19, 0xf6, 0xbf,
- 0xa4, 0xb0, 0xe0, 0x53, 0x66, 0x1f, 0xbf, 0xc9,
- 0x33, 0x47, 0x37, 0xa9, 0x3d, 0x5d, 0xb0, 0x48},
- {0x86, 0xb9, 0x2a, 0x7f, 0x8e, 0xa8, 0x60, 0x42,
- 0x26, 0x6d, 0x6e, 0x1c, 0xa2, 0xec, 0xe0, 0xe5,
- 0x3e, 0x0a, 0x33, 0xbb, 0x61, 0x4c, 0x9f, 0x3c,
- 0xd1, 0xdf, 0x49, 0x33, 0xcd, 0x72, 0x78, 0x18}},
- {{0xf7, 0xd3, 0xcd, 0x49, 0x5c, 0x13, 0x22, 0xfb,
- 0x2e, 0xb2, 0x2f, 0x27, 0xf5, 0x8a, 0x5d, 0x74,
- 0xc1, 0x58, 0xc5, 0xc2, 0x2d, 0x9f, 0x52, 0xc6,
- 0x63, 0x9f, 0xba, 0x05, 0x76, 0x45, 0x7a, 0x63},
- {0x8a, 0xfa, 0x55, 0x4d, 0xdd, 0xa3, 0xb2, 0xc3,
- 0x44, 0xfd, 0xec, 0x72, 0xde, 0xef, 0xc0, 0x99,
- 0xf5, 0x9f, 0xe2, 0x52, 0xb4, 0x05, 0x32, 0x58,
- 0x57, 0xc1, 0x8f, 0xea, 0xc3, 0x24, 0x5b, 0x94}},
- {{0x05, 0x83, 0xee, 0xdd, 0x64, 0xf0, 0x14, 0x3b,
- 0xa0, 0x14, 0x4a, 0x3a, 0x41, 0x82, 0x7c, 0xa7,
- 0x2c, 0xaa, 0xb1, 0x76, 0xbb, 0x59, 0x64, 0x5f,
- 0x52, 0xad, 0x25, 0x29, 0x9d, 0x8f, 0x0b, 0xb0},
- {0x7e, 0xe3, 0x7c, 0xca, 0xcd, 0x4f, 0xb0, 0x6d,
- 0x7a, 0xb2, 0x3e, 0xa0, 0x08, 0xb9, 0xa8, 0x2d,
- 0xc2, 0xf4, 0x99, 0x66, 0xcc, 0xac, 0xd8, 0xb9,
- 0x72, 0x2a, 0x4a, 0x3e, 0x0f, 0x7b, 0xbf, 0xf4}},
- {{0x8c, 0x9c, 0x78, 0x2b, 0x39, 0x61, 0x7e, 0xf7,
- 0x65, 0x37, 0x66, 0x09, 0x38, 0xb9, 0x6f, 0x70,
- 0x78, 0x87, 0xff, 0xcf, 0x93, 0xca, 0x85, 0x06,
- 0x44, 0x84, 0xa7, 0xfe, 0xd3, 0xa4, 0xe3, 0x7e},
- {0xa2, 0x56, 0x49, 0x23, 0x54, 0xa5, 0x50, 0xe9,
- 0x5f, 0xf0, 0x4d, 0xe7, 0xdc, 0x38, 0x32, 0x79,
- 0x4f, 0x1c, 0xb7, 0xe4, 0xbb, 0xf8, 0xbb, 0x2e,
- 0x40, 0x41, 0x4b, 0xcc, 0xe3, 0x1e, 0x16, 0x36}},
- {{0x0c, 0x1e, 0xd7, 0x09, 0x25, 0x40, 0x97, 0xcb,
- 0x5c, 0x46, 0xa8, 0xda, 0xef, 0x25, 0xd5, 0xe5,
- 0x92, 0x4d, 0xcf, 0xa3, 0xc4, 0x5d, 0x35, 0x4a,
- 0xe4, 0x61, 0x92, 0xf3, 0xbf, 0x0e, 0xcd, 0xbe},
- {0xe4, 0xaf, 0x0a, 0xb3, 0x30, 0x8b, 0x9b, 0x48,
- 0x49, 0x43, 0xc7, 0x64, 0x60, 0x4a, 0x2b, 0x9e,
- 0x95, 0x5f, 0x56, 0xe8, 0x35, 0xdc, 0xeb, 0xdc,
- 0xc7, 0xc4, 0xfe, 0x30, 0x40, 0xc7, 0xbf, 0xa4}},
- {{0xd4, 0xa0, 0xf5, 0x81, 0x49, 0x6b, 0xb6, 0x8b,
- 0x0a, 0x69, 0xf9, 0xfe, 0xa8, 0x32, 0xe5, 0xe0,
- 0xa5, 0xcd, 0x02, 0x53, 0xf9, 0x2c, 0xe3, 0x53,
- 0x83, 0x36, 0xc6, 0x02, 0xb5, 0xeb, 0x64, 0xb8},
- {0x1d, 0x42, 0xb9, 0xf9, 0xe9, 0xe3, 0x93, 0x2c,
- 0x4c, 0xee, 0x6c, 0x5a, 0x47, 0x9e, 0x62, 0x01,
- 0x6b, 0x04, 0xfe, 0xa4, 0x30, 0x2b, 0x0d, 0x4f,
- 0x71, 0x10, 0xd3, 0x55, 0xca, 0xf3, 0x5e, 0x80}},
- {{0x77, 0x05, 0xf6, 0x0c, 0x15, 0x9b, 0x45, 0xe7,
- 0xb9, 0x11, 0xb8, 0xf5, 0xd6, 0xda, 0x73, 0x0c,
- 0xda, 0x92, 0xea, 0xd0, 0x9d, 0xd0, 0x18, 0x92,
- 0xce, 0x9a, 0xaa, 0xee, 0x0f, 0xef, 0xde, 0x30},
- {0xf1, 0xf1, 0xd6, 0x9b, 0x51, 0xd7, 0x77, 0x62,
- 0x52, 0x10, 0xb8, 0x7a, 0x84, 0x9d, 0x15, 0x4e,
- 0x07, 0xdc, 0x1e, 0x75, 0x0d, 0x0c, 0x3b, 0xdb,
- 0x74, 0x58, 0x62, 0x02, 0x90, 0x54, 0x8b, 0x43}},
- {{0xa6, 0xfe, 0x0b, 0x87, 0x80, 0x43, 0x67, 0x25,
- 0x57, 0x5d, 0xec, 0x40, 0x50, 0x08, 0xd5, 0x5d,
- 0x43, 0xd7, 0xe0, 0xaa, 0xe0, 0x13, 0xb6, 0xb0,
- 0xc0, 0xd4, 0xe5, 0x0d, 0x45, 0x83, 0xd6, 0x13},
- {0x40, 0x45, 0x0a, 0x92, 0x31, 0xea, 0x8c, 0x60,
- 0x8c, 0x1f, 0xd8, 0x76, 0x45, 0xb9, 0x29, 0x00,
- 0x26, 0x32, 0xd8, 0xa6, 0x96, 0x88, 0xe2, 0xc4,
- 0x8b, 0xdb, 0x7f, 0x17, 0x87, 0xcc, 0xc8, 0xf2}},
- {{0xc2, 0x56, 0xe2, 0xb6, 0x1a, 0x81, 0xe7, 0x31,
- 0x63, 0x2e, 0xbb, 0x0d, 0x2f, 0x81, 0x67, 0xd4,
- 0x22, 0xe2, 0x38, 0x02, 0x25, 0x97, 0xc7, 0x88,
- 0x6e, 0xdf, 0xbe, 0x2a, 0xa5, 0x73, 0x63, 0xaa},
- {0x50, 0x45, 0xe2, 0xc3, 0xbd, 0x89, 0xfc, 0x57,
- 0xbd, 0x3c, 0xa3, 0x98, 0x7e, 0x7f, 0x36, 0x38,
- 0x92, 0x39, 0x1f, 0x0f, 0x81, 0x1a, 0x06, 0x51,
- 0x1f, 0x8d, 0x6a, 0xff, 0x47, 0x16, 0x06, 0x9c}},
- {{0x33, 0x95, 0xa2, 0x6f, 0x27, 0x5f, 0x9c, 0x9c,
- 0x64, 0x45, 0xcb, 0xd1, 0x3c, 0xee, 0x5e, 0x5f,
- 0x48, 0xa6, 0xaf, 0xe3, 0x79, 0xcf, 0xb1, 0xe2,
- 0xbf, 0x55, 0x0e, 0xa2, 0x3b, 0x62, 0xf0, 0xe4},
- {0x14, 0xe8, 0x06, 0xe3, 0xbe, 0x7e, 0x67, 0x01,
- 0xc5, 0x21, 0x67, 0xd8, 0x54, 0xb5, 0x7f, 0xa4,
- 0xf9, 0x75, 0x70, 0x1c, 0xfd, 0x79, 0xdb, 0x86,
- 0xad, 0x37, 0x85, 0x83, 0x56, 0x4e, 0xf0, 0xbf}},
- {{0xbc, 0xa6, 0xe0, 0x56, 0x4e, 0xef, 0xfa, 0xf5,
- 0x1d, 0x5d, 0x3f, 0x2a, 0x5b, 0x19, 0xab, 0x51,
- 0xc5, 0x8b, 0xdd, 0x98, 0x28, 0x35, 0x2f, 0xc3,
- 0x81, 0x4f, 0x5c, 0xe5, 0x70, 0xb9, 0xeb, 0x62},
- {0xc4, 0x6d, 0x26, 0xb0, 0x17, 0x6b, 0xfe, 0x6c,
- 0x12, 0xf8, 0xe7, 0xc1, 0xf5, 0x2f, 0xfa, 0x91,
- 0x13, 0x27, 0xbd, 0x73, 0xcc, 0x33, 0x31, 0x1c,
- 0x39, 0xe3, 0x27, 0x6a, 0x95, 0xcf, 0xc5, 0xfb}},
- {{0x30, 0xb2, 0x99, 0x84, 0xf0, 0x18, 0x2a, 0x6e,
- 0x1e, 0x27, 0xed, 0xa2, 0x29, 0x99, 0x41, 0x56,
- 0xe8, 0xd4, 0x0d, 0xef, 0x99, 0x9c, 0xf3, 0x58,
- 0x29, 0x55, 0x1a, 0xc0, 0x68, 0xd6, 0x74, 0xa4},
- {0x07, 0x9c, 0xe7, 0xec, 0xf5, 0x36, 0x73, 0x41,
- 0xa3, 0x1c, 0xe5, 0x93, 0x97, 0x6a, 0xfd, 0xf7,
- 0x53, 0x18, 0xab, 0xaf, 0xeb, 0x85, 0xbd, 0x92,
- 0x90, 0xab, 0x3c, 0xbf, 0x30, 0x82, 0xad, 0xf6}},
- {{0xc6, 0x87, 0x8a, 0x2a, 0xea, 0xc0, 0xa9, 0xec,
- 0x6d, 0xd3, 0xdc, 0x32, 0x23, 0xce, 0x62, 0x19,
- 0xa4, 0x7e, 0xa8, 0xdd, 0x1c, 0x33, 0xae, 0xd3,
- 0x4f, 0x62, 0x9f, 0x52, 0xe7, 0x65, 0x46, 0xf4},
- {0x97, 0x51, 0x27, 0x67, 0x2d, 0xa2, 0x82, 0x87,
- 0x98, 0xd3, 0xb6, 0x14, 0x7f, 0x51, 0xd3, 0x9a,
- 0x0b, 0xd0, 0x76, 0x81, 0xb2, 0x4f, 0x58, 0x92,
- 0xa4, 0x86, 0xa1, 0xa7, 0x09, 0x1d, 0xef, 0x9b}},
- {{0xb3, 0x0f, 0x2b, 0x69, 0x0d, 0x06, 0x90, 0x64,
- 0xbd, 0x43, 0x4c, 0x10, 0xe8, 0x98, 0x1c, 0xa3,
- 0xe1, 0x68, 0xe9, 0x79, 0x6c, 0x29, 0x51, 0x3f,
- 0x41, 0xdc, 0xdf, 0x1f, 0xf3, 0x60, 0xbe, 0x33},
- {0xa1, 0x5f, 0xf7, 0x1d, 0xb4, 0x3e, 0x9b, 0x3c,
- 0xe7, 0xbd, 0xb6, 0x06, 0xd5, 0x60, 0x06, 0x6d,
- 0x50, 0xd2, 0xf4, 0x1a, 0x31, 0x08, 0xf2, 0xea,
- 0x8e, 0xef, 0x5f, 0x7d, 0xb6, 0xd0, 0xc0, 0x27}},
- {{0x62, 0x9a, 0xd9, 0xbb, 0x38, 0x36, 0xce, 0xf7,
- 0x5d, 0x2f, 0x13, 0xec, 0xc8, 0x2d, 0x02, 0x8a,
- 0x2e, 0x72, 0xf0, 0xe5, 0x15, 0x9d, 0x72, 0xae,
- 0xfc, 0xb3, 0x4f, 0x02, 0xea, 0xe1, 0x09, 0xfe},
- {0x00, 0x00, 0x00, 0x00, 0xfa, 0x0a, 0x3d, 0xbc,
- 0xad, 0x16, 0x0c, 0xb6, 0xe7, 0x7c, 0x8b, 0x39,
- 0x9a, 0x43, 0xbb, 0xe3, 0xc2, 0x55, 0x15, 0x14,
- 0x75, 0xac, 0x90, 0x9b, 0x7f, 0x9a, 0x92, 0x00}},
- {{0x8b, 0xac, 0x70, 0x86, 0x29, 0x8f, 0x00, 0x23,
- 0x7b, 0x45, 0x30, 0xaa, 0xb8, 0x4c, 0xc7, 0x8d,
- 0x4e, 0x47, 0x85, 0xc6, 0x19, 0xe3, 0x96, 0xc2,
- 0x9a, 0xa0, 0x12, 0xed, 0x6f, 0xd7, 0x76, 0x16},
- {0x45, 0xaf, 0x7e, 0x33, 0xc7, 0x7f, 0x10, 0x6c,
- 0x7c, 0x9f, 0x29, 0xc1, 0xa8, 0x7e, 0x15, 0x84,
- 0xe7, 0x7d, 0xc0, 0x6d, 0xab, 0x71, 0x5d, 0xd0,
- 0x6b, 0x9f, 0x97, 0xab, 0xcb, 0x51, 0x0c, 0x9f}},
- {{0x9e, 0xc3, 0x92, 0xb4, 0x04, 0x9f, 0xc8, 0xbb,
- 0xdd, 0x9e, 0xc6, 0x05, 0xfd, 0x65, 0xec, 0x94,
- 0x7f, 0x2c, 0x16, 0xc4, 0x40, 0xac, 0x63, 0x7b,
- 0x7d, 0xb8, 0x0c, 0xe4, 0x5b, 0xe3, 0xa7, 0x0e},
- {0x43, 0xf4, 0x44, 0xe8, 0xcc, 0xc8, 0xd4, 0x54,
- 0x33, 0x37, 0x50, 0xf2, 0x87, 0x42, 0x2e, 0x00,
- 0x49, 0x60, 0x62, 0x02, 0xfd, 0x1a, 0x7c, 0xdb,
- 0x29, 0x6c, 0x6d, 0x54, 0x53, 0x08, 0xd1, 0xc8}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}},
- {{0x27, 0x59, 0xc7, 0x35, 0x60, 0x71, 0xa6, 0xf1,
- 0x79, 0xa5, 0xfd, 0x79, 0x16, 0xf3, 0x41, 0xf0,
- 0x57, 0xb4, 0x02, 0x97, 0x32, 0xe7, 0xde, 0x59,
- 0xe2, 0x2d, 0x9b, 0x11, 0xea, 0x2c, 0x35, 0x92},
- {0x27, 0x59, 0xc7, 0x35, 0x60, 0x71, 0xa6, 0xf1,
- 0x79, 0xa5, 0xfd, 0x79, 0x16, 0xf3, 0x41, 0xf0,
- 0x57, 0xb4, 0x02, 0x97, 0x32, 0xe7, 0xde, 0x59,
- 0xe2, 0x2d, 0x9b, 0x11, 0xea, 0x2c, 0x35, 0x92}},
- {{0x28, 0x56, 0xac, 0x0e, 0x4f, 0x98, 0x09, 0xf0,
- 0x49, 0xfa, 0x7f, 0x84, 0xac, 0x7e, 0x50, 0x5b,
- 0x17, 0x43, 0x14, 0x89, 0x9c, 0x53, 0xa8, 0x94,
- 0x30, 0xf2, 0x11, 0x4d, 0x92, 0x14, 0x27, 0xe8},
- {0x39, 0x7a, 0x84, 0x56, 0x79, 0x9d, 0xec, 0x26,
- 0x2c, 0x53, 0xc1, 0x94, 0xc9, 0x8d, 0x9e, 0x9d,
- 0x32, 0x1f, 0xdd, 0x84, 0x04, 0xe8, 0xe2, 0x0a,
- 0x6b, 0xbe, 0xbb, 0x42, 0x40, 0x67, 0x30, 0x6c}},
- {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x45, 0x51, 0x23, 0x19, 0x50, 0xb7, 0x5f, 0xc4,
- 0x40, 0x2d, 0xa1, 0x73, 0x2f, 0xc9, 0xbe, 0xbd},
- {0x27, 0x59, 0xc7, 0x35, 0x60, 0x71, 0xa6, 0xf1,
- 0x79, 0xa5, 0xfd, 0x79, 0x16, 0xf3, 0x41, 0xf0,
- 0x57, 0xb4, 0x02, 0x97, 0x32, 0xe7, 0xde, 0x59,
- 0xe2, 0x2d, 0x9b, 0x11, 0xea, 0x2c, 0x35, 0x92}},
- {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x40},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}},
- {{0x1c, 0xc4, 0xf7, 0xda, 0x0f, 0x65, 0xca, 0x39,
- 0x70, 0x52, 0x92, 0x8e, 0xc3, 0xc8, 0x15, 0xea,
- 0x7f, 0x10, 0x9e, 0x77, 0x4b, 0x6e, 0x2d, 0xdf,
- 0xe8, 0x30, 0x9d, 0xda, 0xe8, 0x9a, 0x65, 0xae},
- {0x02, 0xb0, 0x16, 0xb1, 0x1d, 0xc8, 0x57, 0x7b,
- 0xa2, 0x3a, 0xa2, 0xa3, 0x38, 0x5c, 0x8f, 0xeb,
- 0x66, 0x37, 0x91, 0xa8, 0x5f, 0xef, 0x04, 0xf6,
- 0x59, 0x75, 0xe1, 0xee, 0x92, 0xf6, 0x0e, 0x30}},
- {{0x8d, 0x76, 0x14, 0xa4, 0x14, 0x06, 0x9f, 0x9a,
- 0xdf, 0x4a, 0x85, 0xa7, 0x6b, 0xbf, 0x29, 0x6f,
- 0xbc, 0x34, 0x87, 0x5d, 0xeb, 0xbb, 0x2e, 0xa9,
- 0xc9, 0x1f, 0x58, 0xd6, 0x9a, 0x82, 0xa0, 0x56},
- {0xd4, 0xb9, 0xdb, 0x88, 0x1d, 0x04, 0xe9, 0x93,
- 0x8d, 0x3f, 0x20, 0xd5, 0x86, 0xa8, 0x83, 0x07,
- 0xdb, 0x09, 0xd8, 0x22, 0x1f, 0x7f, 0xf1, 0x71,
- 0xc8, 0xe7, 0x5d, 0x47, 0xaf, 0x8b, 0x72, 0xe9}},
- {{0x83, 0xb9, 0x39, 0xb2, 0xa4, 0xdf, 0x46, 0x87,
- 0xc2, 0xb8, 0xf1, 0xe6, 0x4c, 0xd1, 0xe2, 0xa9,
- 0xe4, 0x70, 0x30, 0x34, 0xbc, 0x52, 0x7c, 0x55,
- 0xa6, 0xec, 0x80, 0xa4, 0xe5, 0xd2, 0xdc, 0x73},
- {0x08, 0xf1, 0x03, 0xcf, 0x16, 0x73, 0xe8, 0x7d,
- 0xb6, 0x7e, 0x9b, 0xc0, 0xb4, 0xc2, 0xa5, 0x86,
- 0x02, 0x77, 0xd5, 0x27, 0x86, 0xa5, 0x15, 0xfb,
- 0xae, 0x9b, 0x8c, 0xa9, 0xf9, 0xf8, 0xa8, 0x4a}},
- {{0x8b, 0x00, 0x49, 0xdb, 0xfa, 0xf0, 0x1b, 0xa2,
- 0xed, 0x8a, 0x9a, 0x7a, 0x36, 0x78, 0x4a, 0xc7,
- 0xf7, 0xad, 0x39, 0xd0, 0x6c, 0x65, 0x7a, 0x41,
- 0xce, 0xd6, 0xd6, 0x4c, 0x20, 0x21, 0x6b, 0xc7},
- {0xc6, 0xca, 0x78, 0x1d, 0x32, 0x6c, 0x6c, 0x06,
- 0x91, 0xf2, 0x1a, 0xe8, 0x43, 0x16, 0xea, 0x04,
- 0x3c, 0x1f, 0x07, 0x85, 0xf7, 0x09, 0x22, 0x08,
- 0xba, 0x13, 0xfd, 0x78, 0x1e, 0x3f, 0x6f, 0x62}},
- {{0x25, 0x9b, 0x7c, 0xb0, 0xac, 0x72, 0x6f, 0xb2,
- 0xe3, 0x53, 0x84, 0x7a, 0x1a, 0x9a, 0x98, 0x9b,
- 0x44, 0xd3, 0x59, 0xd0, 0x8e, 0x57, 0x41, 0x40,
- 0x78, 0xa7, 0x30, 0x2f, 0x4c, 0x9c, 0xb9, 0x68},
- {0xb7, 0x75, 0x03, 0x63, 0x61, 0xc2, 0x48, 0x6e,
- 0x12, 0x3d, 0xbf, 0x4b, 0x27, 0xdf, 0xb1, 0x7a,
- 0xff, 0x4e, 0x31, 0x07, 0x83, 0xf4, 0x62, 0x5b,
- 0x19, 0xa5, 0xac, 0xa0, 0x32, 0x58, 0x0d, 0xa7}},
- {{0x43, 0x4f, 0x10, 0xa4, 0xca, 0xdb, 0x38, 0x67,
- 0xfa, 0xae, 0x96, 0xb5, 0x6d, 0x97, 0xff, 0x1f,
- 0xb6, 0x83, 0x43, 0xd3, 0xa0, 0x2d, 0x70, 0x7a,
- 0x64, 0x05, 0x4c, 0xa7, 0xc1, 0xa5, 0x21, 0x51},
- {0xe4, 0xf1, 0x23, 0x84, 0xe1, 0xb5, 0x9d, 0xf2,
- 0xb8, 0x73, 0x8b, 0x45, 0x2b, 0x35, 0x46, 0x38,
- 0x10, 0x2b, 0x50, 0xf8, 0x8b, 0x35, 0xcd, 0x34,
- 0xc8, 0x0e, 0xf6, 0xdb, 0x09, 0x35, 0xf0, 0xda}},
- {{0xdb, 0x21, 0x5c, 0x8d, 0x83, 0x1d, 0xb3, 0x34,
- 0xc7, 0x0e, 0x43, 0xa1, 0x58, 0x79, 0x67, 0x13,
- 0x1e, 0x86, 0x5d, 0x89, 0x63, 0xe6, 0x0a, 0x46,
- 0x5c, 0x02, 0x97, 0x1b, 0x62, 0x43, 0x86, 0xf5},
- {0xdb, 0x21, 0x5c, 0x8d, 0x83, 0x1d, 0xb3, 0x34,
- 0xc7, 0x0e, 0x43, 0xa1, 0x58, 0x79, 0x67, 0x13,
- 0x1e, 0x86, 0x5d, 0x89, 0x63, 0xe6, 0x0a, 0x46,
- 0x5c, 0x02, 0x97, 0x1b, 0x62, 0x43, 0x86, 0xf5}}
- };
- secp256k1_scalar_set_int(&one, 1);
- for (i = 0; i < 33; i++) {
- secp256k1_scalar_set_b32(&x, chal[i][0], &overflow);
- CHECK(!overflow);
- secp256k1_scalar_set_b32(&y, chal[i][1], &overflow);
- CHECK(!overflow);
- secp256k1_scalar_set_b32(&r1, res[i][0], &overflow);
- CHECK(!overflow);
- secp256k1_scalar_set_b32(&r2, res[i][1], &overflow);
- CHECK(!overflow);
- secp256k1_scalar_mul(&z, &x, &y);
- CHECK(!secp256k1_scalar_check_overflow(&z));
- CHECK(secp256k1_scalar_eq(&r1, &z));
- if (!secp256k1_scalar_is_zero(&y)) {
- secp256k1_scalar_inverse(&zz, &y);
- CHECK(!secp256k1_scalar_check_overflow(&zz));
-#if defined(USE_SCALAR_INV_NUM)
- secp256k1_scalar_inverse_var(&zzv, &y);
- CHECK(secp256k1_scalar_eq(&zzv, &zz));
-#endif
- secp256k1_scalar_mul(&z, &z, &zz);
- CHECK(!secp256k1_scalar_check_overflow(&z));
- CHECK(secp256k1_scalar_eq(&x, &z));
- secp256k1_scalar_mul(&zz, &zz, &y);
- CHECK(!secp256k1_scalar_check_overflow(&zz));
- CHECK(secp256k1_scalar_eq(&one, &zz));
- }
- secp256k1_scalar_mul(&z, &x, &x);
- CHECK(!secp256k1_scalar_check_overflow(&z));
- secp256k1_scalar_sqr(&zz, &x);
- CHECK(!secp256k1_scalar_check_overflow(&zz));
- CHECK(secp256k1_scalar_eq(&zz, &z));
- CHECK(secp256k1_scalar_eq(&r2, &zz));
- }
- }
-}
-
-/***** FIELD TESTS *****/
-
-void random_fe(secp256k1_fe *x) {
- unsigned char bin[32];
- do {
- secp256k1_rand256(bin);
- if (secp256k1_fe_set_b32(x, bin)) {
- return;
- }
- } while(1);
-}
-
-void random_fe_test(secp256k1_fe *x) {
- unsigned char bin[32];
- do {
- secp256k1_rand256_test(bin);
- if (secp256k1_fe_set_b32(x, bin)) {
- return;
- }
- } while(1);
-}
-
-void random_fe_non_zero(secp256k1_fe *nz) {
- int tries = 10;
- while (--tries >= 0) {
- random_fe(nz);
- secp256k1_fe_normalize(nz);
- if (!secp256k1_fe_is_zero(nz)) {
- break;
- }
- }
- /* Infinitesimal probability of spurious failure here */
- CHECK(tries >= 0);
-}
-
-void random_fe_non_square(secp256k1_fe *ns) {
- secp256k1_fe r;
- random_fe_non_zero(ns);
- if (secp256k1_fe_sqrt(&r, ns)) {
- secp256k1_fe_negate(ns, ns, 1);
- }
-}
-
-int check_fe_equal(const secp256k1_fe *a, const secp256k1_fe *b) {
- secp256k1_fe an = *a;
- secp256k1_fe bn = *b;
- secp256k1_fe_normalize_weak(&an);
- secp256k1_fe_normalize_var(&bn);
- return secp256k1_fe_equal_var(&an, &bn);
-}
-
-int check_fe_inverse(const secp256k1_fe *a, const secp256k1_fe *ai) {
- secp256k1_fe x;
- secp256k1_fe one = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 1);
- secp256k1_fe_mul(&x, a, ai);
- return check_fe_equal(&x, &one);
-}
-
-void run_field_convert(void) {
- static const unsigned char b32[32] = {
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
- 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,
- 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x40
- };
- static const secp256k1_fe_storage fes = SECP256K1_FE_STORAGE_CONST(
- 0x00010203UL, 0x04050607UL, 0x11121314UL, 0x15161718UL,
- 0x22232425UL, 0x26272829UL, 0x33343536UL, 0x37383940UL
- );
- static const secp256k1_fe fe = SECP256K1_FE_CONST(
- 0x00010203UL, 0x04050607UL, 0x11121314UL, 0x15161718UL,
- 0x22232425UL, 0x26272829UL, 0x33343536UL, 0x37383940UL
- );
- secp256k1_fe fe2;
- unsigned char b322[32];
- secp256k1_fe_storage fes2;
- /* Check conversions to fe. */
- CHECK(secp256k1_fe_set_b32(&fe2, b32));
- CHECK(secp256k1_fe_equal_var(&fe, &fe2));
- secp256k1_fe_from_storage(&fe2, &fes);
- CHECK(secp256k1_fe_equal_var(&fe, &fe2));
- /* Check conversion from fe. */
- secp256k1_fe_get_b32(b322, &fe);
- CHECK(memcmp(b322, b32, 32) == 0);
- secp256k1_fe_to_storage(&fes2, &fe);
- CHECK(memcmp(&fes2, &fes, sizeof(fes)) == 0);
-}
-
-int fe_memcmp(const secp256k1_fe *a, const secp256k1_fe *b) {
- secp256k1_fe t = *b;
-#ifdef VERIFY
- t.magnitude = a->magnitude;
- t.normalized = a->normalized;
-#endif
- return memcmp(a, &t, sizeof(secp256k1_fe));
-}
-
-void run_field_misc(void) {
- secp256k1_fe x;
- secp256k1_fe y;
- secp256k1_fe z;
- secp256k1_fe q;
- secp256k1_fe fe5 = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 5);
- int i, j;
- for (i = 0; i < 5*count; i++) {
- secp256k1_fe_storage xs, ys, zs;
- random_fe(&x);
- random_fe_non_zero(&y);
- /* Test the fe equality and comparison operations. */
- CHECK(secp256k1_fe_cmp_var(&x, &x) == 0);
- CHECK(secp256k1_fe_equal_var(&x, &x));
- z = x;
- secp256k1_fe_add(&z,&y);
- /* Test fe conditional move; z is not normalized here. */
- q = x;
- secp256k1_fe_cmov(&x, &z, 0);
- VERIFY_CHECK(!x.normalized && x.magnitude == z.magnitude);
- secp256k1_fe_cmov(&x, &x, 1);
- CHECK(fe_memcmp(&x, &z) != 0);
- CHECK(fe_memcmp(&x, &q) == 0);
- secp256k1_fe_cmov(&q, &z, 1);
- VERIFY_CHECK(!q.normalized && q.magnitude == z.magnitude);
- CHECK(fe_memcmp(&q, &z) == 0);
- secp256k1_fe_normalize_var(&x);
- secp256k1_fe_normalize_var(&z);
- CHECK(!secp256k1_fe_equal_var(&x, &z));
- secp256k1_fe_normalize_var(&q);
- secp256k1_fe_cmov(&q, &z, (i&1));
- VERIFY_CHECK(q.normalized && q.magnitude == 1);
- for (j = 0; j < 6; j++) {
- secp256k1_fe_negate(&z, &z, j+1);
- secp256k1_fe_normalize_var(&q);
- secp256k1_fe_cmov(&q, &z, (j&1));
- VERIFY_CHECK(!q.normalized && q.magnitude == (j+2));
- }
- secp256k1_fe_normalize_var(&z);
- /* Test storage conversion and conditional moves. */
- secp256k1_fe_to_storage(&xs, &x);
- secp256k1_fe_to_storage(&ys, &y);
- secp256k1_fe_to_storage(&zs, &z);
- secp256k1_fe_storage_cmov(&zs, &xs, 0);
- secp256k1_fe_storage_cmov(&zs, &zs, 1);
- CHECK(memcmp(&xs, &zs, sizeof(xs)) != 0);
- secp256k1_fe_storage_cmov(&ys, &xs, 1);
- CHECK(memcmp(&xs, &ys, sizeof(xs)) == 0);
- secp256k1_fe_from_storage(&x, &xs);
- secp256k1_fe_from_storage(&y, &ys);
- secp256k1_fe_from_storage(&z, &zs);
- /* Test that mul_int, mul, and add agree. */
- secp256k1_fe_add(&y, &x);
- secp256k1_fe_add(&y, &x);
- z = x;
- secp256k1_fe_mul_int(&z, 3);
- CHECK(check_fe_equal(&y, &z));
- secp256k1_fe_add(&y, &x);
- secp256k1_fe_add(&z, &x);
- CHECK(check_fe_equal(&z, &y));
- z = x;
- secp256k1_fe_mul_int(&z, 5);
- secp256k1_fe_mul(&q, &x, &fe5);
- CHECK(check_fe_equal(&z, &q));
- secp256k1_fe_negate(&x, &x, 1);
- secp256k1_fe_add(&z, &x);
- secp256k1_fe_add(&q, &x);
- CHECK(check_fe_equal(&y, &z));
- CHECK(check_fe_equal(&q, &y));
- }
-}
-
-void run_field_inv(void) {
- secp256k1_fe x, xi, xii;
- int i;
- for (i = 0; i < 10*count; i++) {
- random_fe_non_zero(&x);
- secp256k1_fe_inv(&xi, &x);
- CHECK(check_fe_inverse(&x, &xi));
- secp256k1_fe_inv(&xii, &xi);
- CHECK(check_fe_equal(&x, &xii));
- }
-}
-
-void run_field_inv_var(void) {
- secp256k1_fe x, xi, xii;
- int i;
- for (i = 0; i < 10*count; i++) {
- random_fe_non_zero(&x);
- secp256k1_fe_inv_var(&xi, &x);
- CHECK(check_fe_inverse(&x, &xi));
- secp256k1_fe_inv_var(&xii, &xi);
- CHECK(check_fe_equal(&x, &xii));
- }
-}
-
-void run_field_inv_all_var(void) {
- secp256k1_fe x[16], xi[16], xii[16];
- int i;
- /* Check it's safe to call for 0 elements */
- secp256k1_fe_inv_all_var(xi, x, 0);
- for (i = 0; i < count; i++) {
- size_t j;
- size_t len = secp256k1_rand_int(15) + 1;
- for (j = 0; j < len; j++) {
- random_fe_non_zero(&x[j]);
- }
- secp256k1_fe_inv_all_var(xi, x, len);
- for (j = 0; j < len; j++) {
- CHECK(check_fe_inverse(&x[j], &xi[j]));
- }
- secp256k1_fe_inv_all_var(xii, xi, len);
- for (j = 0; j < len; j++) {
- CHECK(check_fe_equal(&x[j], &xii[j]));
- }
- }
-}
-
-void run_sqr(void) {
- secp256k1_fe x, s;
-
- {
- int i;
- secp256k1_fe_set_int(&x, 1);
- secp256k1_fe_negate(&x, &x, 1);
-
- for (i = 1; i <= 512; ++i) {
- secp256k1_fe_mul_int(&x, 2);
- secp256k1_fe_normalize(&x);
- secp256k1_fe_sqr(&s, &x);
- }
- }
-}
-
-void test_sqrt(const secp256k1_fe *a, const secp256k1_fe *k) {
- secp256k1_fe r1, r2;
- int v = secp256k1_fe_sqrt(&r1, a);
- CHECK((v == 0) == (k == NULL));
-
- if (k != NULL) {
- /* Check that the returned root is +/- the given known answer */
- secp256k1_fe_negate(&r2, &r1, 1);
- secp256k1_fe_add(&r1, k); secp256k1_fe_add(&r2, k);
- secp256k1_fe_normalize(&r1); secp256k1_fe_normalize(&r2);
- CHECK(secp256k1_fe_is_zero(&r1) || secp256k1_fe_is_zero(&r2));
- }
-}
-
-void run_sqrt(void) {
- secp256k1_fe ns, x, s, t;
- int i;
-
- /* Check sqrt(0) is 0 */
- secp256k1_fe_set_int(&x, 0);
- secp256k1_fe_sqr(&s, &x);
- test_sqrt(&s, &x);
-
- /* Check sqrt of small squares (and their negatives) */
- for (i = 1; i <= 100; i++) {
- secp256k1_fe_set_int(&x, i);
- secp256k1_fe_sqr(&s, &x);
- test_sqrt(&s, &x);
- secp256k1_fe_negate(&t, &s, 1);
- test_sqrt(&t, NULL);
- }
-
- /* Consistency checks for large random values */
- for (i = 0; i < 10; i++) {
- int j;
- random_fe_non_square(&ns);
- for (j = 0; j < count; j++) {
- random_fe(&x);
- secp256k1_fe_sqr(&s, &x);
- test_sqrt(&s, &x);
- secp256k1_fe_negate(&t, &s, 1);
- test_sqrt(&t, NULL);
- secp256k1_fe_mul(&t, &s, &ns);
- test_sqrt(&t, NULL);
- }
- }
-}
-
-/***** GROUP TESTS *****/
-
-void ge_equals_ge(const secp256k1_ge *a, const secp256k1_ge *b) {
- CHECK(a->infinity == b->infinity);
- if (a->infinity) {
- return;
- }
- CHECK(secp256k1_fe_equal_var(&a->x, &b->x));
- CHECK(secp256k1_fe_equal_var(&a->y, &b->y));
-}
-
-/* This compares jacobian points including their Z, not just their geometric meaning. */
-int gej_xyz_equals_gej(const secp256k1_gej *a, const secp256k1_gej *b) {
- secp256k1_gej a2;
- secp256k1_gej b2;
- int ret = 1;
- ret &= a->infinity == b->infinity;
- if (ret && !a->infinity) {
- a2 = *a;
- b2 = *b;
- secp256k1_fe_normalize(&a2.x);
- secp256k1_fe_normalize(&a2.y);
- secp256k1_fe_normalize(&a2.z);
- secp256k1_fe_normalize(&b2.x);
- secp256k1_fe_normalize(&b2.y);
- secp256k1_fe_normalize(&b2.z);
- ret &= secp256k1_fe_cmp_var(&a2.x, &b2.x) == 0;
- ret &= secp256k1_fe_cmp_var(&a2.y, &b2.y) == 0;
- ret &= secp256k1_fe_cmp_var(&a2.z, &b2.z) == 0;
- }
- return ret;
-}
-
-void ge_equals_gej(const secp256k1_ge *a, const secp256k1_gej *b) {
- secp256k1_fe z2s;
- secp256k1_fe u1, u2, s1, s2;
- CHECK(a->infinity == b->infinity);
- if (a->infinity) {
- return;
- }
- /* Check a.x * b.z^2 == b.x && a.y * b.z^3 == b.y, to avoid inverses. */
- secp256k1_fe_sqr(&z2s, &b->z);
- secp256k1_fe_mul(&u1, &a->x, &z2s);
- u2 = b->x; secp256k1_fe_normalize_weak(&u2);
- secp256k1_fe_mul(&s1, &a->y, &z2s); secp256k1_fe_mul(&s1, &s1, &b->z);
- s2 = b->y; secp256k1_fe_normalize_weak(&s2);
- CHECK(secp256k1_fe_equal_var(&u1, &u2));
- CHECK(secp256k1_fe_equal_var(&s1, &s2));
-}
-
-void test_ge(void) {
- int i, i1;
-#ifdef USE_ENDOMORPHISM
- int runs = 6;
-#else
- int runs = 4;
-#endif
- /* Points: (infinity, p1, p1, -p1, -p1, p2, p2, -p2, -p2, p3, p3, -p3, -p3, p4, p4, -p4, -p4).
- * The second in each pair of identical points uses a random Z coordinate in the Jacobian form.
- * All magnitudes are randomized.
- * All 17*17 combinations of points are added to each other, using all applicable methods.
- *
- * When the endomorphism code is compiled in, p5 = lambda*p1 and p6 = lambda^2*p1 are added as well.
- */
- secp256k1_ge *ge = (secp256k1_ge *)malloc(sizeof(secp256k1_ge) * (1 + 4 * runs));
- secp256k1_gej *gej = (secp256k1_gej *)malloc(sizeof(secp256k1_gej) * (1 + 4 * runs));
- secp256k1_fe *zinv = (secp256k1_fe *)malloc(sizeof(secp256k1_fe) * (1 + 4 * runs));
- secp256k1_fe zf;
- secp256k1_fe zfi2, zfi3;
-
- secp256k1_gej_set_infinity(&gej[0]);
- secp256k1_ge_clear(&ge[0]);
- secp256k1_ge_set_gej_var(&ge[0], &gej[0]);
- for (i = 0; i < runs; i++) {
- int j;
- secp256k1_ge g;
- random_group_element_test(&g);
-#ifdef USE_ENDOMORPHISM
- if (i >= runs - 2) {
- secp256k1_ge_mul_lambda(&g, &ge[1]);
- }
- if (i >= runs - 1) {
- secp256k1_ge_mul_lambda(&g, &g);
- }
-#endif
- ge[1 + 4 * i] = g;
- ge[2 + 4 * i] = g;
- secp256k1_ge_neg(&ge[3 + 4 * i], &g);
- secp256k1_ge_neg(&ge[4 + 4 * i], &g);
- secp256k1_gej_set_ge(&gej[1 + 4 * i], &ge[1 + 4 * i]);
- random_group_element_jacobian_test(&gej[2 + 4 * i], &ge[2 + 4 * i]);
- secp256k1_gej_set_ge(&gej[3 + 4 * i], &ge[3 + 4 * i]);
- random_group_element_jacobian_test(&gej[4 + 4 * i], &ge[4 + 4 * i]);
- for (j = 0; j < 4; j++) {
- random_field_element_magnitude(&ge[1 + j + 4 * i].x);
- random_field_element_magnitude(&ge[1 + j + 4 * i].y);
- random_field_element_magnitude(&gej[1 + j + 4 * i].x);
- random_field_element_magnitude(&gej[1 + j + 4 * i].y);
- random_field_element_magnitude(&gej[1 + j + 4 * i].z);
- }
- }
-
- /* Compute z inverses. */
- {
- secp256k1_fe *zs = malloc(sizeof(secp256k1_fe) * (1 + 4 * runs));
- for (i = 0; i < 4 * runs + 1; i++) {
- if (i == 0) {
- /* The point at infinity does not have a meaningful z inverse. Any should do. */
- do {
- random_field_element_test(&zs[i]);
- } while(secp256k1_fe_is_zero(&zs[i]));
- } else {
- zs[i] = gej[i].z;
- }
- }
- secp256k1_fe_inv_all_var(zinv, zs, 4 * runs + 1);
- free(zs);
- }
-
- /* Generate random zf, and zfi2 = 1/zf^2, zfi3 = 1/zf^3 */
- do {
- random_field_element_test(&zf);
- } while(secp256k1_fe_is_zero(&zf));
- random_field_element_magnitude(&zf);
- secp256k1_fe_inv_var(&zfi3, &zf);
- secp256k1_fe_sqr(&zfi2, &zfi3);
- secp256k1_fe_mul(&zfi3, &zfi3, &zfi2);
-
- for (i1 = 0; i1 < 1 + 4 * runs; i1++) {
- int i2;
- for (i2 = 0; i2 < 1 + 4 * runs; i2++) {
- /* Compute reference result using gej + gej (var). */
- secp256k1_gej refj, resj;
- secp256k1_ge ref;
- secp256k1_fe zr;
- secp256k1_gej_add_var(&refj, &gej[i1], &gej[i2], secp256k1_gej_is_infinity(&gej[i1]) ? NULL : &zr);
- /* Check Z ratio. */
- if (!secp256k1_gej_is_infinity(&gej[i1]) && !secp256k1_gej_is_infinity(&refj)) {
- secp256k1_fe zrz; secp256k1_fe_mul(&zrz, &zr, &gej[i1].z);
- CHECK(secp256k1_fe_equal_var(&zrz, &refj.z));
- }
- secp256k1_ge_set_gej_var(&ref, &refj);
-
- /* Test gej + ge with Z ratio result (var). */
- secp256k1_gej_add_ge_var(&resj, &gej[i1], &ge[i2], secp256k1_gej_is_infinity(&gej[i1]) ? NULL : &zr);
- ge_equals_gej(&ref, &resj);
- if (!secp256k1_gej_is_infinity(&gej[i1]) && !secp256k1_gej_is_infinity(&resj)) {
- secp256k1_fe zrz; secp256k1_fe_mul(&zrz, &zr, &gej[i1].z);
- CHECK(secp256k1_fe_equal_var(&zrz, &resj.z));
- }
-
- /* Test gej + ge (var, with additional Z factor). */
- {
- secp256k1_ge ge2_zfi = ge[i2]; /* the second term with x and y rescaled for z = 1/zf */
- secp256k1_fe_mul(&ge2_zfi.x, &ge2_zfi.x, &zfi2);
- secp256k1_fe_mul(&ge2_zfi.y, &ge2_zfi.y, &zfi3);
- random_field_element_magnitude(&ge2_zfi.x);
- random_field_element_magnitude(&ge2_zfi.y);
- secp256k1_gej_add_zinv_var(&resj, &gej[i1], &ge2_zfi, &zf);
- ge_equals_gej(&ref, &resj);
- }
-
- /* Test gej + ge (const). */
- if (i2 != 0) {
- /* secp256k1_gej_add_ge does not support its second argument being infinity. */
- secp256k1_gej_add_ge(&resj, &gej[i1], &ge[i2]);
- ge_equals_gej(&ref, &resj);
- }
-
- /* Test doubling (var). */
- if ((i1 == 0 && i2 == 0) || ((i1 + 3)/4 == (i2 + 3)/4 && ((i1 + 3)%4)/2 == ((i2 + 3)%4)/2)) {
- secp256k1_fe zr2;
- /* Normal doubling with Z ratio result. */
- secp256k1_gej_double_var(&resj, &gej[i1], &zr2);
- ge_equals_gej(&ref, &resj);
- /* Check Z ratio. */
- secp256k1_fe_mul(&zr2, &zr2, &gej[i1].z);
- CHECK(secp256k1_fe_equal_var(&zr2, &resj.z));
- /* Normal doubling. */
- secp256k1_gej_double_var(&resj, &gej[i2], NULL);
- ge_equals_gej(&ref, &resj);
- }
-
- /* Test adding opposites. */
- if ((i1 == 0 && i2 == 0) || ((i1 + 3)/4 == (i2 + 3)/4 && ((i1 + 3)%4)/2 != ((i2 + 3)%4)/2)) {
- CHECK(secp256k1_ge_is_infinity(&ref));
- }
-
- /* Test adding infinity. */
- if (i1 == 0) {
- CHECK(secp256k1_ge_is_infinity(&ge[i1]));
- CHECK(secp256k1_gej_is_infinity(&gej[i1]));
- ge_equals_gej(&ref, &gej[i2]);
- }
- if (i2 == 0) {
- CHECK(secp256k1_ge_is_infinity(&ge[i2]));
- CHECK(secp256k1_gej_is_infinity(&gej[i2]));
- ge_equals_gej(&ref, &gej[i1]);
- }
- }
- }
-
- /* Test adding all points together in random order equals infinity. */
- {
- secp256k1_gej sum = SECP256K1_GEJ_CONST_INFINITY;
- secp256k1_gej *gej_shuffled = (secp256k1_gej *)malloc((4 * runs + 1) * sizeof(secp256k1_gej));
- for (i = 0; i < 4 * runs + 1; i++) {
- gej_shuffled[i] = gej[i];
- }
- for (i = 0; i < 4 * runs + 1; i++) {
- int swap = i + secp256k1_rand_int(4 * runs + 1 - i);
- if (swap != i) {
- secp256k1_gej t = gej_shuffled[i];
- gej_shuffled[i] = gej_shuffled[swap];
- gej_shuffled[swap] = t;
- }
- }
- for (i = 0; i < 4 * runs + 1; i++) {
- secp256k1_gej_add_var(&sum, &sum, &gej_shuffled[i], NULL);
- }
- CHECK(secp256k1_gej_is_infinity(&sum));
- free(gej_shuffled);
- }
-
- /* Test batch gej -> ge conversion with and without known z ratios. */
- {
- secp256k1_fe *zr = (secp256k1_fe *)malloc((4 * runs + 1) * sizeof(secp256k1_fe));
- secp256k1_ge *ge_set_table = (secp256k1_ge *)malloc((4 * runs + 1) * sizeof(secp256k1_ge));
- secp256k1_ge *ge_set_all = (secp256k1_ge *)malloc((4 * runs + 1) * sizeof(secp256k1_ge));
- for (i = 0; i < 4 * runs + 1; i++) {
- /* Compute gej[i + 1].z / gez[i].z (with gej[n].z taken to be 1). */
- if (i < 4 * runs) {
- secp256k1_fe_mul(&zr[i + 1], &zinv[i], &gej[i + 1].z);
- }
- }
- secp256k1_ge_set_table_gej_var(ge_set_table, gej, zr, 4 * runs + 1);
- secp256k1_ge_set_all_gej_var(ge_set_all, gej, 4 * runs + 1, &ctx->error_callback);
- for (i = 0; i < 4 * runs + 1; i++) {
- secp256k1_fe s;
- random_fe_non_zero(&s);
- secp256k1_gej_rescale(&gej[i], &s);
- ge_equals_gej(&ge_set_table[i], &gej[i]);
- ge_equals_gej(&ge_set_all[i], &gej[i]);
- }
- free(ge_set_table);
- free(ge_set_all);
- free(zr);
- }
-
- free(ge);
- free(gej);
- free(zinv);
-}
-
-void test_add_neg_y_diff_x(void) {
- /* The point of this test is to check that we can add two points
- * whose y-coordinates are negatives of each other but whose x
- * coordinates differ. If the x-coordinates were the same, these
- * points would be negatives of each other and their sum is
- * infinity. This is cool because it "covers up" any degeneracy
- * in the addition algorithm that would cause the xy coordinates
- * of the sum to be wrong (since infinity has no xy coordinates).
- * HOWEVER, if the x-coordinates are different, infinity is the
- * wrong answer, and such degeneracies are exposed. This is the
- * root of https://github.com/bitcoin-core/secp256k1/issues/257
- * which this test is a regression test for.
- *
- * These points were generated in sage as
- * # secp256k1 params
- * F = FiniteField (0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
- * C = EllipticCurve ([F (0), F (7)])
- * G = C.lift_x(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
- * N = FiniteField(G.order())
- *
- * # endomorphism values (lambda is 1^{1/3} in N, beta is 1^{1/3} in F)
- * x = polygen(N)
- * lam = (1 - x^3).roots()[1][0]
- *
- * # random "bad pair"
- * P = C.random_element()
- * Q = -int(lam) * P
- * print " P: %x %x" % P.xy()
- * print " Q: %x %x" % Q.xy()
- * print "P + Q: %x %x" % (P + Q).xy()
- */
- secp256k1_gej aj = SECP256K1_GEJ_CONST(
- 0x8d24cd95, 0x0a355af1, 0x3c543505, 0x44238d30,
- 0x0643d79f, 0x05a59614, 0x2f8ec030, 0xd58977cb,
- 0x001e337a, 0x38093dcd, 0x6c0f386d, 0x0b1293a8,
- 0x4d72c879, 0xd7681924, 0x44e6d2f3, 0x9190117d
- );
- secp256k1_gej bj = SECP256K1_GEJ_CONST(
- 0xc7b74206, 0x1f788cd9, 0xabd0937d, 0x164a0d86,
- 0x95f6ff75, 0xf19a4ce9, 0xd013bd7b, 0xbf92d2a7,
- 0xffe1cc85, 0xc7f6c232, 0x93f0c792, 0xf4ed6c57,
- 0xb28d3786, 0x2897e6db, 0xbb192d0b, 0x6e6feab2
- );
- secp256k1_gej sumj = SECP256K1_GEJ_CONST(
- 0x671a63c0, 0x3efdad4c, 0x389a7798, 0x24356027,
- 0xb3d69010, 0x278625c3, 0x5c86d390, 0x184a8f7a,
- 0x5f6409c2, 0x2ce01f2b, 0x511fd375, 0x25071d08,
- 0xda651801, 0x70e95caf, 0x8f0d893c, 0xbed8fbbe
- );
- secp256k1_ge b;
- secp256k1_gej resj;
- secp256k1_ge res;
- secp256k1_ge_set_gej(&b, &bj);
-
- secp256k1_gej_add_var(&resj, &aj, &bj, NULL);
- secp256k1_ge_set_gej(&res, &resj);
- ge_equals_gej(&res, &sumj);
-
- secp256k1_gej_add_ge(&resj, &aj, &b);
- secp256k1_ge_set_gej(&res, &resj);
- ge_equals_gej(&res, &sumj);
-
- secp256k1_gej_add_ge_var(&resj, &aj, &b, NULL);
- secp256k1_ge_set_gej(&res, &resj);
- ge_equals_gej(&res, &sumj);
-}
-
-void run_ge(void) {
- int i;
- for (i = 0; i < count * 32; i++) {
- test_ge();
- }
- test_add_neg_y_diff_x();
-}
-
-void test_ec_combine(void) {
- secp256k1_scalar sum = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
- secp256k1_pubkey data[6];
- const secp256k1_pubkey* d[6];
- secp256k1_pubkey sd;
- secp256k1_pubkey sd2;
- secp256k1_gej Qj;
- secp256k1_ge Q;
- int i;
- for (i = 1; i <= 6; i++) {
- secp256k1_scalar s;
- random_scalar_order_test(&s);
- secp256k1_scalar_add(&sum, &sum, &s);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &Qj, &s);
- secp256k1_ge_set_gej(&Q, &Qj);
- secp256k1_pubkey_save(&data[i - 1], &Q);
- d[i - 1] = &data[i - 1];
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &Qj, &sum);
- secp256k1_ge_set_gej(&Q, &Qj);
- secp256k1_pubkey_save(&sd, &Q);
- CHECK(secp256k1_ec_pubkey_combine(ctx, &sd2, d, i) == 1);
- CHECK(memcmp(&sd, &sd2, sizeof(sd)) == 0);
- }
-}
-
-void run_ec_combine(void) {
- int i;
- for (i = 0; i < count * 8; i++) {
- test_ec_combine();
- }
-}
-
-void test_group_decompress(const secp256k1_fe* x) {
- /* The input itself, normalized. */
- secp256k1_fe fex = *x;
- secp256k1_fe fez;
- /* Results of set_xquad_var, set_xo_var(..., 0), set_xo_var(..., 1). */
- secp256k1_ge ge_quad, ge_even, ge_odd;
- secp256k1_gej gej_quad;
- /* Return values of the above calls. */
- int res_quad, res_even, res_odd;
-
- secp256k1_fe_normalize_var(&fex);
-
- res_quad = secp256k1_ge_set_xquad(&ge_quad, &fex);
- res_even = secp256k1_ge_set_xo_var(&ge_even, &fex, 0);
- res_odd = secp256k1_ge_set_xo_var(&ge_odd, &fex, 1);
-
- CHECK(res_quad == res_even);
- CHECK(res_quad == res_odd);
-
- if (res_quad) {
- secp256k1_fe_normalize_var(&ge_quad.x);
- secp256k1_fe_normalize_var(&ge_odd.x);
- secp256k1_fe_normalize_var(&ge_even.x);
- secp256k1_fe_normalize_var(&ge_quad.y);
- secp256k1_fe_normalize_var(&ge_odd.y);
- secp256k1_fe_normalize_var(&ge_even.y);
-
- /* No infinity allowed. */
- CHECK(!ge_quad.infinity);
- CHECK(!ge_even.infinity);
- CHECK(!ge_odd.infinity);
-
- /* Check that the x coordinates check out. */
- CHECK(secp256k1_fe_equal_var(&ge_quad.x, x));
- CHECK(secp256k1_fe_equal_var(&ge_even.x, x));
- CHECK(secp256k1_fe_equal_var(&ge_odd.x, x));
-
- /* Check that the Y coordinate result in ge_quad is a square. */
- CHECK(secp256k1_fe_is_quad_var(&ge_quad.y));
-
- /* Check odd/even Y in ge_odd, ge_even. */
- CHECK(secp256k1_fe_is_odd(&ge_odd.y));
- CHECK(!secp256k1_fe_is_odd(&ge_even.y));
-
- /* Check secp256k1_gej_has_quad_y_var. */
- secp256k1_gej_set_ge(&gej_quad, &ge_quad);
- CHECK(secp256k1_gej_has_quad_y_var(&gej_quad));
- do {
- random_fe_test(&fez);
- } while (secp256k1_fe_is_zero(&fez));
- secp256k1_gej_rescale(&gej_quad, &fez);
- CHECK(secp256k1_gej_has_quad_y_var(&gej_quad));
- secp256k1_gej_neg(&gej_quad, &gej_quad);
- CHECK(!secp256k1_gej_has_quad_y_var(&gej_quad));
- do {
- random_fe_test(&fez);
- } while (secp256k1_fe_is_zero(&fez));
- secp256k1_gej_rescale(&gej_quad, &fez);
- CHECK(!secp256k1_gej_has_quad_y_var(&gej_quad));
- secp256k1_gej_neg(&gej_quad, &gej_quad);
- CHECK(secp256k1_gej_has_quad_y_var(&gej_quad));
- }
-}
-
-void run_group_decompress(void) {
- int i;
- for (i = 0; i < count * 4; i++) {
- secp256k1_fe fe;
- random_fe_test(&fe);
- test_group_decompress(&fe);
- }
-}
-
-/***** ECMULT TESTS *****/
-
-void run_ecmult_chain(void) {
- /* random starting point A (on the curve) */
- secp256k1_gej a = SECP256K1_GEJ_CONST(
- 0x8b30bbe9, 0xae2a9906, 0x96b22f67, 0x0709dff3,
- 0x727fd8bc, 0x04d3362c, 0x6c7bf458, 0xe2846004,
- 0xa357ae91, 0x5c4a6528, 0x1309edf2, 0x0504740f,
- 0x0eb33439, 0x90216b4f, 0x81063cb6, 0x5f2f7e0f
- );
- /* two random initial factors xn and gn */
- secp256k1_scalar xn = SECP256K1_SCALAR_CONST(
- 0x84cc5452, 0xf7fde1ed, 0xb4d38a8c, 0xe9b1b84c,
- 0xcef31f14, 0x6e569be9, 0x705d357a, 0x42985407
- );
- secp256k1_scalar gn = SECP256K1_SCALAR_CONST(
- 0xa1e58d22, 0x553dcd42, 0xb2398062, 0x5d4c57a9,
- 0x6e9323d4, 0x2b3152e5, 0xca2c3990, 0xedc7c9de
- );
- /* two small multipliers to be applied to xn and gn in every iteration: */
- static const secp256k1_scalar xf = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0x1337);
- static const secp256k1_scalar gf = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0x7113);
- /* accumulators with the resulting coefficients to A and G */
- secp256k1_scalar ae = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 1);
- secp256k1_scalar ge = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
- /* actual points */
- secp256k1_gej x;
- secp256k1_gej x2;
- int i;
-
- /* the point being computed */
- x = a;
- for (i = 0; i < 200*count; i++) {
- /* in each iteration, compute X = xn*X + gn*G; */
- secp256k1_ecmult(&ctx->ecmult_ctx, &x, &x, &xn, &gn);
- /* also compute ae and ge: the actual accumulated factors for A and G */
- /* if X was (ae*A+ge*G), xn*X + gn*G results in (xn*ae*A + (xn*ge+gn)*G) */
- secp256k1_scalar_mul(&ae, &ae, &xn);
- secp256k1_scalar_mul(&ge, &ge, &xn);
- secp256k1_scalar_add(&ge, &ge, &gn);
- /* modify xn and gn */
- secp256k1_scalar_mul(&xn, &xn, &xf);
- secp256k1_scalar_mul(&gn, &gn, &gf);
-
- /* verify */
- if (i == 19999) {
- /* expected result after 19999 iterations */
- secp256k1_gej rp = SECP256K1_GEJ_CONST(
- 0xD6E96687, 0xF9B10D09, 0x2A6F3543, 0x9D86CEBE,
- 0xA4535D0D, 0x409F5358, 0x6440BD74, 0xB933E830,
- 0xB95CBCA2, 0xC77DA786, 0x539BE8FD, 0x53354D2D,
- 0x3B4F566A, 0xE6580454, 0x07ED6015, 0xEE1B2A88
- );
-
- secp256k1_gej_neg(&rp, &rp);
- secp256k1_gej_add_var(&rp, &rp, &x, NULL);
- CHECK(secp256k1_gej_is_infinity(&rp));
- }
- }
- /* redo the computation, but directly with the resulting ae and ge coefficients: */
- secp256k1_ecmult(&ctx->ecmult_ctx, &x2, &a, &ae, &ge);
- secp256k1_gej_neg(&x2, &x2);
- secp256k1_gej_add_var(&x2, &x2, &x, NULL);
- CHECK(secp256k1_gej_is_infinity(&x2));
-}
-
-void test_point_times_order(const secp256k1_gej *point) {
- /* X * (point + G) + (order-X) * (pointer + G) = 0 */
- secp256k1_scalar x;
- secp256k1_scalar nx;
- secp256k1_scalar zero = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
- secp256k1_scalar one = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 1);
- secp256k1_gej res1, res2;
- secp256k1_ge res3;
- unsigned char pub[65];
- size_t psize = 65;
- random_scalar_order_test(&x);
- secp256k1_scalar_negate(&nx, &x);
- secp256k1_ecmult(&ctx->ecmult_ctx, &res1, point, &x, &x); /* calc res1 = x * point + x * G; */
- secp256k1_ecmult(&ctx->ecmult_ctx, &res2, point, &nx, &nx); /* calc res2 = (order - x) * point + (order - x) * G; */
- secp256k1_gej_add_var(&res1, &res1, &res2, NULL);
- CHECK(secp256k1_gej_is_infinity(&res1));
- CHECK(secp256k1_gej_is_valid_var(&res1) == 0);
- secp256k1_ge_set_gej(&res3, &res1);
- CHECK(secp256k1_ge_is_infinity(&res3));
- CHECK(secp256k1_ge_is_valid_var(&res3) == 0);
- CHECK(secp256k1_eckey_pubkey_serialize(&res3, pub, &psize, 0) == 0);
- psize = 65;
- CHECK(secp256k1_eckey_pubkey_serialize(&res3, pub, &psize, 1) == 0);
- /* check zero/one edge cases */
- secp256k1_ecmult(&ctx->ecmult_ctx, &res1, point, &zero, &zero);
- secp256k1_ge_set_gej(&res3, &res1);
- CHECK(secp256k1_ge_is_infinity(&res3));
- secp256k1_ecmult(&ctx->ecmult_ctx, &res1, point, &one, &zero);
- secp256k1_ge_set_gej(&res3, &res1);
- ge_equals_gej(&res3, point);
- secp256k1_ecmult(&ctx->ecmult_ctx, &res1, point, &zero, &one);
- secp256k1_ge_set_gej(&res3, &res1);
- ge_equals_ge(&res3, &secp256k1_ge_const_g);
-}
-
-void run_point_times_order(void) {
- int i;
- secp256k1_fe x = SECP256K1_FE_CONST(0, 0, 0, 0, 0, 0, 0, 2);
- static const secp256k1_fe xr = SECP256K1_FE_CONST(
- 0x7603CB59, 0xB0EF6C63, 0xFE608479, 0x2A0C378C,
- 0xDB3233A8, 0x0F8A9A09, 0xA877DEAD, 0x31B38C45
- );
- for (i = 0; i < 500; i++) {
- secp256k1_ge p;
- if (secp256k1_ge_set_xo_var(&p, &x, 1)) {
- secp256k1_gej j;
- CHECK(secp256k1_ge_is_valid_var(&p));
- secp256k1_gej_set_ge(&j, &p);
- CHECK(secp256k1_gej_is_valid_var(&j));
- test_point_times_order(&j);
- }
- secp256k1_fe_sqr(&x, &x);
- }
- secp256k1_fe_normalize_var(&x);
- CHECK(secp256k1_fe_equal_var(&x, &xr));
-}
-
-void ecmult_const_random_mult(void) {
- /* random starting point A (on the curve) */
- secp256k1_ge a = SECP256K1_GE_CONST(
- 0x6d986544, 0x57ff52b8, 0xcf1b8126, 0x5b802a5b,
- 0xa97f9263, 0xb1e88044, 0x93351325, 0x91bc450a,
- 0x535c59f7, 0x325e5d2b, 0xc391fbe8, 0x3c12787c,
- 0x337e4a98, 0xe82a9011, 0x0123ba37, 0xdd769c7d
- );
- /* random initial factor xn */
- secp256k1_scalar xn = SECP256K1_SCALAR_CONST(
- 0x649d4f77, 0xc4242df7, 0x7f2079c9, 0x14530327,
- 0xa31b876a, 0xd2d8ce2a, 0x2236d5c6, 0xd7b2029b
- );
- /* expected xn * A (from sage) */
- secp256k1_ge expected_b = SECP256K1_GE_CONST(
- 0x23773684, 0x4d209dc7, 0x098a786f, 0x20d06fcd,
- 0x070a38bf, 0xc11ac651, 0x03004319, 0x1e2a8786,
- 0xed8c3b8e, 0xc06dd57b, 0xd06ea66e, 0x45492b0f,
- 0xb84e4e1b, 0xfb77e21f, 0x96baae2a, 0x63dec956
- );
- secp256k1_gej b;
- secp256k1_ecmult_const(&b, &a, &xn);
-
- CHECK(secp256k1_ge_is_valid_var(&a));
- ge_equals_gej(&expected_b, &b);
-}
-
-void ecmult_const_commutativity(void) {
- secp256k1_scalar a;
- secp256k1_scalar b;
- secp256k1_gej res1;
- secp256k1_gej res2;
- secp256k1_ge mid1;
- secp256k1_ge mid2;
- random_scalar_order_test(&a);
- random_scalar_order_test(&b);
-
- secp256k1_ecmult_const(&res1, &secp256k1_ge_const_g, &a);
- secp256k1_ecmult_const(&res2, &secp256k1_ge_const_g, &b);
- secp256k1_ge_set_gej(&mid1, &res1);
- secp256k1_ge_set_gej(&mid2, &res2);
- secp256k1_ecmult_const(&res1, &mid1, &b);
- secp256k1_ecmult_const(&res2, &mid2, &a);
- secp256k1_ge_set_gej(&mid1, &res1);
- secp256k1_ge_set_gej(&mid2, &res2);
- ge_equals_ge(&mid1, &mid2);
-}
-
-void ecmult_const_mult_zero_one(void) {
- secp256k1_scalar zero = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
- secp256k1_scalar one = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 1);
- secp256k1_scalar negone;
- secp256k1_gej res1;
- secp256k1_ge res2;
- secp256k1_ge point;
- secp256k1_scalar_negate(&negone, &one);
-
- random_group_element_test(&point);
- secp256k1_ecmult_const(&res1, &point, &zero);
- secp256k1_ge_set_gej(&res2, &res1);
- CHECK(secp256k1_ge_is_infinity(&res2));
- secp256k1_ecmult_const(&res1, &point, &one);
- secp256k1_ge_set_gej(&res2, &res1);
- ge_equals_ge(&res2, &point);
- secp256k1_ecmult_const(&res1, &point, &negone);
- secp256k1_gej_neg(&res1, &res1);
- secp256k1_ge_set_gej(&res2, &res1);
- ge_equals_ge(&res2, &point);
-}
-
-void ecmult_const_chain_multiply(void) {
- /* Check known result (randomly generated test problem from sage) */
- const secp256k1_scalar scalar = SECP256K1_SCALAR_CONST(
- 0x4968d524, 0x2abf9b7a, 0x466abbcf, 0x34b11b6d,
- 0xcd83d307, 0x827bed62, 0x05fad0ce, 0x18fae63b
- );
- const secp256k1_gej expected_point = SECP256K1_GEJ_CONST(
- 0x5494c15d, 0x32099706, 0xc2395f94, 0x348745fd,
- 0x757ce30e, 0x4e8c90fb, 0xa2bad184, 0xf883c69f,
- 0x5d195d20, 0xe191bf7f, 0x1be3e55f, 0x56a80196,
- 0x6071ad01, 0xf1462f66, 0xc997fa94, 0xdb858435
- );
- secp256k1_gej point;
- secp256k1_ge res;
- int i;
-
- secp256k1_gej_set_ge(&point, &secp256k1_ge_const_g);
- for (i = 0; i < 100; ++i) {
- secp256k1_ge tmp;
- secp256k1_ge_set_gej(&tmp, &point);
- secp256k1_ecmult_const(&point, &tmp, &scalar);
- }
- secp256k1_ge_set_gej(&res, &point);
- ge_equals_gej(&res, &expected_point);
-}
-
-void run_ecmult_const_tests(void) {
- ecmult_const_mult_zero_one();
- ecmult_const_random_mult();
- ecmult_const_commutativity();
- ecmult_const_chain_multiply();
-}
-
-void test_wnaf(const secp256k1_scalar *number, int w) {
- secp256k1_scalar x, two, t;
- int wnaf[256];
- int zeroes = -1;
- int i;
- int bits;
- secp256k1_scalar_set_int(&x, 0);
- secp256k1_scalar_set_int(&two, 2);
- bits = secp256k1_ecmult_wnaf(wnaf, 256, number, w);
- CHECK(bits <= 256);
- for (i = bits-1; i >= 0; i--) {
- int v = wnaf[i];
- secp256k1_scalar_mul(&x, &x, &two);
- if (v) {
- CHECK(zeroes == -1 || zeroes >= w-1); /* check that distance between non-zero elements is at least w-1 */
- zeroes=0;
- CHECK((v & 1) == 1); /* check non-zero elements are odd */
- CHECK(v <= (1 << (w-1)) - 1); /* check range below */
- CHECK(v >= -(1 << (w-1)) - 1); /* check range above */
- } else {
- CHECK(zeroes != -1); /* check that no unnecessary zero padding exists */
- zeroes++;
- }
- if (v >= 0) {
- secp256k1_scalar_set_int(&t, v);
- } else {
- secp256k1_scalar_set_int(&t, -v);
- secp256k1_scalar_negate(&t, &t);
- }
- secp256k1_scalar_add(&x, &x, &t);
- }
- CHECK(secp256k1_scalar_eq(&x, number)); /* check that wnaf represents number */
-}
-
-void test_constant_wnaf_negate(const secp256k1_scalar *number) {
- secp256k1_scalar neg1 = *number;
- secp256k1_scalar neg2 = *number;
- int sign1 = 1;
- int sign2 = 1;
-
- if (!secp256k1_scalar_get_bits(&neg1, 0, 1)) {
- secp256k1_scalar_negate(&neg1, &neg1);
- sign1 = -1;
- }
- sign2 = secp256k1_scalar_cond_negate(&neg2, secp256k1_scalar_is_even(&neg2));
- CHECK(sign1 == sign2);
- CHECK(secp256k1_scalar_eq(&neg1, &neg2));
-}
-
-void test_constant_wnaf(const secp256k1_scalar *number, int w) {
- secp256k1_scalar x, shift;
- int wnaf[256] = {0};
- int i;
- int skew;
- secp256k1_scalar num = *number;
-
- secp256k1_scalar_set_int(&x, 0);
- secp256k1_scalar_set_int(&shift, 1 << w);
- /* With USE_ENDOMORPHISM on we only consider 128-bit numbers */
-#ifdef USE_ENDOMORPHISM
- for (i = 0; i < 16; ++i) {
- secp256k1_scalar_shr_int(&num, 8);
- }
-#endif
- skew = secp256k1_wnaf_const(wnaf, num, w);
-
- for (i = WNAF_SIZE(w); i >= 0; --i) {
- secp256k1_scalar t;
- int v = wnaf[i];
- CHECK(v != 0); /* check nonzero */
- CHECK(v & 1); /* check parity */
- CHECK(v > -(1 << w)); /* check range above */
- CHECK(v < (1 << w)); /* check range below */
-
- secp256k1_scalar_mul(&x, &x, &shift);
- if (v >= 0) {
- secp256k1_scalar_set_int(&t, v);
- } else {
- secp256k1_scalar_set_int(&t, -v);
- secp256k1_scalar_negate(&t, &t);
- }
- secp256k1_scalar_add(&x, &x, &t);
- }
- /* Skew num because when encoding numbers as odd we use an offset */
- secp256k1_scalar_cadd_bit(&num, skew == 2, 1);
- CHECK(secp256k1_scalar_eq(&x, &num));
-}
-
-void run_wnaf(void) {
- int i;
- secp256k1_scalar n = {{0}};
-
- /* Sanity check: 1 and 2 are the smallest odd and even numbers and should
- * have easier-to-diagnose failure modes */
- n.d[0] = 1;
- test_constant_wnaf(&n, 4);
- n.d[0] = 2;
- test_constant_wnaf(&n, 4);
- /* Random tests */
- for (i = 0; i < count; i++) {
- random_scalar_order(&n);
- test_wnaf(&n, 4+(i%10));
- test_constant_wnaf_negate(&n);
- test_constant_wnaf(&n, 4 + (i % 10));
- }
- secp256k1_scalar_set_int(&n, 0);
- CHECK(secp256k1_scalar_cond_negate(&n, 1) == -1);
- CHECK(secp256k1_scalar_is_zero(&n));
- CHECK(secp256k1_scalar_cond_negate(&n, 0) == 1);
- CHECK(secp256k1_scalar_is_zero(&n));
-}
-
-void test_ecmult_constants(void) {
- /* Test ecmult_gen() for [0..36) and [order-36..0). */
- secp256k1_scalar x;
- secp256k1_gej r;
- secp256k1_ge ng;
- int i;
- int j;
- secp256k1_ge_neg(&ng, &secp256k1_ge_const_g);
- for (i = 0; i < 36; i++ ) {
- secp256k1_scalar_set_int(&x, i);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &r, &x);
- for (j = 0; j < i; j++) {
- if (j == i - 1) {
- ge_equals_gej(&secp256k1_ge_const_g, &r);
- }
- secp256k1_gej_add_ge(&r, &r, &ng);
- }
- CHECK(secp256k1_gej_is_infinity(&r));
- }
- for (i = 1; i <= 36; i++ ) {
- secp256k1_scalar_set_int(&x, i);
- secp256k1_scalar_negate(&x, &x);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &r, &x);
- for (j = 0; j < i; j++) {
- if (j == i - 1) {
- ge_equals_gej(&ng, &r);
- }
- secp256k1_gej_add_ge(&r, &r, &secp256k1_ge_const_g);
- }
- CHECK(secp256k1_gej_is_infinity(&r));
- }
-}
-
-void run_ecmult_constants(void) {
- test_ecmult_constants();
-}
-
-void test_ecmult_gen_blind(void) {
- /* Test ecmult_gen() blinding and confirm that the blinding changes, the affine points match, and the z's don't match. */
- secp256k1_scalar key;
- secp256k1_scalar b;
- unsigned char seed32[32];
- secp256k1_gej pgej;
- secp256k1_gej pgej2;
- secp256k1_gej i;
- secp256k1_ge pge;
- random_scalar_order_test(&key);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pgej, &key);
- secp256k1_rand256(seed32);
- b = ctx->ecmult_gen_ctx.blind;
- i = ctx->ecmult_gen_ctx.initial;
- secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, seed32);
- CHECK(!secp256k1_scalar_eq(&b, &ctx->ecmult_gen_ctx.blind));
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pgej2, &key);
- CHECK(!gej_xyz_equals_gej(&pgej, &pgej2));
- CHECK(!gej_xyz_equals_gej(&i, &ctx->ecmult_gen_ctx.initial));
- secp256k1_ge_set_gej(&pge, &pgej);
- ge_equals_gej(&pge, &pgej2);
-}
-
-void test_ecmult_gen_blind_reset(void) {
- /* Test ecmult_gen() blinding reset and confirm that the blinding is consistent. */
- secp256k1_scalar b;
- secp256k1_gej initial;
- secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, 0);
- b = ctx->ecmult_gen_ctx.blind;
- initial = ctx->ecmult_gen_ctx.initial;
- secp256k1_ecmult_gen_blind(&ctx->ecmult_gen_ctx, 0);
- CHECK(secp256k1_scalar_eq(&b, &ctx->ecmult_gen_ctx.blind));
- CHECK(gej_xyz_equals_gej(&initial, &ctx->ecmult_gen_ctx.initial));
-}
-
-void run_ecmult_gen_blind(void) {
- int i;
- test_ecmult_gen_blind_reset();
- for (i = 0; i < 10; i++) {
- test_ecmult_gen_blind();
- }
-}
-
-#ifdef USE_ENDOMORPHISM
-/***** ENDOMORPHISH TESTS *****/
-void test_scalar_split(void) {
- secp256k1_scalar full;
- secp256k1_scalar s1, slam;
- const unsigned char zero[32] = {0};
- unsigned char tmp[32];
-
- random_scalar_order_test(&full);
- secp256k1_scalar_split_lambda(&s1, &slam, &full);
-
- /* check that both are <= 128 bits in size */
- if (secp256k1_scalar_is_high(&s1)) {
- secp256k1_scalar_negate(&s1, &s1);
- }
- if (secp256k1_scalar_is_high(&slam)) {
- secp256k1_scalar_negate(&slam, &slam);
- }
-
- secp256k1_scalar_get_b32(tmp, &s1);
- CHECK(memcmp(zero, tmp, 16) == 0);
- secp256k1_scalar_get_b32(tmp, &slam);
- CHECK(memcmp(zero, tmp, 16) == 0);
-}
-
-void run_endomorphism_tests(void) {
- test_scalar_split();
-}
-#endif
-
-void ec_pubkey_parse_pointtest(const unsigned char *input, int xvalid, int yvalid) {
- unsigned char pubkeyc[65];
- secp256k1_pubkey pubkey;
- secp256k1_ge ge;
- size_t pubkeyclen;
- int32_t ecount;
- ecount = 0;
- secp256k1_context_set_illegal_callback(ctx, counting_illegal_callback_fn, &ecount);
- for (pubkeyclen = 3; pubkeyclen <= 65; pubkeyclen++) {
- /* Smaller sizes are tested exhaustively elsewhere. */
- int32_t i;
- memcpy(&pubkeyc[1], input, 64);
- VG_UNDEF(&pubkeyc[pubkeyclen], 65 - pubkeyclen);
- for (i = 0; i < 256; i++) {
- /* Try all type bytes. */
- int xpass;
- int ypass;
- int ysign;
- pubkeyc[0] = i;
- /* What sign does this point have? */
- ysign = (input[63] & 1) + 2;
- /* For the current type (i) do we expect parsing to work? Handled all of compressed/uncompressed/hybrid. */
- xpass = xvalid && (pubkeyclen == 33) && ((i & 254) == 2);
- /* Do we expect a parse and re-serialize as uncompressed to give a matching y? */
- ypass = xvalid && yvalid && ((i & 4) == ((pubkeyclen == 65) << 2)) &&
- ((i == 4) || ((i & 251) == ysign)) && ((pubkeyclen == 33) || (pubkeyclen == 65));
- if (xpass || ypass) {
- /* These cases must parse. */
- unsigned char pubkeyo[65];
- size_t outl;
- memset(&pubkey, 0, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- ecount = 0;
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, pubkeyclen) == 1);
- VG_CHECK(&pubkey, sizeof(pubkey));
- outl = 65;
- VG_UNDEF(pubkeyo, 65);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, pubkeyo, &outl, &pubkey, SECP256K1_EC_COMPRESSED) == 1);
- VG_CHECK(pubkeyo, outl);
- CHECK(outl == 33);
- CHECK(memcmp(&pubkeyo[1], &pubkeyc[1], 32) == 0);
- CHECK((pubkeyclen != 33) || (pubkeyo[0] == pubkeyc[0]));
- if (ypass) {
- /* This test isn't always done because we decode with alternative signs, so the y won't match. */
- CHECK(pubkeyo[0] == ysign);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 1);
- memset(&pubkey, 0, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- secp256k1_pubkey_save(&pubkey, &ge);
- VG_CHECK(&pubkey, sizeof(pubkey));
- outl = 65;
- VG_UNDEF(pubkeyo, 65);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, pubkeyo, &outl, &pubkey, SECP256K1_EC_UNCOMPRESSED) == 1);
- VG_CHECK(pubkeyo, outl);
- CHECK(outl == 65);
- CHECK(pubkeyo[0] == 4);
- CHECK(memcmp(&pubkeyo[1], input, 64) == 0);
- }
- CHECK(ecount == 0);
- } else {
- /* These cases must fail to parse. */
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, pubkeyclen) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- }
- }
- }
- secp256k1_context_set_illegal_callback(ctx, NULL, NULL);
-}
-
-void run_ec_pubkey_parse_test(void) {
-#define SECP256K1_EC_PARSE_TEST_NVALID (12)
- const unsigned char valid[SECP256K1_EC_PARSE_TEST_NVALID][64] = {
- {
- /* Point with leading and trailing zeros in x and y serialization. */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x52,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x64, 0xef, 0xa1, 0x7b, 0x77, 0x61, 0xe1, 0xe4, 0x27, 0x06, 0x98, 0x9f, 0xb4, 0x83,
- 0xb8, 0xd2, 0xd4, 0x9b, 0xf7, 0x8f, 0xae, 0x98, 0x03, 0xf0, 0x99, 0xb8, 0x34, 0xed, 0xeb, 0x00
- },
- {
- /* Point with x equal to a 3rd root of unity.*/
- 0x7a, 0xe9, 0x6a, 0x2b, 0x65, 0x7c, 0x07, 0x10, 0x6e, 0x64, 0x47, 0x9e, 0xac, 0x34, 0x34, 0xe9,
- 0x9c, 0xf0, 0x49, 0x75, 0x12, 0xf5, 0x89, 0x95, 0xc1, 0x39, 0x6c, 0x28, 0x71, 0x95, 0x01, 0xee,
- 0x42, 0x18, 0xf2, 0x0a, 0xe6, 0xc6, 0x46, 0xb3, 0x63, 0xdb, 0x68, 0x60, 0x58, 0x22, 0xfb, 0x14,
- 0x26, 0x4c, 0xa8, 0xd2, 0x58, 0x7f, 0xdd, 0x6f, 0xbc, 0x75, 0x0d, 0x58, 0x7e, 0x76, 0xa7, 0xee,
- },
- {
- /* Point with largest x. (1/2) */
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2c,
- 0x0e, 0x99, 0x4b, 0x14, 0xea, 0x72, 0xf8, 0xc3, 0xeb, 0x95, 0xc7, 0x1e, 0xf6, 0x92, 0x57, 0x5e,
- 0x77, 0x50, 0x58, 0x33, 0x2d, 0x7e, 0x52, 0xd0, 0x99, 0x5c, 0xf8, 0x03, 0x88, 0x71, 0xb6, 0x7d,
- },
- {
- /* Point with largest x. (2/2) */
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2c,
- 0xf1, 0x66, 0xb4, 0xeb, 0x15, 0x8d, 0x07, 0x3c, 0x14, 0x6a, 0x38, 0xe1, 0x09, 0x6d, 0xa8, 0xa1,
- 0x88, 0xaf, 0xa7, 0xcc, 0xd2, 0x81, 0xad, 0x2f, 0x66, 0xa3, 0x07, 0xfb, 0x77, 0x8e, 0x45, 0xb2,
- },
- {
- /* Point with smallest x. (1/2) */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x42, 0x18, 0xf2, 0x0a, 0xe6, 0xc6, 0x46, 0xb3, 0x63, 0xdb, 0x68, 0x60, 0x58, 0x22, 0xfb, 0x14,
- 0x26, 0x4c, 0xa8, 0xd2, 0x58, 0x7f, 0xdd, 0x6f, 0xbc, 0x75, 0x0d, 0x58, 0x7e, 0x76, 0xa7, 0xee,
- },
- {
- /* Point with smallest x. (2/2) */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0xbd, 0xe7, 0x0d, 0xf5, 0x19, 0x39, 0xb9, 0x4c, 0x9c, 0x24, 0x97, 0x9f, 0xa7, 0xdd, 0x04, 0xeb,
- 0xd9, 0xb3, 0x57, 0x2d, 0xa7, 0x80, 0x22, 0x90, 0x43, 0x8a, 0xf2, 0xa6, 0x81, 0x89, 0x54, 0x41,
- },
- {
- /* Point with largest y. (1/3) */
- 0x1f, 0xe1, 0xe5, 0xef, 0x3f, 0xce, 0xb5, 0xc1, 0x35, 0xab, 0x77, 0x41, 0x33, 0x3c, 0xe5, 0xa6,
- 0xe8, 0x0d, 0x68, 0x16, 0x76, 0x53, 0xf6, 0xb2, 0xb2, 0x4b, 0xcb, 0xcf, 0xaa, 0xaf, 0xf5, 0x07,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2e,
- },
- {
- /* Point with largest y. (2/3) */
- 0xcb, 0xb0, 0xde, 0xab, 0x12, 0x57, 0x54, 0xf1, 0xfd, 0xb2, 0x03, 0x8b, 0x04, 0x34, 0xed, 0x9c,
- 0xb3, 0xfb, 0x53, 0xab, 0x73, 0x53, 0x91, 0x12, 0x99, 0x94, 0xa5, 0x35, 0xd9, 0x25, 0xf6, 0x73,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2e,
- },
- {
- /* Point with largest y. (3/3) */
- 0x14, 0x6d, 0x3b, 0x65, 0xad, 0xd9, 0xf5, 0x4c, 0xcc, 0xa2, 0x85, 0x33, 0xc8, 0x8e, 0x2c, 0xbc,
- 0x63, 0xf7, 0x44, 0x3e, 0x16, 0x58, 0x78, 0x3a, 0xb4, 0x1f, 0x8e, 0xf9, 0x7c, 0x2a, 0x10, 0xb5,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2e,
- },
- {
- /* Point with smallest y. (1/3) */
- 0x1f, 0xe1, 0xe5, 0xef, 0x3f, 0xce, 0xb5, 0xc1, 0x35, 0xab, 0x77, 0x41, 0x33, 0x3c, 0xe5, 0xa6,
- 0xe8, 0x0d, 0x68, 0x16, 0x76, 0x53, 0xf6, 0xb2, 0xb2, 0x4b, 0xcb, 0xcf, 0xaa, 0xaf, 0xf5, 0x07,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- },
- {
- /* Point with smallest y. (2/3) */
- 0xcb, 0xb0, 0xde, 0xab, 0x12, 0x57, 0x54, 0xf1, 0xfd, 0xb2, 0x03, 0x8b, 0x04, 0x34, 0xed, 0x9c,
- 0xb3, 0xfb, 0x53, 0xab, 0x73, 0x53, 0x91, 0x12, 0x99, 0x94, 0xa5, 0x35, 0xd9, 0x25, 0xf6, 0x73,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- },
- {
- /* Point with smallest y. (3/3) */
- 0x14, 0x6d, 0x3b, 0x65, 0xad, 0xd9, 0xf5, 0x4c, 0xcc, 0xa2, 0x85, 0x33, 0xc8, 0x8e, 0x2c, 0xbc,
- 0x63, 0xf7, 0x44, 0x3e, 0x16, 0x58, 0x78, 0x3a, 0xb4, 0x1f, 0x8e, 0xf9, 0x7c, 0x2a, 0x10, 0xb5,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
- }
- };
-#define SECP256K1_EC_PARSE_TEST_NXVALID (4)
- const unsigned char onlyxvalid[SECP256K1_EC_PARSE_TEST_NXVALID][64] = {
- {
- /* Valid if y overflow ignored (y = 1 mod p). (1/3) */
- 0x1f, 0xe1, 0xe5, 0xef, 0x3f, 0xce, 0xb5, 0xc1, 0x35, 0xab, 0x77, 0x41, 0x33, 0x3c, 0xe5, 0xa6,
- 0xe8, 0x0d, 0x68, 0x16, 0x76, 0x53, 0xf6, 0xb2, 0xb2, 0x4b, 0xcb, 0xcf, 0xaa, 0xaf, 0xf5, 0x07,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x30,
- },
- {
- /* Valid if y overflow ignored (y = 1 mod p). (2/3) */
- 0xcb, 0xb0, 0xde, 0xab, 0x12, 0x57, 0x54, 0xf1, 0xfd, 0xb2, 0x03, 0x8b, 0x04, 0x34, 0xed, 0x9c,
- 0xb3, 0xfb, 0x53, 0xab, 0x73, 0x53, 0x91, 0x12, 0x99, 0x94, 0xa5, 0x35, 0xd9, 0x25, 0xf6, 0x73,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x30,
- },
- {
- /* Valid if y overflow ignored (y = 1 mod p). (3/3)*/
- 0x14, 0x6d, 0x3b, 0x65, 0xad, 0xd9, 0xf5, 0x4c, 0xcc, 0xa2, 0x85, 0x33, 0xc8, 0x8e, 0x2c, 0xbc,
- 0x63, 0xf7, 0x44, 0x3e, 0x16, 0x58, 0x78, 0x3a, 0xb4, 0x1f, 0x8e, 0xf9, 0x7c, 0x2a, 0x10, 0xb5,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x30,
- },
- {
- /* x on curve, y is from y^2 = x^3 + 8. */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03
- }
- };
-#define SECP256K1_EC_PARSE_TEST_NINVALID (7)
- const unsigned char invalid[SECP256K1_EC_PARSE_TEST_NINVALID][64] = {
- {
- /* x is third root of -8, y is -1 * (x^3+7); also on the curve for y^2 = x^3 + 9. */
- 0x0a, 0x2d, 0x2b, 0xa9, 0x35, 0x07, 0xf1, 0xdf, 0x23, 0x37, 0x70, 0xc2, 0xa7, 0x97, 0x96, 0x2c,
- 0xc6, 0x1f, 0x6d, 0x15, 0xda, 0x14, 0xec, 0xd4, 0x7d, 0x8d, 0x27, 0xae, 0x1c, 0xd5, 0xf8, 0x53,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- },
- {
- /* Valid if x overflow ignored (x = 1 mod p). */
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x30,
- 0x42, 0x18, 0xf2, 0x0a, 0xe6, 0xc6, 0x46, 0xb3, 0x63, 0xdb, 0x68, 0x60, 0x58, 0x22, 0xfb, 0x14,
- 0x26, 0x4c, 0xa8, 0xd2, 0x58, 0x7f, 0xdd, 0x6f, 0xbc, 0x75, 0x0d, 0x58, 0x7e, 0x76, 0xa7, 0xee,
- },
- {
- /* Valid if x overflow ignored (x = 1 mod p). */
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x30,
- 0xbd, 0xe7, 0x0d, 0xf5, 0x19, 0x39, 0xb9, 0x4c, 0x9c, 0x24, 0x97, 0x9f, 0xa7, 0xdd, 0x04, 0xeb,
- 0xd9, 0xb3, 0x57, 0x2d, 0xa7, 0x80, 0x22, 0x90, 0x43, 0x8a, 0xf2, 0xa6, 0x81, 0x89, 0x54, 0x41,
- },
- {
- /* x is -1, y is the result of the sqrt ladder; also on the curve for y^2 = x^3 - 5. */
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2e,
- 0xf4, 0x84, 0x14, 0x5c, 0xb0, 0x14, 0x9b, 0x82, 0x5d, 0xff, 0x41, 0x2f, 0xa0, 0x52, 0xa8, 0x3f,
- 0xcb, 0x72, 0xdb, 0x61, 0xd5, 0x6f, 0x37, 0x70, 0xce, 0x06, 0x6b, 0x73, 0x49, 0xa2, 0xaa, 0x28,
- },
- {
- /* x is -1, y is the result of the sqrt ladder; also on the curve for y^2 = x^3 - 5. */
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2e,
- 0x0b, 0x7b, 0xeb, 0xa3, 0x4f, 0xeb, 0x64, 0x7d, 0xa2, 0x00, 0xbe, 0xd0, 0x5f, 0xad, 0x57, 0xc0,
- 0x34, 0x8d, 0x24, 0x9e, 0x2a, 0x90, 0xc8, 0x8f, 0x31, 0xf9, 0x94, 0x8b, 0xb6, 0x5d, 0x52, 0x07,
- },
- {
- /* x is zero, y is the result of the sqrt ladder; also on the curve for y^2 = x^3 - 7. */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x8f, 0x53, 0x7e, 0xef, 0xdf, 0xc1, 0x60, 0x6a, 0x07, 0x27, 0xcd, 0x69, 0xb4, 0xa7, 0x33, 0x3d,
- 0x38, 0xed, 0x44, 0xe3, 0x93, 0x2a, 0x71, 0x79, 0xee, 0xcb, 0x4b, 0x6f, 0xba, 0x93, 0x60, 0xdc,
- },
- {
- /* x is zero, y is the result of the sqrt ladder; also on the curve for y^2 = x^3 - 7. */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x70, 0xac, 0x81, 0x10, 0x20, 0x3e, 0x9f, 0x95, 0xf8, 0xd8, 0x32, 0x96, 0x4b, 0x58, 0xcc, 0xc2,
- 0xc7, 0x12, 0xbb, 0x1c, 0x6c, 0xd5, 0x8e, 0x86, 0x11, 0x34, 0xb4, 0x8f, 0x45, 0x6c, 0x9b, 0x53
- }
- };
- const unsigned char pubkeyc[66] = {
- /* Serialization of G. */
- 0x04, 0x79, 0xBE, 0x66, 0x7E, 0xF9, 0xDC, 0xBB, 0xAC, 0x55, 0xA0, 0x62, 0x95, 0xCE, 0x87, 0x0B,
- 0x07, 0x02, 0x9B, 0xFC, 0xDB, 0x2D, 0xCE, 0x28, 0xD9, 0x59, 0xF2, 0x81, 0x5B, 0x16, 0xF8, 0x17,
- 0x98, 0x48, 0x3A, 0xDA, 0x77, 0x26, 0xA3, 0xC4, 0x65, 0x5D, 0xA4, 0xFB, 0xFC, 0x0E, 0x11, 0x08,
- 0xA8, 0xFD, 0x17, 0xB4, 0x48, 0xA6, 0x85, 0x54, 0x19, 0x9C, 0x47, 0xD0, 0x8F, 0xFB, 0x10, 0xD4,
- 0xB8, 0x00
- };
- unsigned char sout[65];
- unsigned char shortkey[2];
- secp256k1_ge ge;
- secp256k1_pubkey pubkey;
- size_t len;
- int32_t i;
- int32_t ecount;
- int32_t ecount2;
- ecount = 0;
- /* Nothing should be reading this far into pubkeyc. */
- VG_UNDEF(&pubkeyc[65], 1);
- secp256k1_context_set_illegal_callback(ctx, counting_illegal_callback_fn, &ecount);
- /* Zero length claimed, fail, zeroize, no illegal arg error. */
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(shortkey, 2);
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, shortkey, 0) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- /* Length one claimed, fail, zeroize, no illegal arg error. */
- for (i = 0; i < 256 ; i++) {
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- shortkey[0] = i;
- VG_UNDEF(&shortkey[1], 1);
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, shortkey, 1) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- }
- /* Length two claimed, fail, zeroize, no illegal arg error. */
- for (i = 0; i < 65536 ; i++) {
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- shortkey[0] = i & 255;
- shortkey[1] = i >> 8;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, shortkey, 2) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- }
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- /* 33 bytes claimed on otherwise valid input starting with 0x04, fail, zeroize output, no illegal arg error. */
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, 33) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- /* NULL pubkey, illegal arg error. Pubkey isn't rewritten before this step, since it's NULL into the parser. */
- CHECK(secp256k1_ec_pubkey_parse(ctx, NULL, pubkeyc, 65) == 0);
- CHECK(ecount == 2);
- /* NULL input string. Illegal arg and zeroize output. */
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, NULL, 65) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 1);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 2);
- /* 64 bytes claimed on input starting with 0x04, fail, zeroize output, no illegal arg error. */
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, 64) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- /* 66 bytes claimed, fail, zeroize output, no illegal arg error. */
- memset(&pubkey, 0xfe, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, 66) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 0);
- CHECK(ecount == 1);
- /* Valid parse. */
- memset(&pubkey, 0, sizeof(pubkey));
- ecount = 0;
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, 65) == 1);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(ecount == 0);
- VG_UNDEF(&ge, sizeof(ge));
- CHECK(secp256k1_pubkey_load(ctx, &ge, &pubkey) == 1);
- VG_CHECK(&ge.x, sizeof(ge.x));
- VG_CHECK(&ge.y, sizeof(ge.y));
- VG_CHECK(&ge.infinity, sizeof(ge.infinity));
- ge_equals_ge(&secp256k1_ge_const_g, &ge);
- CHECK(ecount == 0);
- /* secp256k1_ec_pubkey_serialize illegal args. */
- ecount = 0;
- len = 65;
- CHECK(secp256k1_ec_pubkey_serialize(ctx, NULL, &len, &pubkey, SECP256K1_EC_UNCOMPRESSED) == 0);
- CHECK(ecount == 1);
- CHECK(len == 0);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, sout, NULL, &pubkey, SECP256K1_EC_UNCOMPRESSED) == 0);
- CHECK(ecount == 2);
- len = 65;
- VG_UNDEF(sout, 65);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, sout, &len, NULL, SECP256K1_EC_UNCOMPRESSED) == 0);
- VG_CHECK(sout, 65);
- CHECK(ecount == 3);
- CHECK(len == 0);
- len = 65;
- CHECK(secp256k1_ec_pubkey_serialize(ctx, sout, &len, &pubkey, ~0) == 0);
- CHECK(ecount == 4);
- CHECK(len == 0);
- len = 65;
- VG_UNDEF(sout, 65);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, sout, &len, &pubkey, SECP256K1_EC_UNCOMPRESSED) == 1);
- VG_CHECK(sout, 65);
- CHECK(ecount == 4);
- CHECK(len == 65);
- /* Multiple illegal args. Should still set arg error only once. */
- ecount = 0;
- ecount2 = 11;
- CHECK(secp256k1_ec_pubkey_parse(ctx, NULL, NULL, 65) == 0);
- CHECK(ecount == 1);
- /* Does the illegal arg callback actually change the behavior? */
- secp256k1_context_set_illegal_callback(ctx, uncounting_illegal_callback_fn, &ecount2);
- CHECK(secp256k1_ec_pubkey_parse(ctx, NULL, NULL, 65) == 0);
- CHECK(ecount == 1);
- CHECK(ecount2 == 10);
- secp256k1_context_set_illegal_callback(ctx, NULL, NULL);
- /* Try a bunch of prefabbed points with all possible encodings. */
- for (i = 0; i < SECP256K1_EC_PARSE_TEST_NVALID; i++) {
- ec_pubkey_parse_pointtest(valid[i], 1, 1);
- }
- for (i = 0; i < SECP256K1_EC_PARSE_TEST_NXVALID; i++) {
- ec_pubkey_parse_pointtest(onlyxvalid[i], 1, 0);
- }
- for (i = 0; i < SECP256K1_EC_PARSE_TEST_NINVALID; i++) {
- ec_pubkey_parse_pointtest(invalid[i], 0, 0);
- }
-}
-
-void run_eckey_edge_case_test(void) {
- const unsigned char orderc[32] = {
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41
- };
- const unsigned char zeros[sizeof(secp256k1_pubkey)] = {0x00};
- unsigned char ctmp[33];
- unsigned char ctmp2[33];
- secp256k1_pubkey pubkey;
- secp256k1_pubkey pubkey2;
- secp256k1_pubkey pubkey_one;
- secp256k1_pubkey pubkey_negone;
- const secp256k1_pubkey *pubkeys[3];
- size_t len;
- int32_t ecount;
- /* Group order is too large, reject. */
- CHECK(secp256k1_ec_seckey_verify(ctx, orderc) == 0);
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, orderc) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- /* Maximum value is too large, reject. */
- memset(ctmp, 255, 32);
- CHECK(secp256k1_ec_seckey_verify(ctx, ctmp) == 0);
- memset(&pubkey, 1, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, ctmp) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- /* Zero is too small, reject. */
- memset(ctmp, 0, 32);
- CHECK(secp256k1_ec_seckey_verify(ctx, ctmp) == 0);
- memset(&pubkey, 1, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, ctmp) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- /* One must be accepted. */
- ctmp[31] = 0x01;
- CHECK(secp256k1_ec_seckey_verify(ctx, ctmp) == 1);
- memset(&pubkey, 0, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, ctmp) == 1);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) > 0);
- pubkey_one = pubkey;
- /* Group order + 1 is too large, reject. */
- memcpy(ctmp, orderc, 32);
- ctmp[31] = 0x42;
- CHECK(secp256k1_ec_seckey_verify(ctx, ctmp) == 0);
- memset(&pubkey, 1, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, ctmp) == 0);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- /* -1 must be accepted. */
- ctmp[31] = 0x40;
- CHECK(secp256k1_ec_seckey_verify(ctx, ctmp) == 1);
- memset(&pubkey, 0, sizeof(pubkey));
- VG_UNDEF(&pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, ctmp) == 1);
- VG_CHECK(&pubkey, sizeof(pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) > 0);
- pubkey_negone = pubkey;
- /* Tweak of zero leaves the value changed. */
- memset(ctmp2, 0, 32);
- CHECK(secp256k1_ec_privkey_tweak_add(ctx, ctmp, ctmp2) == 1);
- CHECK(memcmp(orderc, ctmp, 31) == 0 && ctmp[31] == 0x40);
- memcpy(&pubkey2, &pubkey, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, ctmp2) == 1);
- CHECK(memcmp(&pubkey, &pubkey2, sizeof(pubkey)) == 0);
- /* Multiply tweak of zero zeroizes the output. */
- CHECK(secp256k1_ec_privkey_tweak_mul(ctx, ctmp, ctmp2) == 0);
- CHECK(memcmp(zeros, ctmp, 32) == 0);
- CHECK(secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey, ctmp2) == 0);
- CHECK(memcmp(&pubkey, zeros, sizeof(pubkey)) == 0);
- memcpy(&pubkey, &pubkey2, sizeof(pubkey));
- /* Overflowing key tweak zeroizes. */
- memcpy(ctmp, orderc, 32);
- ctmp[31] = 0x40;
- CHECK(secp256k1_ec_privkey_tweak_add(ctx, ctmp, orderc) == 0);
- CHECK(memcmp(zeros, ctmp, 32) == 0);
- memcpy(ctmp, orderc, 32);
- ctmp[31] = 0x40;
- CHECK(secp256k1_ec_privkey_tweak_mul(ctx, ctmp, orderc) == 0);
- CHECK(memcmp(zeros, ctmp, 32) == 0);
- memcpy(ctmp, orderc, 32);
- ctmp[31] = 0x40;
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, orderc) == 0);
- CHECK(memcmp(&pubkey, zeros, sizeof(pubkey)) == 0);
- memcpy(&pubkey, &pubkey2, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey, orderc) == 0);
- CHECK(memcmp(&pubkey, zeros, sizeof(pubkey)) == 0);
- memcpy(&pubkey, &pubkey2, sizeof(pubkey));
- /* Private key tweaks results in a key of zero. */
- ctmp2[31] = 1;
- CHECK(secp256k1_ec_privkey_tweak_add(ctx, ctmp2, ctmp) == 0);
- CHECK(memcmp(zeros, ctmp2, 32) == 0);
- ctmp2[31] = 1;
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, ctmp2) == 0);
- CHECK(memcmp(&pubkey, zeros, sizeof(pubkey)) == 0);
- memcpy(&pubkey, &pubkey2, sizeof(pubkey));
- /* Tweak computation wraps and results in a key of 1. */
- ctmp2[31] = 2;
- CHECK(secp256k1_ec_privkey_tweak_add(ctx, ctmp2, ctmp) == 1);
- CHECK(memcmp(ctmp2, zeros, 31) == 0 && ctmp2[31] == 1);
- ctmp2[31] = 2;
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, ctmp2) == 1);
- ctmp2[31] = 1;
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey2, ctmp2) == 1);
- CHECK(memcmp(&pubkey, &pubkey2, sizeof(pubkey)) == 0);
- /* Tweak mul * 2 = 1+1. */
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, ctmp2) == 1);
- ctmp2[31] = 2;
- CHECK(secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey2, ctmp2) == 1);
- CHECK(memcmp(&pubkey, &pubkey2, sizeof(pubkey)) == 0);
- /* Test argument errors. */
- ecount = 0;
- secp256k1_context_set_illegal_callback(ctx, counting_illegal_callback_fn, &ecount);
- CHECK(ecount == 0);
- /* Zeroize pubkey on parse error. */
- memset(&pubkey, 0, 32);
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, ctmp2) == 0);
- CHECK(ecount == 1);
- CHECK(memcmp(&pubkey, zeros, sizeof(pubkey)) == 0);
- memcpy(&pubkey, &pubkey2, sizeof(pubkey));
- memset(&pubkey2, 0, 32);
- CHECK(secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey2, ctmp2) == 0);
- CHECK(ecount == 2);
- CHECK(memcmp(&pubkey2, zeros, sizeof(pubkey2)) == 0);
- /* Plain argument errors. */
- ecount = 0;
- CHECK(secp256k1_ec_seckey_verify(ctx, ctmp) == 1);
- CHECK(ecount == 0);
- CHECK(secp256k1_ec_seckey_verify(ctx, NULL) == 0);
- CHECK(ecount == 1);
- ecount = 0;
- memset(ctmp2, 0, 32);
- ctmp2[31] = 4;
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, NULL, ctmp2) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, NULL) == 0);
- CHECK(ecount == 2);
- ecount = 0;
- memset(ctmp2, 0, 32);
- ctmp2[31] = 4;
- CHECK(secp256k1_ec_pubkey_tweak_mul(ctx, NULL, ctmp2) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey, NULL) == 0);
- CHECK(ecount == 2);
- ecount = 0;
- memset(ctmp2, 0, 32);
- CHECK(secp256k1_ec_privkey_tweak_add(ctx, NULL, ctmp2) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ec_privkey_tweak_add(ctx, ctmp, NULL) == 0);
- CHECK(ecount == 2);
- ecount = 0;
- memset(ctmp2, 0, 32);
- ctmp2[31] = 1;
- CHECK(secp256k1_ec_privkey_tweak_mul(ctx, NULL, ctmp2) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ec_privkey_tweak_mul(ctx, ctmp, NULL) == 0);
- CHECK(ecount == 2);
- ecount = 0;
- CHECK(secp256k1_ec_pubkey_create(ctx, NULL, ctmp) == 0);
- CHECK(ecount == 1);
- memset(&pubkey, 1, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, NULL) == 0);
- CHECK(ecount == 2);
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- /* secp256k1_ec_pubkey_combine tests. */
- ecount = 0;
- pubkeys[0] = &pubkey_one;
- VG_UNDEF(&pubkeys[0], sizeof(secp256k1_pubkey *));
- VG_UNDEF(&pubkeys[1], sizeof(secp256k1_pubkey *));
- VG_UNDEF(&pubkeys[2], sizeof(secp256k1_pubkey *));
- memset(&pubkey, 255, sizeof(secp256k1_pubkey));
- VG_UNDEF(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(secp256k1_ec_pubkey_combine(ctx, &pubkey, pubkeys, 0) == 0);
- VG_CHECK(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ec_pubkey_combine(ctx, NULL, pubkeys, 1) == 0);
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- CHECK(ecount == 2);
- memset(&pubkey, 255, sizeof(secp256k1_pubkey));
- VG_UNDEF(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(secp256k1_ec_pubkey_combine(ctx, &pubkey, NULL, 1) == 0);
- VG_CHECK(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- CHECK(ecount == 3);
- pubkeys[0] = &pubkey_negone;
- memset(&pubkey, 255, sizeof(secp256k1_pubkey));
- VG_UNDEF(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(secp256k1_ec_pubkey_combine(ctx, &pubkey, pubkeys, 1) == 1);
- VG_CHECK(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) > 0);
- CHECK(ecount == 3);
- len = 33;
- CHECK(secp256k1_ec_pubkey_serialize(ctx, ctmp, &len, &pubkey, SECP256K1_EC_COMPRESSED) == 1);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, ctmp2, &len, &pubkey_negone, SECP256K1_EC_COMPRESSED) == 1);
- CHECK(memcmp(ctmp, ctmp2, 33) == 0);
- /* Result is infinity. */
- pubkeys[0] = &pubkey_one;
- pubkeys[1] = &pubkey_negone;
- memset(&pubkey, 255, sizeof(secp256k1_pubkey));
- VG_UNDEF(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(secp256k1_ec_pubkey_combine(ctx, &pubkey, pubkeys, 2) == 0);
- VG_CHECK(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) == 0);
- CHECK(ecount == 3);
- /* Passes through infinity but comes out one. */
- pubkeys[2] = &pubkey_one;
- memset(&pubkey, 255, sizeof(secp256k1_pubkey));
- VG_UNDEF(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(secp256k1_ec_pubkey_combine(ctx, &pubkey, pubkeys, 3) == 1);
- VG_CHECK(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) > 0);
- CHECK(ecount == 3);
- len = 33;
- CHECK(secp256k1_ec_pubkey_serialize(ctx, ctmp, &len, &pubkey, SECP256K1_EC_COMPRESSED) == 1);
- CHECK(secp256k1_ec_pubkey_serialize(ctx, ctmp2, &len, &pubkey_one, SECP256K1_EC_COMPRESSED) == 1);
- CHECK(memcmp(ctmp, ctmp2, 33) == 0);
- /* Adds to two. */
- pubkeys[1] = &pubkey_one;
- memset(&pubkey, 255, sizeof(secp256k1_pubkey));
- VG_UNDEF(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(secp256k1_ec_pubkey_combine(ctx, &pubkey, pubkeys, 2) == 1);
- VG_CHECK(&pubkey, sizeof(secp256k1_pubkey));
- CHECK(memcmp(&pubkey, zeros, sizeof(secp256k1_pubkey)) > 0);
- CHECK(ecount == 3);
- secp256k1_context_set_illegal_callback(ctx, NULL, NULL);
-}
-
-void random_sign(secp256k1_scalar *sigr, secp256k1_scalar *sigs, const secp256k1_scalar *key, const secp256k1_scalar *msg, int *recid) {
- secp256k1_scalar nonce;
- do {
- random_scalar_order_test(&nonce);
- } while(!secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, sigr, sigs, key, msg, &nonce, recid));
-}
-
-void test_ecdsa_sign_verify(void) {
- secp256k1_gej pubj;
- secp256k1_ge pub;
- secp256k1_scalar one;
- secp256k1_scalar msg, key;
- secp256k1_scalar sigr, sigs;
- int recid;
- int getrec;
- random_scalar_order_test(&msg);
- random_scalar_order_test(&key);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &pubj, &key);
- secp256k1_ge_set_gej(&pub, &pubj);
- getrec = secp256k1_rand_bits(1);
- random_sign(&sigr, &sigs, &key, &msg, getrec?&recid:NULL);
- if (getrec) {
- CHECK(recid >= 0 && recid < 4);
- }
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sigr, &sigs, &pub, &msg));
- secp256k1_scalar_set_int(&one, 1);
- secp256k1_scalar_add(&msg, &msg, &one);
- CHECK(!secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sigr, &sigs, &pub, &msg));
-}
-
-void run_ecdsa_sign_verify(void) {
- int i;
- for (i = 0; i < 10*count; i++) {
- test_ecdsa_sign_verify();
- }
-}
-
-/** Dummy nonce generation function that just uses a precomputed nonce, and fails if it is not accepted. Use only for testing. */
-static int precomputed_nonce_function(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
- (void)msg32;
- (void)key32;
- (void)algo16;
- memcpy(nonce32, data, 32);
- return (counter == 0);
-}
-
-static int nonce_function_test_fail(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
- /* Dummy nonce generator that has a fatal error on the first counter value. */
- if (counter == 0) {
- return 0;
- }
- return nonce_function_rfc6979(nonce32, msg32, key32, algo16, data, counter - 1);
-}
-
-static int nonce_function_test_retry(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
- /* Dummy nonce generator that produces unacceptable nonces for the first several counter values. */
- if (counter < 3) {
- memset(nonce32, counter==0 ? 0 : 255, 32);
- if (counter == 2) {
- nonce32[31]--;
- }
- return 1;
- }
- if (counter < 5) {
- static const unsigned char order[] = {
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
- 0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,
- 0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x41
- };
- memcpy(nonce32, order, 32);
- if (counter == 4) {
- nonce32[31]++;
- }
- return 1;
- }
- /* Retry rate of 6979 is negligible esp. as we only call this in deterministic tests. */
- /* If someone does fine a case where it retries for secp256k1, we'd like to know. */
- if (counter > 5) {
- return 0;
- }
- return nonce_function_rfc6979(nonce32, msg32, key32, algo16, data, counter - 5);
-}
-
-int is_empty_signature(const secp256k1_ecdsa_signature *sig) {
- static const unsigned char res[sizeof(secp256k1_ecdsa_signature)] = {0};
- return memcmp(sig, res, sizeof(secp256k1_ecdsa_signature)) == 0;
-}
-
-void test_ecdsa_end_to_end(void) {
- unsigned char extra[32] = {0x00};
- unsigned char privkey[32];
- unsigned char message[32];
- unsigned char privkey2[32];
- secp256k1_ecdsa_signature signature[6];
- secp256k1_scalar r, s;
- unsigned char sig[74];
- size_t siglen = 74;
- unsigned char pubkeyc[65];
- size_t pubkeyclen = 65;
- secp256k1_pubkey pubkey;
- unsigned char seckey[300];
- size_t seckeylen = 300;
-
- /* Generate a random key and message. */
- {
- secp256k1_scalar msg, key;
- random_scalar_order_test(&msg);
- random_scalar_order_test(&key);
- secp256k1_scalar_get_b32(privkey, &key);
- secp256k1_scalar_get_b32(message, &msg);
- }
-
- /* Construct and verify corresponding public key. */
- CHECK(secp256k1_ec_seckey_verify(ctx, privkey) == 1);
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, privkey) == 1);
-
- /* Verify exporting and importing public key. */
- CHECK(secp256k1_ec_pubkey_serialize(ctx, pubkeyc, &pubkeyclen, &pubkey, secp256k1_rand_bits(1) == 1 ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED));
- memset(&pubkey, 0, sizeof(pubkey));
- CHECK(secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeyc, pubkeyclen) == 1);
-
- /* Verify private key import and export. */
- CHECK(ec_privkey_export_der(ctx, seckey, &seckeylen, privkey, secp256k1_rand_bits(1) == 1));
- CHECK(ec_privkey_import_der(ctx, privkey2, seckey, seckeylen) == 1);
- CHECK(memcmp(privkey, privkey2, 32) == 0);
-
- /* Optionally tweak the keys using addition. */
- if (secp256k1_rand_int(3) == 0) {
- int ret1;
- int ret2;
- unsigned char rnd[32];
- secp256k1_pubkey pubkey2;
- secp256k1_rand256_test(rnd);
- ret1 = secp256k1_ec_privkey_tweak_add(ctx, privkey, rnd);
- ret2 = secp256k1_ec_pubkey_tweak_add(ctx, &pubkey, rnd);
- CHECK(ret1 == ret2);
- if (ret1 == 0) {
- return;
- }
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey2, privkey) == 1);
- CHECK(memcmp(&pubkey, &pubkey2, sizeof(pubkey)) == 0);
- }
-
- /* Optionally tweak the keys using multiplication. */
- if (secp256k1_rand_int(3) == 0) {
- int ret1;
- int ret2;
- unsigned char rnd[32];
- secp256k1_pubkey pubkey2;
- secp256k1_rand256_test(rnd);
- ret1 = secp256k1_ec_privkey_tweak_mul(ctx, privkey, rnd);
- ret2 = secp256k1_ec_pubkey_tweak_mul(ctx, &pubkey, rnd);
- CHECK(ret1 == ret2);
- if (ret1 == 0) {
- return;
- }
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey2, privkey) == 1);
- CHECK(memcmp(&pubkey, &pubkey2, sizeof(pubkey)) == 0);
- }
-
- /* Sign. */
- CHECK(secp256k1_ecdsa_sign(ctx, &signature[0], message, privkey, NULL, NULL) == 1);
- CHECK(secp256k1_ecdsa_sign(ctx, &signature[4], message, privkey, NULL, NULL) == 1);
- CHECK(secp256k1_ecdsa_sign(ctx, &signature[1], message, privkey, NULL, extra) == 1);
- extra[31] = 1;
- CHECK(secp256k1_ecdsa_sign(ctx, &signature[2], message, privkey, NULL, extra) == 1);
- extra[31] = 0;
- extra[0] = 1;
- CHECK(secp256k1_ecdsa_sign(ctx, &signature[3], message, privkey, NULL, extra) == 1);
- CHECK(memcmp(&signature[0], &signature[4], sizeof(signature[0])) == 0);
- CHECK(memcmp(&signature[0], &signature[1], sizeof(signature[0])) != 0);
- CHECK(memcmp(&signature[0], &signature[2], sizeof(signature[0])) != 0);
- CHECK(memcmp(&signature[0], &signature[3], sizeof(signature[0])) != 0);
- CHECK(memcmp(&signature[1], &signature[2], sizeof(signature[0])) != 0);
- CHECK(memcmp(&signature[1], &signature[3], sizeof(signature[0])) != 0);
- CHECK(memcmp(&signature[2], &signature[3], sizeof(signature[0])) != 0);
- /* Verify. */
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[0], message, &pubkey) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[1], message, &pubkey) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[2], message, &pubkey) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[3], message, &pubkey) == 1);
- /* Test lower-S form, malleate, verify and fail, test again, malleate again */
- CHECK(!secp256k1_ecdsa_signature_normalize(ctx, NULL, &signature[0]));
- secp256k1_ecdsa_signature_load(ctx, &r, &s, &signature[0]);
- secp256k1_scalar_negate(&s, &s);
- secp256k1_ecdsa_signature_save(&signature[5], &r, &s);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[5], message, &pubkey) == 0);
- CHECK(secp256k1_ecdsa_signature_normalize(ctx, NULL, &signature[5]));
- CHECK(secp256k1_ecdsa_signature_normalize(ctx, &signature[5], &signature[5]));
- CHECK(!secp256k1_ecdsa_signature_normalize(ctx, NULL, &signature[5]));
- CHECK(!secp256k1_ecdsa_signature_normalize(ctx, &signature[5], &signature[5]));
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[5], message, &pubkey) == 1);
- secp256k1_scalar_negate(&s, &s);
- secp256k1_ecdsa_signature_save(&signature[5], &r, &s);
- CHECK(!secp256k1_ecdsa_signature_normalize(ctx, NULL, &signature[5]));
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[5], message, &pubkey) == 1);
- CHECK(memcmp(&signature[5], &signature[0], 64) == 0);
-
- /* Serialize/parse DER and verify again */
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, sig, &siglen, &signature[0]) == 1);
- memset(&signature[0], 0, sizeof(signature[0]));
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &signature[0], sig, siglen) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, &signature[0], message, &pubkey) == 1);
- /* Serialize/destroy/parse DER and verify again. */
- siglen = 74;
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, sig, &siglen, &signature[0]) == 1);
- sig[secp256k1_rand_int(siglen)] += 1 + secp256k1_rand_int(255);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &signature[0], sig, siglen) == 0 ||
- secp256k1_ecdsa_verify(ctx, &signature[0], message, &pubkey) == 0);
-}
-
-void test_random_pubkeys(void) {
- secp256k1_ge elem;
- secp256k1_ge elem2;
- unsigned char in[65];
- /* Generate some randomly sized pubkeys. */
- size_t len = secp256k1_rand_bits(2) == 0 ? 65 : 33;
- if (secp256k1_rand_bits(2) == 0) {
- len = secp256k1_rand_bits(6);
- }
- if (len == 65) {
- in[0] = secp256k1_rand_bits(1) ? 4 : (secp256k1_rand_bits(1) ? 6 : 7);
- } else {
- in[0] = secp256k1_rand_bits(1) ? 2 : 3;
- }
- if (secp256k1_rand_bits(3) == 0) {
- in[0] = secp256k1_rand_bits(8);
- }
- if (len > 1) {
- secp256k1_rand256(&in[1]);
- }
- if (len > 33) {
- secp256k1_rand256(&in[33]);
- }
- if (secp256k1_eckey_pubkey_parse(&elem, in, len)) {
- unsigned char out[65];
- unsigned char firstb;
- int res;
- size_t size = len;
- firstb = in[0];
- /* If the pubkey can be parsed, it should round-trip... */
- CHECK(secp256k1_eckey_pubkey_serialize(&elem, out, &size, len == 33));
- CHECK(size == len);
- CHECK(memcmp(&in[1], &out[1], len-1) == 0);
- /* ... except for the type of hybrid inputs. */
- if ((in[0] != 6) && (in[0] != 7)) {
- CHECK(in[0] == out[0]);
- }
- size = 65;
- CHECK(secp256k1_eckey_pubkey_serialize(&elem, in, &size, 0));
- CHECK(size == 65);
- CHECK(secp256k1_eckey_pubkey_parse(&elem2, in, size));
- ge_equals_ge(&elem,&elem2);
- /* Check that the X9.62 hybrid type is checked. */
- in[0] = secp256k1_rand_bits(1) ? 6 : 7;
- res = secp256k1_eckey_pubkey_parse(&elem2, in, size);
- if (firstb == 2 || firstb == 3) {
- if (in[0] == firstb + 4) {
- CHECK(res);
- } else {
- CHECK(!res);
- }
- }
- if (res) {
- ge_equals_ge(&elem,&elem2);
- CHECK(secp256k1_eckey_pubkey_serialize(&elem, out, &size, 0));
- CHECK(memcmp(&in[1], &out[1], 64) == 0);
- }
- }
-}
-
-void run_random_pubkeys(void) {
- int i;
- for (i = 0; i < 10*count; i++) {
- test_random_pubkeys();
- }
-}
-
-void run_ecdsa_end_to_end(void) {
- int i;
- for (i = 0; i < 64*count; i++) {
- test_ecdsa_end_to_end();
- }
-}
-
-int test_ecdsa_der_parse(const unsigned char *sig, size_t siglen, int certainly_der, int certainly_not_der) {
- static const unsigned char zeroes[32] = {0};
-#ifdef ENABLE_OPENSSL_TESTS
- static const unsigned char max_scalar[32] = {
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x40
- };
-#endif
-
- int ret = 0;
-
- secp256k1_ecdsa_signature sig_der;
- unsigned char roundtrip_der[2048];
- unsigned char compact_der[64];
- size_t len_der = 2048;
- int parsed_der = 0, valid_der = 0, roundtrips_der = 0;
-
- secp256k1_ecdsa_signature sig_der_lax;
- unsigned char roundtrip_der_lax[2048];
- unsigned char compact_der_lax[64];
- size_t len_der_lax = 2048;
- int parsed_der_lax = 0, valid_der_lax = 0, roundtrips_der_lax = 0;
-
-#ifdef ENABLE_OPENSSL_TESTS
- ECDSA_SIG *sig_openssl;
- const unsigned char *sigptr;
- unsigned char roundtrip_openssl[2048];
- int len_openssl = 2048;
- int parsed_openssl, valid_openssl = 0, roundtrips_openssl = 0;
-#endif
-
- parsed_der = secp256k1_ecdsa_signature_parse_der(ctx, &sig_der, sig, siglen);
- if (parsed_der) {
- ret |= (!secp256k1_ecdsa_signature_serialize_compact(ctx, compact_der, &sig_der)) << 0;
- valid_der = (memcmp(compact_der, zeroes, 32) != 0) && (memcmp(compact_der + 32, zeroes, 32) != 0);
- }
- if (valid_der) {
- ret |= (!secp256k1_ecdsa_signature_serialize_der(ctx, roundtrip_der, &len_der, &sig_der)) << 1;
- roundtrips_der = (len_der == siglen) && memcmp(roundtrip_der, sig, siglen) == 0;
- }
-
- parsed_der_lax = ecdsa_signature_parse_der_lax(ctx, &sig_der_lax, sig, siglen);
- if (parsed_der_lax) {
- ret |= (!secp256k1_ecdsa_signature_serialize_compact(ctx, compact_der_lax, &sig_der_lax)) << 10;
- valid_der_lax = (memcmp(compact_der_lax, zeroes, 32) != 0) && (memcmp(compact_der_lax + 32, zeroes, 32) != 0);
- }
- if (valid_der_lax) {
- ret |= (!secp256k1_ecdsa_signature_serialize_der(ctx, roundtrip_der_lax, &len_der_lax, &sig_der_lax)) << 11;
- roundtrips_der_lax = (len_der_lax == siglen) && memcmp(roundtrip_der_lax, sig, siglen) == 0;
- }
-
- if (certainly_der) {
- ret |= (!parsed_der) << 2;
- }
- if (certainly_not_der) {
- ret |= (parsed_der) << 17;
- }
- if (valid_der) {
- ret |= (!roundtrips_der) << 3;
- }
-
- if (valid_der) {
- ret |= (!roundtrips_der_lax) << 12;
- ret |= (len_der != len_der_lax) << 13;
- ret |= (memcmp(roundtrip_der_lax, roundtrip_der, len_der) != 0) << 14;
- }
- ret |= (roundtrips_der != roundtrips_der_lax) << 15;
- if (parsed_der) {
- ret |= (!parsed_der_lax) << 16;
- }
-
-#ifdef ENABLE_OPENSSL_TESTS
- sig_openssl = ECDSA_SIG_new();
- sigptr = sig;
- parsed_openssl = (d2i_ECDSA_SIG(&sig_openssl, &sigptr, siglen) != NULL);
- if (parsed_openssl) {
- valid_openssl = !BN_is_negative(sig_openssl->r) && !BN_is_negative(sig_openssl->s) && BN_num_bits(sig_openssl->r) > 0 && BN_num_bits(sig_openssl->r) <= 256 && BN_num_bits(sig_openssl->s) > 0 && BN_num_bits(sig_openssl->s) <= 256;
- if (valid_openssl) {
- unsigned char tmp[32] = {0};
- BN_bn2bin(sig_openssl->r, tmp + 32 - BN_num_bytes(sig_openssl->r));
- valid_openssl = memcmp(tmp, max_scalar, 32) < 0;
- }
- if (valid_openssl) {
- unsigned char tmp[32] = {0};
- BN_bn2bin(sig_openssl->s, tmp + 32 - BN_num_bytes(sig_openssl->s));
- valid_openssl = memcmp(tmp, max_scalar, 32) < 0;
- }
- }
- len_openssl = i2d_ECDSA_SIG(sig_openssl, NULL);
- if (len_openssl <= 2048) {
- unsigned char *ptr = roundtrip_openssl;
- CHECK(i2d_ECDSA_SIG(sig_openssl, &ptr) == len_openssl);
- roundtrips_openssl = valid_openssl && ((size_t)len_openssl == siglen) && (memcmp(roundtrip_openssl, sig, siglen) == 0);
- } else {
- len_openssl = 0;
- }
- ECDSA_SIG_free(sig_openssl);
-
- ret |= (parsed_der && !parsed_openssl) << 4;
- ret |= (valid_der && !valid_openssl) << 5;
- ret |= (roundtrips_openssl && !parsed_der) << 6;
- ret |= (roundtrips_der != roundtrips_openssl) << 7;
- if (roundtrips_openssl) {
- ret |= (len_der != (size_t)len_openssl) << 8;
- ret |= (memcmp(roundtrip_der, roundtrip_openssl, len_der) != 0) << 9;
- }
-#endif
- return ret;
-}
-
-static void assign_big_endian(unsigned char *ptr, size_t ptrlen, uint32_t val) {
- size_t i;
- for (i = 0; i < ptrlen; i++) {
- int shift = ptrlen - 1 - i;
- if (shift >= 4) {
- ptr[i] = 0;
- } else {
- ptr[i] = (val >> shift) & 0xFF;
- }
- }
-}
-
-static void damage_array(unsigned char *sig, size_t *len) {
- int pos;
- int action = secp256k1_rand_bits(3);
- if (action < 1 && *len > 3) {
- /* Delete a byte. */
- pos = secp256k1_rand_int(*len);
- memmove(sig + pos, sig + pos + 1, *len - pos - 1);
- (*len)--;
- return;
- } else if (action < 2 && *len < 2048) {
- /* Insert a byte. */
- pos = secp256k1_rand_int(1 + *len);
- memmove(sig + pos + 1, sig + pos, *len - pos);
- sig[pos] = secp256k1_rand_bits(8);
- (*len)++;
- return;
- } else if (action < 4) {
- /* Modify a byte. */
- sig[secp256k1_rand_int(*len)] += 1 + secp256k1_rand_int(255);
- return;
- } else { /* action < 8 */
- /* Modify a bit. */
- sig[secp256k1_rand_int(*len)] ^= 1 << secp256k1_rand_bits(3);
- return;
- }
-}
-
-static void random_ber_signature(unsigned char *sig, size_t *len, int* certainly_der, int* certainly_not_der) {
- int der;
- int nlow[2], nlen[2], nlenlen[2], nhbit[2], nhbyte[2], nzlen[2];
- size_t tlen, elen, glen;
- int indet;
- int n;
-
- *len = 0;
- der = secp256k1_rand_bits(2) == 0;
- *certainly_der = der;
- *certainly_not_der = 0;
- indet = der ? 0 : secp256k1_rand_int(10) == 0;
-
- for (n = 0; n < 2; n++) {
- /* We generate two classes of numbers: nlow==1 "low" ones (up to 32 bytes), nlow==0 "high" ones (32 bytes with 129 top bits set, or larger than 32 bytes) */
- nlow[n] = der ? 1 : (secp256k1_rand_bits(3) != 0);
- /* The length of the number in bytes (the first byte of which will always be nonzero) */
- nlen[n] = nlow[n] ? secp256k1_rand_int(33) : 32 + secp256k1_rand_int(200) * secp256k1_rand_int(8) / 8;
- CHECK(nlen[n] <= 232);
- /* The top bit of the number. */
- nhbit[n] = (nlow[n] == 0 && nlen[n] == 32) ? 1 : (nlen[n] == 0 ? 0 : secp256k1_rand_bits(1));
- /* The top byte of the number (after the potential hardcoded 16 0xFF characters for "high" 32 bytes numbers) */
- nhbyte[n] = nlen[n] == 0 ? 0 : (nhbit[n] ? 128 + secp256k1_rand_bits(7) : 1 + secp256k1_rand_int(127));
- /* The number of zero bytes in front of the number (which is 0 or 1 in case of DER, otherwise we extend up to 300 bytes) */
- nzlen[n] = der ? ((nlen[n] == 0 || nhbit[n]) ? 1 : 0) : (nlow[n] ? secp256k1_rand_int(3) : secp256k1_rand_int(300 - nlen[n]) * secp256k1_rand_int(8) / 8);
- if (nzlen[n] > ((nlen[n] == 0 || nhbit[n]) ? 1 : 0)) {
- *certainly_not_der = 1;
- }
- CHECK(nlen[n] + nzlen[n] <= 300);
- /* The length of the length descriptor for the number. 0 means short encoding, anything else is long encoding. */
- nlenlen[n] = nlen[n] + nzlen[n] < 128 ? 0 : (nlen[n] + nzlen[n] < 256 ? 1 : 2);
- if (!der) {
- /* nlenlen[n] max 127 bytes */
- int add = secp256k1_rand_int(127 - nlenlen[n]) * secp256k1_rand_int(16) * secp256k1_rand_int(16) / 256;
- nlenlen[n] += add;
- if (add != 0) {
- *certainly_not_der = 1;
- }
- }
- CHECK(nlen[n] + nzlen[n] + nlenlen[n] <= 427);
- }
-
- /* The total length of the data to go, so far */
- tlen = 2 + nlenlen[0] + nlen[0] + nzlen[0] + 2 + nlenlen[1] + nlen[1] + nzlen[1];
- CHECK(tlen <= 856);
-
- /* The length of the garbage inside the tuple. */
- elen = (der || indet) ? 0 : secp256k1_rand_int(980 - tlen) * secp256k1_rand_int(8) / 8;
- if (elen != 0) {
- *certainly_not_der = 1;
- }
- tlen += elen;
- CHECK(tlen <= 980);
-
- /* The length of the garbage after the end of the tuple. */
- glen = der ? 0 : secp256k1_rand_int(990 - tlen) * secp256k1_rand_int(8) / 8;
- if (glen != 0) {
- *certainly_not_der = 1;
- }
- CHECK(tlen + glen <= 990);
-
- /* Write the tuple header. */
- sig[(*len)++] = 0x30;
- if (indet) {
- /* Indeterminate length */
- sig[(*len)++] = 0x80;
- *certainly_not_der = 1;
- } else {
- int tlenlen = tlen < 128 ? 0 : (tlen < 256 ? 1 : 2);
- if (!der) {
- int add = secp256k1_rand_int(127 - tlenlen) * secp256k1_rand_int(16) * secp256k1_rand_int(16) / 256;
- tlenlen += add;
- if (add != 0) {
- *certainly_not_der = 1;
- }
- }
- if (tlenlen == 0) {
- /* Short length notation */
- sig[(*len)++] = tlen;
- } else {
- /* Long length notation */
- sig[(*len)++] = 128 + tlenlen;
- assign_big_endian(sig + *len, tlenlen, tlen);
- *len += tlenlen;
- }
- tlen += tlenlen;
- }
- tlen += 2;
- CHECK(tlen + glen <= 1119);
-
- for (n = 0; n < 2; n++) {
- /* Write the integer header. */
- sig[(*len)++] = 0x02;
- if (nlenlen[n] == 0) {
- /* Short length notation */
- sig[(*len)++] = nlen[n] + nzlen[n];
- } else {
- /* Long length notation. */
- sig[(*len)++] = 128 + nlenlen[n];
- assign_big_endian(sig + *len, nlenlen[n], nlen[n] + nzlen[n]);
- *len += nlenlen[n];
- }
- /* Write zero padding */
- while (nzlen[n] > 0) {
- sig[(*len)++] = 0x00;
- nzlen[n]--;
- }
- if (nlen[n] == 32 && !nlow[n]) {
- /* Special extra 16 0xFF bytes in "high" 32-byte numbers */
- int i;
- for (i = 0; i < 16; i++) {
- sig[(*len)++] = 0xFF;
- }
- nlen[n] -= 16;
- }
- /* Write first byte of number */
- if (nlen[n] > 0) {
- sig[(*len)++] = nhbyte[n];
- nlen[n]--;
- }
- /* Generate remaining random bytes of number */
- secp256k1_rand_bytes_test(sig + *len, nlen[n]);
- *len += nlen[n];
- nlen[n] = 0;
- }
-
- /* Generate random garbage inside tuple. */
- secp256k1_rand_bytes_test(sig + *len, elen);
- *len += elen;
-
- /* Generate end-of-contents bytes. */
- if (indet) {
- sig[(*len)++] = 0;
- sig[(*len)++] = 0;
- tlen += 2;
- }
- CHECK(tlen + glen <= 1121);
-
- /* Generate random garbage outside tuple. */
- secp256k1_rand_bytes_test(sig + *len, glen);
- *len += glen;
- tlen += glen;
- CHECK(tlen <= 1121);
- CHECK(tlen == *len);
-}
-
-void run_ecdsa_der_parse(void) {
- int i,j;
- for (i = 0; i < 200 * count; i++) {
- unsigned char buffer[2048];
- size_t buflen = 0;
- int certainly_der = 0;
- int certainly_not_der = 0;
- random_ber_signature(buffer, &buflen, &certainly_der, &certainly_not_der);
- CHECK(buflen <= 2048);
- for (j = 0; j < 16; j++) {
- int ret = 0;
- if (j > 0) {
- damage_array(buffer, &buflen);
- /* We don't know anything anymore about the DERness of the result */
- certainly_der = 0;
- certainly_not_der = 0;
- }
- ret = test_ecdsa_der_parse(buffer, buflen, certainly_der, certainly_not_der);
- if (ret != 0) {
- size_t k;
- fprintf(stderr, "Failure %x on ", ret);
- for (k = 0; k < buflen; k++) {
- fprintf(stderr, "%02x ", buffer[k]);
- }
- fprintf(stderr, "\n");
- }
- CHECK(ret == 0);
- }
- }
-}
-
-/* Tests several edge cases. */
-void test_ecdsa_edge_cases(void) {
- int t;
- secp256k1_ecdsa_signature sig;
-
- /* Test the case where ECDSA recomputes a point that is infinity. */
- {
- secp256k1_gej keyj;
- secp256k1_ge key;
- secp256k1_scalar msg;
- secp256k1_scalar sr, ss;
- secp256k1_scalar_set_int(&ss, 1);
- secp256k1_scalar_negate(&ss, &ss);
- secp256k1_scalar_inverse(&ss, &ss);
- secp256k1_scalar_set_int(&sr, 1);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &keyj, &sr);
- secp256k1_ge_set_gej(&key, &keyj);
- msg = ss;
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 0);
- }
-
- /* Verify signature with r of zero fails. */
- {
- const unsigned char pubkey_mods_zero[33] = {
- 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xfe, 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0,
- 0x3b, 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41,
- 0x41
- };
- secp256k1_ge key;
- secp256k1_scalar msg;
- secp256k1_scalar sr, ss;
- secp256k1_scalar_set_int(&ss, 1);
- secp256k1_scalar_set_int(&msg, 0);
- secp256k1_scalar_set_int(&sr, 0);
- CHECK(secp256k1_eckey_pubkey_parse(&key, pubkey_mods_zero, 33));
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 0);
- }
-
- /* Verify signature with s of zero fails. */
- {
- const unsigned char pubkey[33] = {
- 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x01
- };
- secp256k1_ge key;
- secp256k1_scalar msg;
- secp256k1_scalar sr, ss;
- secp256k1_scalar_set_int(&ss, 0);
- secp256k1_scalar_set_int(&msg, 0);
- secp256k1_scalar_set_int(&sr, 1);
- CHECK(secp256k1_eckey_pubkey_parse(&key, pubkey, 33));
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 0);
- }
-
- /* Verify signature with message 0 passes. */
- {
- const unsigned char pubkey[33] = {
- 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x02
- };
- const unsigned char pubkey2[33] = {
- 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xfe, 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0,
- 0x3b, 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41,
- 0x43
- };
- secp256k1_ge key;
- secp256k1_ge key2;
- secp256k1_scalar msg;
- secp256k1_scalar sr, ss;
- secp256k1_scalar_set_int(&ss, 2);
- secp256k1_scalar_set_int(&msg, 0);
- secp256k1_scalar_set_int(&sr, 2);
- CHECK(secp256k1_eckey_pubkey_parse(&key, pubkey, 33));
- CHECK(secp256k1_eckey_pubkey_parse(&key2, pubkey2, 33));
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 1);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key2, &msg) == 1);
- secp256k1_scalar_negate(&ss, &ss);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 1);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key2, &msg) == 1);
- secp256k1_scalar_set_int(&ss, 1);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 0);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key2, &msg) == 0);
- }
-
- /* Verify signature with message 1 passes. */
- {
- const unsigned char pubkey[33] = {
- 0x02, 0x14, 0x4e, 0x5a, 0x58, 0xef, 0x5b, 0x22,
- 0x6f, 0xd2, 0xe2, 0x07, 0x6a, 0x77, 0xcf, 0x05,
- 0xb4, 0x1d, 0xe7, 0x4a, 0x30, 0x98, 0x27, 0x8c,
- 0x93, 0xe6, 0xe6, 0x3c, 0x0b, 0xc4, 0x73, 0x76,
- 0x25
- };
- const unsigned char pubkey2[33] = {
- 0x02, 0x8a, 0xd5, 0x37, 0xed, 0x73, 0xd9, 0x40,
- 0x1d, 0xa0, 0x33, 0xd2, 0xdc, 0xf0, 0xaf, 0xae,
- 0x34, 0xcf, 0x5f, 0x96, 0x4c, 0x73, 0x28, 0x0f,
- 0x92, 0xc0, 0xf6, 0x9d, 0xd9, 0xb2, 0x09, 0x10,
- 0x62
- };
- const unsigned char csr[32] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x45, 0x51, 0x23, 0x19, 0x50, 0xb7, 0x5f, 0xc4,
- 0x40, 0x2d, 0xa1, 0x72, 0x2f, 0xc9, 0xba, 0xeb
- };
- secp256k1_ge key;
- secp256k1_ge key2;
- secp256k1_scalar msg;
- secp256k1_scalar sr, ss;
- secp256k1_scalar_set_int(&ss, 1);
- secp256k1_scalar_set_int(&msg, 1);
- secp256k1_scalar_set_b32(&sr, csr, NULL);
- CHECK(secp256k1_eckey_pubkey_parse(&key, pubkey, 33));
- CHECK(secp256k1_eckey_pubkey_parse(&key2, pubkey2, 33));
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 1);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key2, &msg) == 1);
- secp256k1_scalar_negate(&ss, &ss);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 1);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key2, &msg) == 1);
- secp256k1_scalar_set_int(&ss, 2);
- secp256k1_scalar_inverse_var(&ss, &ss);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 0);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key2, &msg) == 0);
- }
-
- /* Verify signature with message -1 passes. */
- {
- const unsigned char pubkey[33] = {
- 0x03, 0xaf, 0x97, 0xff, 0x7d, 0x3a, 0xf6, 0xa0,
- 0x02, 0x94, 0xbd, 0x9f, 0x4b, 0x2e, 0xd7, 0x52,
- 0x28, 0xdb, 0x49, 0x2a, 0x65, 0xcb, 0x1e, 0x27,
- 0x57, 0x9c, 0xba, 0x74, 0x20, 0xd5, 0x1d, 0x20,
- 0xf1
- };
- const unsigned char csr[32] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x45, 0x51, 0x23, 0x19, 0x50, 0xb7, 0x5f, 0xc4,
- 0x40, 0x2d, 0xa1, 0x72, 0x2f, 0xc9, 0xba, 0xee
- };
- secp256k1_ge key;
- secp256k1_scalar msg;
- secp256k1_scalar sr, ss;
- secp256k1_scalar_set_int(&ss, 1);
- secp256k1_scalar_set_int(&msg, 1);
- secp256k1_scalar_negate(&msg, &msg);
- secp256k1_scalar_set_b32(&sr, csr, NULL);
- CHECK(secp256k1_eckey_pubkey_parse(&key, pubkey, 33));
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 1);
- secp256k1_scalar_negate(&ss, &ss);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 1);
- secp256k1_scalar_set_int(&ss, 3);
- secp256k1_scalar_inverse_var(&ss, &ss);
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sr, &ss, &key, &msg) == 0);
- }
-
- /* Signature where s would be zero. */
- {
- secp256k1_pubkey pubkey;
- size_t siglen;
- int32_t ecount;
- unsigned char signature[72];
- static const unsigned char nonce[32] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- };
- static const unsigned char nonce2[32] = {
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
- 0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,
- 0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x40
- };
- const unsigned char key[32] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- };
- unsigned char msg[32] = {
- 0x86, 0x41, 0x99, 0x81, 0x06, 0x23, 0x44, 0x53,
- 0xaa, 0x5f, 0x9d, 0x6a, 0x31, 0x78, 0xf4, 0xf7,
- 0xb8, 0x12, 0xe0, 0x0b, 0x81, 0x7a, 0x77, 0x62,
- 0x65, 0xdf, 0xdd, 0x31, 0xb9, 0x3e, 0x29, 0xa9,
- };
- ecount = 0;
- secp256k1_context_set_illegal_callback(ctx, counting_illegal_callback_fn, &ecount);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, precomputed_nonce_function, nonce) == 0);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, precomputed_nonce_function, nonce2) == 0);
- msg[31] = 0xaa;
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, precomputed_nonce_function, nonce) == 1);
- CHECK(ecount == 0);
- CHECK(secp256k1_ecdsa_sign(ctx, NULL, msg, key, precomputed_nonce_function, nonce2) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, NULL, key, precomputed_nonce_function, nonce2) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, NULL, precomputed_nonce_function, nonce2) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, precomputed_nonce_function, nonce2) == 1);
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, key) == 1);
- CHECK(secp256k1_ecdsa_verify(ctx, NULL, msg, &pubkey) == 0);
- CHECK(ecount == 4);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, NULL, &pubkey) == 0);
- CHECK(ecount == 5);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg, NULL) == 0);
- CHECK(ecount == 6);
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg, &pubkey) == 1);
- CHECK(ecount == 6);
- CHECK(secp256k1_ec_pubkey_create(ctx, &pubkey, NULL) == 0);
- CHECK(ecount == 7);
- /* That pubkeyload fails via an ARGCHECK is a little odd but makes sense because pubkeys are an opaque data type. */
- CHECK(secp256k1_ecdsa_verify(ctx, &sig, msg, &pubkey) == 0);
- CHECK(ecount == 8);
- siglen = 72;
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, NULL, &siglen, &sig) == 0);
- CHECK(ecount == 9);
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, signature, NULL, &sig) == 0);
- CHECK(ecount == 10);
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, signature, &siglen, NULL) == 0);
- CHECK(ecount == 11);
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, signature, &siglen, &sig) == 1);
- CHECK(ecount == 11);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, NULL, signature, siglen) == 0);
- CHECK(ecount == 12);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, NULL, siglen) == 0);
- CHECK(ecount == 13);
- CHECK(secp256k1_ecdsa_signature_parse_der(ctx, &sig, signature, siglen) == 1);
- CHECK(ecount == 13);
- siglen = 10;
- /* Too little room for a signature does not fail via ARGCHECK. */
- CHECK(secp256k1_ecdsa_signature_serialize_der(ctx, signature, &siglen, &sig) == 0);
- CHECK(ecount == 13);
- ecount = 0;
- CHECK(secp256k1_ecdsa_signature_normalize(ctx, NULL, NULL) == 0);
- CHECK(ecount == 1);
- CHECK(secp256k1_ecdsa_signature_serialize_compact(ctx, NULL, &sig) == 0);
- CHECK(ecount == 2);
- CHECK(secp256k1_ecdsa_signature_serialize_compact(ctx, signature, NULL) == 0);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdsa_signature_serialize_compact(ctx, signature, &sig) == 1);
- CHECK(ecount == 3);
- CHECK(secp256k1_ecdsa_signature_parse_compact(ctx, NULL, signature) == 0);
- CHECK(ecount == 4);
- CHECK(secp256k1_ecdsa_signature_parse_compact(ctx, &sig, NULL) == 0);
- CHECK(ecount == 5);
- CHECK(secp256k1_ecdsa_signature_parse_compact(ctx, &sig, signature) == 1);
- CHECK(ecount == 5);
- memset(signature, 255, 64);
- CHECK(secp256k1_ecdsa_signature_parse_compact(ctx, &sig, signature) == 0);
- CHECK(ecount == 5);
- secp256k1_context_set_illegal_callback(ctx, NULL, NULL);
- }
-
- /* Nonce function corner cases. */
- for (t = 0; t < 2; t++) {
- static const unsigned char zero[32] = {0x00};
- int i;
- unsigned char key[32];
- unsigned char msg[32];
- secp256k1_ecdsa_signature sig2;
- secp256k1_scalar sr[512], ss;
- const unsigned char *extra;
- extra = t == 0 ? NULL : zero;
- memset(msg, 0, 32);
- msg[31] = 1;
- /* High key results in signature failure. */
- memset(key, 0xFF, 32);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, NULL, extra) == 0);
- CHECK(is_empty_signature(&sig));
- /* Zero key results in signature failure. */
- memset(key, 0, 32);
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, NULL, extra) == 0);
- CHECK(is_empty_signature(&sig));
- /* Nonce function failure results in signature failure. */
- key[31] = 1;
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, nonce_function_test_fail, extra) == 0);
- CHECK(is_empty_signature(&sig));
- /* The retry loop successfully makes its way to the first good value. */
- CHECK(secp256k1_ecdsa_sign(ctx, &sig, msg, key, nonce_function_test_retry, extra) == 1);
- CHECK(!is_empty_signature(&sig));
- CHECK(secp256k1_ecdsa_sign(ctx, &sig2, msg, key, nonce_function_rfc6979, extra) == 1);
- CHECK(!is_empty_signature(&sig2));
- CHECK(memcmp(&sig, &sig2, sizeof(sig)) == 0);
- /* The default nonce function is deterministic. */
- CHECK(secp256k1_ecdsa_sign(ctx, &sig2, msg, key, NULL, extra) == 1);
- CHECK(!is_empty_signature(&sig2));
- CHECK(memcmp(&sig, &sig2, sizeof(sig)) == 0);
- /* The default nonce function changes output with different messages. */
- for(i = 0; i < 256; i++) {
- int j;
- msg[0] = i;
- CHECK(secp256k1_ecdsa_sign(ctx, &sig2, msg, key, NULL, extra) == 1);
- CHECK(!is_empty_signature(&sig2));
- secp256k1_ecdsa_signature_load(ctx, &sr[i], &ss, &sig2);
- for (j = 0; j < i; j++) {
- CHECK(!secp256k1_scalar_eq(&sr[i], &sr[j]));
- }
- }
- msg[0] = 0;
- msg[31] = 2;
- /* The default nonce function changes output with different keys. */
- for(i = 256; i < 512; i++) {
- int j;
- key[0] = i - 256;
- CHECK(secp256k1_ecdsa_sign(ctx, &sig2, msg, key, NULL, extra) == 1);
- CHECK(!is_empty_signature(&sig2));
- secp256k1_ecdsa_signature_load(ctx, &sr[i], &ss, &sig2);
- for (j = 0; j < i; j++) {
- CHECK(!secp256k1_scalar_eq(&sr[i], &sr[j]));
- }
- }
- key[0] = 0;
- }
-
- {
- /* Check that optional nonce arguments do not have equivalent effect. */
- const unsigned char zeros[32] = {0};
- unsigned char nonce[32];
- unsigned char nonce2[32];
- unsigned char nonce3[32];
- unsigned char nonce4[32];
- VG_UNDEF(nonce,32);
- VG_UNDEF(nonce2,32);
- VG_UNDEF(nonce3,32);
- VG_UNDEF(nonce4,32);
- CHECK(nonce_function_rfc6979(nonce, zeros, zeros, NULL, NULL, 0) == 1);
- VG_CHECK(nonce,32);
- CHECK(nonce_function_rfc6979(nonce2, zeros, zeros, zeros, NULL, 0) == 1);
- VG_CHECK(nonce2,32);
- CHECK(nonce_function_rfc6979(nonce3, zeros, zeros, NULL, (void *)zeros, 0) == 1);
- VG_CHECK(nonce3,32);
- CHECK(nonce_function_rfc6979(nonce4, zeros, zeros, zeros, (void *)zeros, 0) == 1);
- VG_CHECK(nonce4,32);
- CHECK(memcmp(nonce, nonce2, 32) != 0);
- CHECK(memcmp(nonce, nonce3, 32) != 0);
- CHECK(memcmp(nonce, nonce4, 32) != 0);
- CHECK(memcmp(nonce2, nonce3, 32) != 0);
- CHECK(memcmp(nonce2, nonce4, 32) != 0);
- CHECK(memcmp(nonce3, nonce4, 32) != 0);
- }
-
-
- /* Privkey export where pubkey is the point at infinity. */
- {
- unsigned char privkey[300];
- unsigned char seckey[32] = {
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
- 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41,
- };
- size_t outlen = 300;
- CHECK(!ec_privkey_export_der(ctx, privkey, &outlen, seckey, 0));
- outlen = 300;
- CHECK(!ec_privkey_export_der(ctx, privkey, &outlen, seckey, 1));
- }
-}
-
-void run_ecdsa_edge_cases(void) {
- test_ecdsa_edge_cases();
-}
-
-#ifdef ENABLE_OPENSSL_TESTS
-EC_KEY *get_openssl_key(const unsigned char *key32) {
- unsigned char privkey[300];
- size_t privkeylen;
- const unsigned char* pbegin = privkey;
- int compr = secp256k1_rand_bits(1);
- EC_KEY *ec_key = EC_KEY_new_by_curve_name(NID_secp256k1);
- CHECK(ec_privkey_export_der(ctx, privkey, &privkeylen, key32, compr));
- CHECK(d2i_ECPrivateKey(&ec_key, &pbegin, privkeylen));
- CHECK(EC_KEY_check_key(ec_key));
- return ec_key;
-}
-
-void test_ecdsa_openssl(void) {
- secp256k1_gej qj;
- secp256k1_ge q;
- secp256k1_scalar sigr, sigs;
- secp256k1_scalar one;
- secp256k1_scalar msg2;
- secp256k1_scalar key, msg;
- EC_KEY *ec_key;
- unsigned int sigsize = 80;
- size_t secp_sigsize = 80;
- unsigned char message[32];
- unsigned char signature[80];
- unsigned char key32[32];
- secp256k1_rand256_test(message);
- secp256k1_scalar_set_b32(&msg, message, NULL);
- random_scalar_order_test(&key);
- secp256k1_scalar_get_b32(key32, &key);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &qj, &key);
- secp256k1_ge_set_gej(&q, &qj);
- ec_key = get_openssl_key(key32);
- CHECK(ec_key != NULL);
- CHECK(ECDSA_sign(0, message, sizeof(message), signature, &sigsize, ec_key));
- CHECK(secp256k1_ecdsa_sig_parse(&sigr, &sigs, signature, sigsize));
- CHECK(secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sigr, &sigs, &q, &msg));
- secp256k1_scalar_set_int(&one, 1);
- secp256k1_scalar_add(&msg2, &msg, &one);
- CHECK(!secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &sigr, &sigs, &q, &msg2));
-
- random_sign(&sigr, &sigs, &key, &msg, NULL);
- CHECK(secp256k1_ecdsa_sig_serialize(signature, &secp_sigsize, &sigr, &sigs));
- CHECK(ECDSA_verify(0, message, sizeof(message), signature, secp_sigsize, ec_key) == 1);
-
- EC_KEY_free(ec_key);
-}
-
-void run_ecdsa_openssl(void) {
- int i;
- for (i = 0; i < 10*count; i++) {
- test_ecdsa_openssl();
- }
-}
-#endif
-
-#ifdef ENABLE_MODULE_ECDH
-# include "modules/ecdh/tests_impl.h"
-#endif
-
-#ifdef ENABLE_MODULE_SCHNORR
-# include "modules/schnorr/tests_impl.h"
-#endif
-
-#ifdef ENABLE_MODULE_RECOVERY
-# include "modules/recovery/tests_impl.h"
-#endif
-
-int main(int argc, char **argv) {
- unsigned char seed16[16] = {0};
- unsigned char run32[32] = {0};
- /* find iteration count */
- if (argc > 1) {
- count = strtol(argv[1], NULL, 0);
- }
-
- /* find random seed */
- if (argc > 2) {
- int pos = 0;
- const char* ch = argv[2];
- while (pos < 16 && ch[0] != 0 && ch[1] != 0) {
- unsigned short sh;
- if (sscanf(ch, "%2hx", &sh)) {
- seed16[pos] = sh;
- } else {
- break;
- }
- ch += 2;
- pos++;
- }
- } else {
- FILE *frand = fopen("/dev/urandom", "r");
- if ((frand == NULL) || !fread(&seed16, sizeof(seed16), 1, frand)) {
- uint64_t t = time(NULL) * (uint64_t)1337;
- seed16[0] ^= t;
- seed16[1] ^= t >> 8;
- seed16[2] ^= t >> 16;
- seed16[3] ^= t >> 24;
- seed16[4] ^= t >> 32;
- seed16[5] ^= t >> 40;
- seed16[6] ^= t >> 48;
- seed16[7] ^= t >> 56;
- }
- fclose(frand);
- }
- secp256k1_rand_seed(seed16);
-
- printf("test count = %i\n", count);
- printf("random seed = %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n", seed16[0], seed16[1], seed16[2], seed16[3], seed16[4], seed16[5], seed16[6], seed16[7], seed16[8], seed16[9], seed16[10], seed16[11], seed16[12], seed16[13], seed16[14], seed16[15]);
-
- /* initialize */
- run_context_tests();
- ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
- if (secp256k1_rand_bits(1)) {
- secp256k1_rand256(run32);
- CHECK(secp256k1_context_randomize(ctx, secp256k1_rand_bits(1) ? run32 : NULL));
- }
-
- run_rand_bits();
- run_rand_int();
-
- run_sha256_tests();
- run_hmac_sha256_tests();
- run_rfc6979_hmac_sha256_tests();
-
-#ifndef USE_NUM_NONE
- /* num tests */
- run_num_smalltests();
-#endif
-
- /* scalar tests */
- run_scalar_tests();
-
- /* field tests */
- run_field_inv();
- run_field_inv_var();
- run_field_inv_all_var();
- run_field_misc();
- run_field_convert();
- run_sqr();
- run_sqrt();
-
- /* group tests */
- run_ge();
- run_group_decompress();
-
- /* ecmult tests */
- run_wnaf();
- run_point_times_order();
- run_ecmult_chain();
- run_ecmult_constants();
- run_ecmult_gen_blind();
- run_ecmult_const_tests();
- run_ec_combine();
-
- /* endomorphism tests */
-#ifdef USE_ENDOMORPHISM
- run_endomorphism_tests();
-#endif
-
- /* EC point parser test */
- run_ec_pubkey_parse_test();
-
- /* EC key edge cases */
- run_eckey_edge_case_test();
-
-#ifdef ENABLE_MODULE_ECDH
- /* ecdh tests */
- run_ecdh_tests();
-#endif
-
- /* ecdsa tests */
- run_random_pubkeys();
- run_ecdsa_der_parse();
- run_ecdsa_sign_verify();
- run_ecdsa_end_to_end();
- run_ecdsa_edge_cases();
-#ifdef ENABLE_OPENSSL_TESTS
- run_ecdsa_openssl();
-#endif
-
-#ifdef ENABLE_MODULE_SCHNORR
- /* Schnorr tests */
- run_schnorr_tests();
-#endif
-
-#ifdef ENABLE_MODULE_RECOVERY
- /* ECDSA pubkey recovery tests */
- run_recovery_tests();
-#endif
-
- secp256k1_rand256(run32);
- printf("random run = %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n", run32[0], run32[1], run32[2], run32[3], run32[4], run32[5], run32[6], run32[7], run32[8], run32[9], run32[10], run32[11], run32[12], run32[13], run32[14], run32[15]);
-
- /* shutdown */
- secp256k1_context_destroy(ctx);
-
- printf("no problems found\n");
- return 0;
-}
diff --git a/crypto/secp256k1/libsecp256k1/src/tests_exhaustive.c b/crypto/secp256k1/libsecp256k1/src/tests_exhaustive.c
deleted file mode 100644
index b040bb0733..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/tests_exhaustive.c
+++ /dev/null
@@ -1,470 +0,0 @@
-/***********************************************************************
- * Copyright (c) 2016 Andrew Poelstra *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#include
-#include
-
-#include
-
-#undef USE_ECMULT_STATIC_PRECOMPUTATION
-
-#ifndef EXHAUSTIVE_TEST_ORDER
-/* see group_impl.h for allowable values */
-#define EXHAUSTIVE_TEST_ORDER 13
-#define EXHAUSTIVE_TEST_LAMBDA 9 /* cube root of 1 mod 13 */
-#endif
-
-#include "include/secp256k1.h"
-#include "group.h"
-#include "secp256k1.c"
-#include "testrand_impl.h"
-
-#ifdef ENABLE_MODULE_RECOVERY
-#include "src/modules/recovery/main_impl.h"
-#include "include/secp256k1_recovery.h"
-#endif
-
-/** stolen from tests.c */
-void ge_equals_ge(const secp256k1_ge *a, const secp256k1_ge *b) {
- CHECK(a->infinity == b->infinity);
- if (a->infinity) {
- return;
- }
- CHECK(secp256k1_fe_equal_var(&a->x, &b->x));
- CHECK(secp256k1_fe_equal_var(&a->y, &b->y));
-}
-
-void ge_equals_gej(const secp256k1_ge *a, const secp256k1_gej *b) {
- secp256k1_fe z2s;
- secp256k1_fe u1, u2, s1, s2;
- CHECK(a->infinity == b->infinity);
- if (a->infinity) {
- return;
- }
- /* Check a.x * b.z^2 == b.x && a.y * b.z^3 == b.y, to avoid inverses. */
- secp256k1_fe_sqr(&z2s, &b->z);
- secp256k1_fe_mul(&u1, &a->x, &z2s);
- u2 = b->x; secp256k1_fe_normalize_weak(&u2);
- secp256k1_fe_mul(&s1, &a->y, &z2s); secp256k1_fe_mul(&s1, &s1, &b->z);
- s2 = b->y; secp256k1_fe_normalize_weak(&s2);
- CHECK(secp256k1_fe_equal_var(&u1, &u2));
- CHECK(secp256k1_fe_equal_var(&s1, &s2));
-}
-
-void random_fe(secp256k1_fe *x) {
- unsigned char bin[32];
- do {
- secp256k1_rand256(bin);
- if (secp256k1_fe_set_b32(x, bin)) {
- return;
- }
- } while(1);
-}
-/** END stolen from tests.c */
-
-int secp256k1_nonce_function_smallint(unsigned char *nonce32, const unsigned char *msg32,
- const unsigned char *key32, const unsigned char *algo16,
- void *data, unsigned int attempt) {
- secp256k1_scalar s;
- int *idata = data;
- (void)msg32;
- (void)key32;
- (void)algo16;
- /* Some nonces cannot be used because they'd cause s and/or r to be zero.
- * The signing function has retry logic here that just re-calls the nonce
- * function with an increased `attempt`. So if attempt > 0 this means we
- * need to change the nonce to avoid an infinite loop. */
- if (attempt > 0) {
- *idata = (*idata + 1) % EXHAUSTIVE_TEST_ORDER;
- }
- secp256k1_scalar_set_int(&s, *idata);
- secp256k1_scalar_get_b32(nonce32, &s);
- return 1;
-}
-
-#ifdef USE_ENDOMORPHISM
-void test_exhaustive_endomorphism(const secp256k1_ge *group, int order) {
- int i;
- for (i = 0; i < order; i++) {
- secp256k1_ge res;
- secp256k1_ge_mul_lambda(&res, &group[i]);
- ge_equals_ge(&group[i * EXHAUSTIVE_TEST_LAMBDA % EXHAUSTIVE_TEST_ORDER], &res);
- }
-}
-#endif
-
-void test_exhaustive_addition(const secp256k1_ge *group, const secp256k1_gej *groupj, int order) {
- int i, j;
-
- /* Sanity-check (and check infinity functions) */
- CHECK(secp256k1_ge_is_infinity(&group[0]));
- CHECK(secp256k1_gej_is_infinity(&groupj[0]));
- for (i = 1; i < order; i++) {
- CHECK(!secp256k1_ge_is_infinity(&group[i]));
- CHECK(!secp256k1_gej_is_infinity(&groupj[i]));
- }
-
- /* Check all addition formulae */
- for (j = 0; j < order; j++) {
- secp256k1_fe fe_inv;
- secp256k1_fe_inv(&fe_inv, &groupj[j].z);
- for (i = 0; i < order; i++) {
- secp256k1_ge zless_gej;
- secp256k1_gej tmp;
- /* add_var */
- secp256k1_gej_add_var(&tmp, &groupj[i], &groupj[j], NULL);
- ge_equals_gej(&group[(i + j) % order], &tmp);
- /* add_ge */
- if (j > 0) {
- secp256k1_gej_add_ge(&tmp, &groupj[i], &group[j]);
- ge_equals_gej(&group[(i + j) % order], &tmp);
- }
- /* add_ge_var */
- secp256k1_gej_add_ge_var(&tmp, &groupj[i], &group[j], NULL);
- ge_equals_gej(&group[(i + j) % order], &tmp);
- /* add_zinv_var */
- zless_gej.infinity = groupj[j].infinity;
- zless_gej.x = groupj[j].x;
- zless_gej.y = groupj[j].y;
- secp256k1_gej_add_zinv_var(&tmp, &groupj[i], &zless_gej, &fe_inv);
- ge_equals_gej(&group[(i + j) % order], &tmp);
- }
- }
-
- /* Check doubling */
- for (i = 0; i < order; i++) {
- secp256k1_gej tmp;
- if (i > 0) {
- secp256k1_gej_double_nonzero(&tmp, &groupj[i], NULL);
- ge_equals_gej(&group[(2 * i) % order], &tmp);
- }
- secp256k1_gej_double_var(&tmp, &groupj[i], NULL);
- ge_equals_gej(&group[(2 * i) % order], &tmp);
- }
-
- /* Check negation */
- for (i = 1; i < order; i++) {
- secp256k1_ge tmp;
- secp256k1_gej tmpj;
- secp256k1_ge_neg(&tmp, &group[i]);
- ge_equals_ge(&group[order - i], &tmp);
- secp256k1_gej_neg(&tmpj, &groupj[i]);
- ge_equals_gej(&group[order - i], &tmpj);
- }
-}
-
-void test_exhaustive_ecmult(const secp256k1_context *ctx, const secp256k1_ge *group, const secp256k1_gej *groupj, int order) {
- int i, j, r_log;
- for (r_log = 1; r_log < order; r_log++) {
- for (j = 0; j < order; j++) {
- for (i = 0; i < order; i++) {
- secp256k1_gej tmp;
- secp256k1_scalar na, ng;
- secp256k1_scalar_set_int(&na, i);
- secp256k1_scalar_set_int(&ng, j);
-
- secp256k1_ecmult(&ctx->ecmult_ctx, &tmp, &groupj[r_log], &na, &ng);
- ge_equals_gej(&group[(i * r_log + j) % order], &tmp);
-
- if (i > 0) {
- secp256k1_ecmult_const(&tmp, &group[i], &ng);
- ge_equals_gej(&group[(i * j) % order], &tmp);
- }
- }
- }
- }
-}
-
-void r_from_k(secp256k1_scalar *r, const secp256k1_ge *group, int k) {
- secp256k1_fe x;
- unsigned char x_bin[32];
- k %= EXHAUSTIVE_TEST_ORDER;
- x = group[k].x;
- secp256k1_fe_normalize(&x);
- secp256k1_fe_get_b32(x_bin, &x);
- secp256k1_scalar_set_b32(r, x_bin, NULL);
-}
-
-void test_exhaustive_verify(const secp256k1_context *ctx, const secp256k1_ge *group, int order) {
- int s, r, msg, key;
- for (s = 1; s < order; s++) {
- for (r = 1; r < order; r++) {
- for (msg = 1; msg < order; msg++) {
- for (key = 1; key < order; key++) {
- secp256k1_ge nonconst_ge;
- secp256k1_ecdsa_signature sig;
- secp256k1_pubkey pk;
- secp256k1_scalar sk_s, msg_s, r_s, s_s;
- secp256k1_scalar s_times_k_s, msg_plus_r_times_sk_s;
- int k, should_verify;
- unsigned char msg32[32];
-
- secp256k1_scalar_set_int(&s_s, s);
- secp256k1_scalar_set_int(&r_s, r);
- secp256k1_scalar_set_int(&msg_s, msg);
- secp256k1_scalar_set_int(&sk_s, key);
-
- /* Verify by hand */
- /* Run through every k value that gives us this r and check that *one* works.
- * Note there could be none, there could be multiple, ECDSA is weird. */
- should_verify = 0;
- for (k = 0; k < order; k++) {
- secp256k1_scalar check_x_s;
- r_from_k(&check_x_s, group, k);
- if (r_s == check_x_s) {
- secp256k1_scalar_set_int(&s_times_k_s, k);
- secp256k1_scalar_mul(&s_times_k_s, &s_times_k_s, &s_s);
- secp256k1_scalar_mul(&msg_plus_r_times_sk_s, &r_s, &sk_s);
- secp256k1_scalar_add(&msg_plus_r_times_sk_s, &msg_plus_r_times_sk_s, &msg_s);
- should_verify |= secp256k1_scalar_eq(&s_times_k_s, &msg_plus_r_times_sk_s);
- }
- }
- /* nb we have a "high s" rule */
- should_verify &= !secp256k1_scalar_is_high(&s_s);
-
- /* Verify by calling verify */
- secp256k1_ecdsa_signature_save(&sig, &r_s, &s_s);
- memcpy(&nonconst_ge, &group[sk_s], sizeof(nonconst_ge));
- secp256k1_pubkey_save(&pk, &nonconst_ge);
- secp256k1_scalar_get_b32(msg32, &msg_s);
- CHECK(should_verify ==
- secp256k1_ecdsa_verify(ctx, &sig, msg32, &pk));
- }
- }
- }
- }
-}
-
-void test_exhaustive_sign(const secp256k1_context *ctx, const secp256k1_ge *group, int order) {
- int i, j, k;
-
- /* Loop */
- for (i = 1; i < order; i++) { /* message */
- for (j = 1; j < order; j++) { /* key */
- for (k = 1; k < order; k++) { /* nonce */
- const int starting_k = k;
- secp256k1_ecdsa_signature sig;
- secp256k1_scalar sk, msg, r, s, expected_r;
- unsigned char sk32[32], msg32[32];
- secp256k1_scalar_set_int(&msg, i);
- secp256k1_scalar_set_int(&sk, j);
- secp256k1_scalar_get_b32(sk32, &sk);
- secp256k1_scalar_get_b32(msg32, &msg);
-
- secp256k1_ecdsa_sign(ctx, &sig, msg32, sk32, secp256k1_nonce_function_smallint, &k);
-
- secp256k1_ecdsa_signature_load(ctx, &r, &s, &sig);
- /* Note that we compute expected_r *after* signing -- this is important
- * because our nonce-computing function function might change k during
- * signing. */
- r_from_k(&expected_r, group, k);
- CHECK(r == expected_r);
- CHECK((k * s) % order == (i + r * j) % order ||
- (k * (EXHAUSTIVE_TEST_ORDER - s)) % order == (i + r * j) % order);
-
- /* Overflow means we've tried every possible nonce */
- if (k < starting_k) {
- break;
- }
- }
- }
- }
-
- /* We would like to verify zero-knowledge here by counting how often every
- * possible (s, r) tuple appears, but because the group order is larger
- * than the field order, when coercing the x-values to scalar values, some
- * appear more often than others, so we are actually not zero-knowledge.
- * (This effect also appears in the real code, but the difference is on the
- * order of 1/2^128th the field order, so the deviation is not useful to a
- * computationally bounded attacker.)
- */
-}
-
-#ifdef ENABLE_MODULE_RECOVERY
-void test_exhaustive_recovery_sign(const secp256k1_context *ctx, const secp256k1_ge *group, int order) {
- int i, j, k;
-
- /* Loop */
- for (i = 1; i < order; i++) { /* message */
- for (j = 1; j < order; j++) { /* key */
- for (k = 1; k < order; k++) { /* nonce */
- const int starting_k = k;
- secp256k1_fe r_dot_y_normalized;
- secp256k1_ecdsa_recoverable_signature rsig;
- secp256k1_ecdsa_signature sig;
- secp256k1_scalar sk, msg, r, s, expected_r;
- unsigned char sk32[32], msg32[32];
- int expected_recid;
- int recid;
- secp256k1_scalar_set_int(&msg, i);
- secp256k1_scalar_set_int(&sk, j);
- secp256k1_scalar_get_b32(sk32, &sk);
- secp256k1_scalar_get_b32(msg32, &msg);
-
- secp256k1_ecdsa_sign_recoverable(ctx, &rsig, msg32, sk32, secp256k1_nonce_function_smallint, &k);
-
- /* Check directly */
- secp256k1_ecdsa_recoverable_signature_load(ctx, &r, &s, &recid, &rsig);
- r_from_k(&expected_r, group, k);
- CHECK(r == expected_r);
- CHECK((k * s) % order == (i + r * j) % order ||
- (k * (EXHAUSTIVE_TEST_ORDER - s)) % order == (i + r * j) % order);
- /* In computing the recid, there is an overflow condition that is disabled in
- * scalar_low_impl.h `secp256k1_scalar_set_b32` because almost every r.y value
- * will exceed the group order, and our signing code always holds out for r
- * values that don't overflow, so with a proper overflow check the tests would
- * loop indefinitely. */
- r_dot_y_normalized = group[k].y;
- secp256k1_fe_normalize(&r_dot_y_normalized);
- /* Also the recovery id is flipped depending if we hit the low-s branch */
- if ((k * s) % order == (i + r * j) % order) {
- expected_recid = secp256k1_fe_is_odd(&r_dot_y_normalized) ? 1 : 0;
- } else {
- expected_recid = secp256k1_fe_is_odd(&r_dot_y_normalized) ? 0 : 1;
- }
- CHECK(recid == expected_recid);
-
- /* Convert to a standard sig then check */
- secp256k1_ecdsa_recoverable_signature_convert(ctx, &sig, &rsig);
- secp256k1_ecdsa_signature_load(ctx, &r, &s, &sig);
- /* Note that we compute expected_r *after* signing -- this is important
- * because our nonce-computing function function might change k during
- * signing. */
- r_from_k(&expected_r, group, k);
- CHECK(r == expected_r);
- CHECK((k * s) % order == (i + r * j) % order ||
- (k * (EXHAUSTIVE_TEST_ORDER - s)) % order == (i + r * j) % order);
-
- /* Overflow means we've tried every possible nonce */
- if (k < starting_k) {
- break;
- }
- }
- }
- }
-}
-
-void test_exhaustive_recovery_verify(const secp256k1_context *ctx, const secp256k1_ge *group, int order) {
- /* This is essentially a copy of test_exhaustive_verify, with recovery added */
- int s, r, msg, key;
- for (s = 1; s < order; s++) {
- for (r = 1; r < order; r++) {
- for (msg = 1; msg < order; msg++) {
- for (key = 1; key < order; key++) {
- secp256k1_ge nonconst_ge;
- secp256k1_ecdsa_recoverable_signature rsig;
- secp256k1_ecdsa_signature sig;
- secp256k1_pubkey pk;
- secp256k1_scalar sk_s, msg_s, r_s, s_s;
- secp256k1_scalar s_times_k_s, msg_plus_r_times_sk_s;
- int recid = 0;
- int k, should_verify;
- unsigned char msg32[32];
-
- secp256k1_scalar_set_int(&s_s, s);
- secp256k1_scalar_set_int(&r_s, r);
- secp256k1_scalar_set_int(&msg_s, msg);
- secp256k1_scalar_set_int(&sk_s, key);
- secp256k1_scalar_get_b32(msg32, &msg_s);
-
- /* Verify by hand */
- /* Run through every k value that gives us this r and check that *one* works.
- * Note there could be none, there could be multiple, ECDSA is weird. */
- should_verify = 0;
- for (k = 0; k < order; k++) {
- secp256k1_scalar check_x_s;
- r_from_k(&check_x_s, group, k);
- if (r_s == check_x_s) {
- secp256k1_scalar_set_int(&s_times_k_s, k);
- secp256k1_scalar_mul(&s_times_k_s, &s_times_k_s, &s_s);
- secp256k1_scalar_mul(&msg_plus_r_times_sk_s, &r_s, &sk_s);
- secp256k1_scalar_add(&msg_plus_r_times_sk_s, &msg_plus_r_times_sk_s, &msg_s);
- should_verify |= secp256k1_scalar_eq(&s_times_k_s, &msg_plus_r_times_sk_s);
- }
- }
- /* nb we have a "high s" rule */
- should_verify &= !secp256k1_scalar_is_high(&s_s);
-
- /* We would like to try recovering the pubkey and checking that it matches,
- * but pubkey recovery is impossible in the exhaustive tests (the reason
- * being that there are 12 nonzero r values, 12 nonzero points, and no
- * overlap between the sets, so there are no valid signatures). */
-
- /* Verify by converting to a standard signature and calling verify */
- secp256k1_ecdsa_recoverable_signature_save(&rsig, &r_s, &s_s, recid);
- secp256k1_ecdsa_recoverable_signature_convert(ctx, &sig, &rsig);
- memcpy(&nonconst_ge, &group[sk_s], sizeof(nonconst_ge));
- secp256k1_pubkey_save(&pk, &nonconst_ge);
- CHECK(should_verify ==
- secp256k1_ecdsa_verify(ctx, &sig, msg32, &pk));
- }
- }
- }
- }
-}
-#endif
-
-int main(void) {
- int i;
- secp256k1_gej groupj[EXHAUSTIVE_TEST_ORDER];
- secp256k1_ge group[EXHAUSTIVE_TEST_ORDER];
-
- /* Build context */
- secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
-
- /* TODO set z = 1, then do num_tests runs with random z values */
-
- /* Generate the entire group */
- secp256k1_gej_set_infinity(&groupj[0]);
- secp256k1_ge_set_gej(&group[0], &groupj[0]);
- for (i = 1; i < EXHAUSTIVE_TEST_ORDER; i++) {
- /* Set a different random z-value for each Jacobian point */
- secp256k1_fe z;
- random_fe(&z);
-
- secp256k1_gej_add_ge(&groupj[i], &groupj[i - 1], &secp256k1_ge_const_g);
- secp256k1_ge_set_gej(&group[i], &groupj[i]);
- secp256k1_gej_rescale(&groupj[i], &z);
-
- /* Verify against ecmult_gen */
- {
- secp256k1_scalar scalar_i;
- secp256k1_gej generatedj;
- secp256k1_ge generated;
-
- secp256k1_scalar_set_int(&scalar_i, i);
- secp256k1_ecmult_gen(&ctx->ecmult_gen_ctx, &generatedj, &scalar_i);
- secp256k1_ge_set_gej(&generated, &generatedj);
-
- CHECK(group[i].infinity == 0);
- CHECK(generated.infinity == 0);
- CHECK(secp256k1_fe_equal_var(&generated.x, &group[i].x));
- CHECK(secp256k1_fe_equal_var(&generated.y, &group[i].y));
- }
- }
-
- /* Run the tests */
-#ifdef USE_ENDOMORPHISM
- test_exhaustive_endomorphism(group, EXHAUSTIVE_TEST_ORDER);
-#endif
- test_exhaustive_addition(group, groupj, EXHAUSTIVE_TEST_ORDER);
- test_exhaustive_ecmult(ctx, group, groupj, EXHAUSTIVE_TEST_ORDER);
- test_exhaustive_sign(ctx, group, EXHAUSTIVE_TEST_ORDER);
- test_exhaustive_verify(ctx, group, EXHAUSTIVE_TEST_ORDER);
-
-#ifdef ENABLE_MODULE_RECOVERY
- test_exhaustive_recovery_sign(ctx, group, EXHAUSTIVE_TEST_ORDER);
- test_exhaustive_recovery_verify(ctx, group, EXHAUSTIVE_TEST_ORDER);
-#endif
-
- secp256k1_context_destroy(ctx);
- return 0;
-}
-
diff --git a/crypto/secp256k1/libsecp256k1/src/util.h b/crypto/secp256k1/libsecp256k1/src/util.h
deleted file mode 100644
index 4092a86c91..0000000000
--- a/crypto/secp256k1/libsecp256k1/src/util.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/**********************************************************************
- * Copyright (c) 2013, 2014 Pieter Wuille *
- * Distributed under the MIT software license, see the accompanying *
- * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
- **********************************************************************/
-
-#ifndef _SECP256K1_UTIL_H_
-#define _SECP256K1_UTIL_H_
-
-#if defined HAVE_CONFIG_H
-#include "libsecp256k1-config.h"
-#endif
-
-#include
-#include
-#include
-
-typedef struct {
- void (*fn)(const char *text, void* data);
- const void* data;
-} secp256k1_callback;
-
-static SECP256K1_INLINE void secp256k1_callback_call(const secp256k1_callback * const cb, const char * const text) {
- cb->fn(text, (void*)cb->data);
-}
-
-#ifdef DETERMINISTIC
-#define TEST_FAILURE(msg) do { \
- fprintf(stderr, "%s\n", msg); \
- abort(); \
-} while(0);
-#else
-#define TEST_FAILURE(msg) do { \
- fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, msg); \
- abort(); \
-} while(0)
-#endif
-
-#ifdef HAVE_BUILTIN_EXPECT
-#define EXPECT(x,c) __builtin_expect((x),(c))
-#else
-#define EXPECT(x,c) (x)
-#endif
-
-#ifdef DETERMINISTIC
-#define CHECK(cond) do { \
- if (EXPECT(!(cond), 0)) { \
- TEST_FAILURE("test condition failed"); \
- } \
-} while(0)
-#else
-#define CHECK(cond) do { \
- if (EXPECT(!(cond), 0)) { \
- TEST_FAILURE("test condition failed: " #cond); \
- } \
-} while(0)
-#endif
-
-/* Like assert(), but when VERIFY is defined, and side-effect safe. */
-#if defined(COVERAGE)
-#define VERIFY_CHECK(check)
-#define VERIFY_SETUP(stmt)
-#elif defined(VERIFY)
-#define VERIFY_CHECK CHECK
-#define VERIFY_SETUP(stmt) do { stmt; } while(0)
-#else
-#define VERIFY_CHECK(cond) do { (void)(cond); } while(0)
-#define VERIFY_SETUP(stmt)
-#endif
-
-static SECP256K1_INLINE void *checked_malloc(const secp256k1_callback* cb, size_t size) {
- void *ret = malloc(size);
- if (ret == NULL) {
- secp256k1_callback_call(cb, "Out of memory");
- }
- return ret;
-}
-
-/* Macro for restrict, when available and not in a VERIFY build. */
-#if defined(SECP256K1_BUILD) && defined(VERIFY)
-# define SECP256K1_RESTRICT
-#else
-# if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) )
-# if SECP256K1_GNUC_PREREQ(3,0)
-# define SECP256K1_RESTRICT __restrict__
-# elif (defined(_MSC_VER) && _MSC_VER >= 1400)
-# define SECP256K1_RESTRICT __restrict
-# else
-# define SECP256K1_RESTRICT
-# endif
-# else
-# define SECP256K1_RESTRICT restrict
-# endif
-#endif
-
-#if defined(_WIN32)
-# define I64FORMAT "I64d"
-# define I64uFORMAT "I64u"
-#else
-# define I64FORMAT "lld"
-# define I64uFORMAT "llu"
-#endif
-
-#if defined(HAVE___INT128)
-# if defined(__GNUC__)
-# define SECP256K1_GNUC_EXT __extension__
-# else
-# define SECP256K1_GNUC_EXT
-# endif
-SECP256K1_GNUC_EXT typedef unsigned __int128 uint128_t;
-#endif
-
-#endif
diff --git a/crypto/secp256k1/panic_cb.go b/crypto/secp256k1/panic_cb.go
deleted file mode 100644
index a30b04f51b..0000000000
--- a/crypto/secp256k1/panic_cb.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2015 Jeffrey Wilcke, Felix Lange, Gustav Simonsson. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be found in
-// the LICENSE file.
-
-//go:build !gofuzz && cgo
-// +build !gofuzz,cgo
-
-package secp256k1
-
-import "C"
-import "unsafe"
-
-// Callbacks for converting libsecp256k1 internal faults into
-// recoverable Go panics.
-
-//export secp256k1GoPanicIllegal
-func secp256k1GoPanicIllegal(msg *C.char, data unsafe.Pointer) {
- panic("illegal argument: " + C.GoString(msg))
-}
-
-//export secp256k1GoPanicError
-func secp256k1GoPanicError(msg *C.char, data unsafe.Pointer) {
- panic("internal error: " + C.GoString(msg))
-}
diff --git a/crypto/secp256k1/scalar_mult_cgo.go b/crypto/secp256k1/scalar_mult_cgo.go
deleted file mode 100644
index 8afa9d023b..0000000000
--- a/crypto/secp256k1/scalar_mult_cgo.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2015 Jeffrey Wilcke, Felix Lange, Gustav Simonsson. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be found in
-// the LICENSE file.
-
-//go:build !gofuzz && cgo
-// +build !gofuzz,cgo
-
-package secp256k1
-
-import (
- "math/big"
- "unsafe"
-)
-
-/*
-
-#include "libsecp256k1/include/secp256k1.h"
-
-extern int secp256k1_ext_scalar_mul(const secp256k1_context* ctx, const unsigned char *point, const unsigned char *scalar);
-
-*/
-import "C"
-
-func (BitCurve *BitCurve) ScalarMult(Bx, By *big.Int, scalar []byte) (*big.Int, *big.Int) {
- // Ensure scalar is exactly 32 bytes. We pad always, even if
- // scalar is 32 bytes long, to avoid a timing side channel.
- if len(scalar) > 32 {
- panic("can't handle scalars > 256 bits")
- }
- // NOTE: potential timing issue
- padded := make([]byte, 32)
- copy(padded[32-len(scalar):], scalar)
- scalar = padded
-
- // Do the multiplication in C, updating point.
- point := make([]byte, 64)
- readBits(Bx, point[:32])
- readBits(By, point[32:])
-
- pointPtr := (*C.uchar)(unsafe.Pointer(&point[0]))
- scalarPtr := (*C.uchar)(unsafe.Pointer(&scalar[0]))
- res := C.secp256k1_ext_scalar_mul(context, pointPtr, scalarPtr)
-
- // Unpack the result and clear temporaries.
- x := new(big.Int).SetBytes(point[:32])
- y := new(big.Int).SetBytes(point[32:])
- for i := range point {
- point[i] = 0
- }
- for i := range padded {
- scalar[i] = 0
- }
- if res != 1 {
- return nil, nil
- }
- return x, y
-}
diff --git a/crypto/secp256k1/scalar_mult_nocgo.go b/crypto/secp256k1/scalar_mult_nocgo.go
deleted file mode 100644
index 22f53ac6ae..0000000000
--- a/crypto/secp256k1/scalar_mult_nocgo.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2015 Jeffrey Wilcke, Felix Lange, Gustav Simonsson. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be found in
-// the LICENSE file.
-
-//go:build gofuzz || !cgo
-// +build gofuzz !cgo
-
-package secp256k1
-
-import "math/big"
-
-func (BitCurve *BitCurve) ScalarMult(Bx, By *big.Int, scalar []byte) (*big.Int, *big.Int) {
- panic("ScalarMult is not available when secp256k1 is built without cgo")
-}
diff --git a/crypto/secp256k1/secp256.go b/crypto/secp256k1/secp256.go
deleted file mode 100644
index 61abc1eaf0..0000000000
--- a/crypto/secp256k1/secp256.go
+++ /dev/null
@@ -1,182 +0,0 @@
-// Copyright 2015 Jeffrey Wilcke, Felix Lange, Gustav Simonsson. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be found in
-// the LICENSE file.
-
-//go:build !gofuzz && cgo
-// +build !gofuzz,cgo
-
-// Package secp256k1 wraps the bitcoin secp256k1 C library.
-package secp256k1
-
-/*
-#cgo CFLAGS: -I./libsecp256k1
-#cgo CFLAGS: -I./libsecp256k1/src/
-
-#ifdef __SIZEOF_INT128__
-# define HAVE___INT128
-# define USE_FIELD_5X52
-# define USE_SCALAR_4X64
-#else
-# define USE_FIELD_10X26
-# define USE_SCALAR_8X32
-#endif
-
-#ifndef NDEBUG
-# define NDEBUG
-#endif
-
-#define USE_ENDOMORPHISM
-#define USE_NUM_NONE
-#define USE_FIELD_INV_BUILTIN
-#define USE_SCALAR_INV_BUILTIN
-#include "./libsecp256k1/src/secp256k1.c"
-#include "./libsecp256k1/src/modules/recovery/main_impl.h"
-#include "ext.h"
-
-typedef void (*callbackFunc) (const char* msg, void* data);
-extern void secp256k1GoPanicIllegal(const char* msg, void* data);
-extern void secp256k1GoPanicError(const char* msg, void* data);
-*/
-import "C"
-
-import (
- "errors"
- "math/big"
- "unsafe"
-)
-
-var context *C.secp256k1_context
-
-func init() {
- // around 20 ms on a modern CPU.
- context = C.secp256k1_context_create_sign_verify()
- C.secp256k1_context_set_illegal_callback(context, C.callbackFunc(C.secp256k1GoPanicIllegal), nil)
- C.secp256k1_context_set_error_callback(context, C.callbackFunc(C.secp256k1GoPanicError), nil)
-}
-
-var (
- ErrInvalidMsgLen = errors.New("invalid message length, need 32 bytes")
- ErrInvalidSignatureLen = errors.New("invalid signature length")
- ErrInvalidRecoveryID = errors.New("invalid signature recovery id")
- ErrInvalidKey = errors.New("invalid private key")
- ErrInvalidPubkey = errors.New("invalid public key")
- ErrSignFailed = errors.New("signing failed")
- ErrRecoverFailed = errors.New("recovery failed")
-)
-
-// Sign creates a recoverable ECDSA signature.
-// The produced signature is in the 65-byte [R || S || V] format where V is 0 or 1.
-//
-// The caller is responsible for ensuring that msg cannot be chosen
-// directly by an attacker. It is usually preferable to use a cryptographic
-// hash function on any input before handing it to this function.
-func Sign(msg []byte, seckey []byte) ([]byte, error) {
- if len(msg) != 32 {
- return nil, ErrInvalidMsgLen
- }
- if len(seckey) != 32 {
- return nil, ErrInvalidKey
- }
- seckeydata := (*C.uchar)(unsafe.Pointer(&seckey[0]))
- if C.secp256k1_ec_seckey_verify(context, seckeydata) != 1 {
- return nil, ErrInvalidKey
- }
-
- var (
- msgdata = (*C.uchar)(unsafe.Pointer(&msg[0]))
- noncefunc = C.secp256k1_nonce_function_rfc6979
- sigstruct C.secp256k1_ecdsa_recoverable_signature
- )
- if C.secp256k1_ecdsa_sign_recoverable(context, &sigstruct, msgdata, seckeydata, noncefunc, nil) == 0 {
- return nil, ErrSignFailed
- }
-
- var (
- sig = make([]byte, 65)
- sigdata = (*C.uchar)(unsafe.Pointer(&sig[0]))
- recid C.int
- )
- C.secp256k1_ecdsa_recoverable_signature_serialize_compact(context, sigdata, &recid, &sigstruct)
- sig[64] = byte(recid) // add back recid to get 65 bytes sig
- return sig, nil
-}
-
-// RecoverPubkey returns the public key of the signer.
-// msg must be the 32-byte hash of the message to be signed.
-// sig must be a 65-byte compact ECDSA signature containing the
-// recovery id as the last element.
-func RecoverPubkey(msg []byte, sig []byte) ([]byte, error) {
- if len(msg) != 32 {
- return nil, ErrInvalidMsgLen
- }
- if err := checkSignature(sig); err != nil {
- return nil, err
- }
-
- var (
- pubkey = make([]byte, 65)
- sigdata = (*C.uchar)(unsafe.Pointer(&sig[0]))
- msgdata = (*C.uchar)(unsafe.Pointer(&msg[0]))
- )
- if C.secp256k1_ext_ecdsa_recover(context, (*C.uchar)(unsafe.Pointer(&pubkey[0])), sigdata, msgdata) == 0 {
- return nil, ErrRecoverFailed
- }
- return pubkey, nil
-}
-
-// VerifySignature checks that the given pubkey created signature over message.
-// The signature should be in [R || S] format.
-func VerifySignature(pubkey, msg, signature []byte) bool {
- if len(msg) != 32 || len(signature) != 64 || len(pubkey) == 0 {
- return false
- }
- sigdata := (*C.uchar)(unsafe.Pointer(&signature[0]))
- msgdata := (*C.uchar)(unsafe.Pointer(&msg[0]))
- keydata := (*C.uchar)(unsafe.Pointer(&pubkey[0]))
- return C.secp256k1_ext_ecdsa_verify(context, sigdata, msgdata, keydata, C.size_t(len(pubkey))) != 0
-}
-
-// DecompressPubkey parses a public key in the 33-byte compressed format.
-// It returns non-nil coordinates if the public key is valid.
-func DecompressPubkey(pubkey []byte) (x, y *big.Int) {
- if len(pubkey) != 33 {
- return nil, nil
- }
- var (
- pubkeydata = (*C.uchar)(unsafe.Pointer(&pubkey[0]))
- pubkeylen = C.size_t(len(pubkey))
- out = make([]byte, 65)
- outdata = (*C.uchar)(unsafe.Pointer(&out[0]))
- outlen = C.size_t(len(out))
- )
- if C.secp256k1_ext_reencode_pubkey(context, outdata, outlen, pubkeydata, pubkeylen) == 0 {
- return nil, nil
- }
- return new(big.Int).SetBytes(out[1:33]), new(big.Int).SetBytes(out[33:])
-}
-
-// CompressPubkey encodes a public key to 33-byte compressed format.
-func CompressPubkey(x, y *big.Int) []byte {
- var (
- pubkey = S256().Marshal(x, y)
- pubkeydata = (*C.uchar)(unsafe.Pointer(&pubkey[0]))
- pubkeylen = C.size_t(len(pubkey))
- out = make([]byte, 33)
- outdata = (*C.uchar)(unsafe.Pointer(&out[0]))
- outlen = C.size_t(len(out))
- )
- if C.secp256k1_ext_reencode_pubkey(context, outdata, outlen, pubkeydata, pubkeylen) == 0 {
- panic("libsecp256k1 error")
- }
- return out
-}
-
-func checkSignature(sig []byte) error {
- if len(sig) != 65 {
- return ErrInvalidSignatureLen
- }
- if sig[64] >= 4 {
- return ErrInvalidRecoveryID
- }
- return nil
-}
diff --git a/crypto/secp256k1/secp256_test.go b/crypto/secp256k1/secp256_test.go
deleted file mode 100644
index 74408d06d2..0000000000
--- a/crypto/secp256k1/secp256_test.go
+++ /dev/null
@@ -1,241 +0,0 @@
-// Copyright 2015 Jeffrey Wilcke, Felix Lange, Gustav Simonsson. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be found in
-// the LICENSE file.
-
-//go:build !gofuzz && cgo
-// +build !gofuzz,cgo
-
-package secp256k1
-
-import (
- "bytes"
- "crypto/ecdsa"
- "crypto/elliptic"
- "crypto/rand"
- "encoding/hex"
- "io"
- "testing"
-)
-
-const TestCount = 1000
-
-func generateKeyPair() (pubkey, privkey []byte) {
- key, err := ecdsa.GenerateKey(S256(), rand.Reader)
- if err != nil {
- panic(err)
- }
- pubkey = elliptic.Marshal(S256(), key.X, key.Y)
-
- privkey = make([]byte, 32)
- blob := key.D.Bytes()
- copy(privkey[32-len(blob):], blob)
-
- return pubkey, privkey
-}
-
-func csprngEntropy(n int) []byte {
- buf := make([]byte, n)
- if _, err := io.ReadFull(rand.Reader, buf); err != nil {
- panic("reading from crypto/rand failed: " + err.Error())
- }
- return buf
-}
-
-func randSig() []byte {
- sig := csprngEntropy(65)
- sig[32] &= 0x70
- sig[64] %= 4
- return sig
-}
-
-// tests for malleability
-// highest bit of signature ECDSA s value must be 0, in the 33th byte
-func compactSigCheck(t *testing.T, sig []byte) {
- var b = int(sig[32])
- if b < 0 {
- t.Errorf("highest bit is negative: %d", b)
- }
- if ((b >> 7) == 1) != ((b & 0x80) == 0x80) {
- t.Errorf("highest bit: %d bit >> 7: %d", b, b>>7)
- }
- if (b & 0x80) == 0x80 {
- t.Errorf("highest bit: %d bit & 0x80: %d", b, b&0x80)
- }
-}
-
-func TestSignatureValidity(t *testing.T) {
- pubkey, seckey := generateKeyPair()
- msg := csprngEntropy(32)
- sig, err := Sign(msg, seckey)
- if err != nil {
- t.Errorf("signature error: %s", err)
- }
- compactSigCheck(t, sig)
- if len(pubkey) != 65 {
- t.Errorf("pubkey length mismatch: want: 65 have: %d", len(pubkey))
- }
- if len(seckey) != 32 {
- t.Errorf("seckey length mismatch: want: 32 have: %d", len(seckey))
- }
- if len(sig) != 65 {
- t.Errorf("sig length mismatch: want: 65 have: %d", len(sig))
- }
- recid := int(sig[64])
- if recid > 4 || recid < 0 {
- t.Errorf("sig recid mismatch: want: within 0 to 4 have: %d", int(sig[64]))
- }
-}
-
-func TestInvalidRecoveryID(t *testing.T) {
- _, seckey := generateKeyPair()
- msg := csprngEntropy(32)
- sig, _ := Sign(msg, seckey)
- sig[64] = 99
- _, err := RecoverPubkey(msg, sig)
- if err != ErrInvalidRecoveryID {
- t.Fatalf("got %q, want %q", err, ErrInvalidRecoveryID)
- }
-}
-
-func TestSignAndRecover(t *testing.T) {
- pubkey1, seckey := generateKeyPair()
- msg := csprngEntropy(32)
- sig, err := Sign(msg, seckey)
- if err != nil {
- t.Errorf("signature error: %s", err)
- }
- pubkey2, err := RecoverPubkey(msg, sig)
- if err != nil {
- t.Errorf("recover error: %s", err)
- }
- if !bytes.Equal(pubkey1, pubkey2) {
- t.Errorf("pubkey mismatch: want: %x have: %x", pubkey1, pubkey2)
- }
-}
-
-func TestSignDeterministic(t *testing.T) {
- _, seckey := generateKeyPair()
- msg := make([]byte, 32)
- copy(msg, "hi there")
-
- sig1, err := Sign(msg, seckey)
- if err != nil {
- t.Fatal(err)
- }
- sig2, err := Sign(msg, seckey)
- if err != nil {
- t.Fatal(err)
- }
- if !bytes.Equal(sig1, sig2) {
- t.Fatal("signatures not equal")
- }
-}
-
-func TestRandomMessagesWithSameKey(t *testing.T) {
- pubkey, seckey := generateKeyPair()
- keys := func() ([]byte, []byte) {
- return pubkey, seckey
- }
- signAndRecoverWithRandomMessages(t, keys)
-}
-
-func TestRandomMessagesWithRandomKeys(t *testing.T) {
- keys := func() ([]byte, []byte) {
- pubkey, seckey := generateKeyPair()
- return pubkey, seckey
- }
- signAndRecoverWithRandomMessages(t, keys)
-}
-
-func signAndRecoverWithRandomMessages(t *testing.T, keys func() ([]byte, []byte)) {
- for i := 0; i < TestCount; i++ {
- pubkey1, seckey := keys()
- msg := csprngEntropy(32)
- sig, err := Sign(msg, seckey)
- if err != nil {
- t.Fatalf("signature error: %s", err)
- }
- if sig == nil {
- t.Fatal("signature is nil")
- }
- compactSigCheck(t, sig)
-
- // TODO: why do we flip around the recovery id?
- sig[len(sig)-1] %= 4
-
- pubkey2, err := RecoverPubkey(msg, sig)
- if err != nil {
- t.Fatalf("recover error: %s", err)
- }
- if pubkey2 == nil {
- t.Error("pubkey is nil")
- }
- if !bytes.Equal(pubkey1, pubkey2) {
- t.Fatalf("pubkey mismatch: want: %x have: %x", pubkey1, pubkey2)
- }
- }
-}
-
-func TestRecoveryOfRandomSignature(t *testing.T) {
- pubkey1, _ := generateKeyPair()
- msg := csprngEntropy(32)
-
- for i := 0; i < TestCount; i++ {
- // recovery can sometimes work, but if so should always give wrong pubkey
- pubkey2, _ := RecoverPubkey(msg, randSig())
- if bytes.Equal(pubkey1, pubkey2) {
- t.Fatalf("iteration: %d: pubkey mismatch: do NOT want %x: ", i, pubkey2)
- }
- }
-}
-
-func TestRandomMessagesAgainstValidSig(t *testing.T) {
- pubkey1, seckey := generateKeyPair()
- msg := csprngEntropy(32)
- sig, _ := Sign(msg, seckey)
-
- for i := 0; i < TestCount; i++ {
- msg = csprngEntropy(32)
- pubkey2, _ := RecoverPubkey(msg, sig)
- // recovery can sometimes work, but if so should always give wrong pubkey
- if bytes.Equal(pubkey1, pubkey2) {
- t.Fatalf("iteration: %d: pubkey mismatch: do NOT want %x: ", i, pubkey2)
- }
- }
-}
-
-// Useful when the underlying libsecp256k1 API changes to quickly
-// check only recover function without use of signature function
-func TestRecoverSanity(t *testing.T) {
- msg, _ := hex.DecodeString("ce0677bb30baa8cf067c88db9811f4333d131bf8bcf12fe7065d211dce971008")
- sig, _ := hex.DecodeString("90f27b8b488db00b00606796d2987f6a5f59ae62ea05effe84fef5b8b0e549984a691139ad57a3f0b906637673aa2f63d1f55cb1a69199d4009eea23ceaddc9301")
- pubkey1, _ := hex.DecodeString("04e32df42865e97135acfb65f3bae71bdc86f4d49150ad6a440b6f15878109880a0a2b2667f7e725ceea70c673093bf67663e0312623c8e091b13cf2c0f11ef652")
- pubkey2, err := RecoverPubkey(msg, sig)
- if err != nil {
- t.Fatalf("recover error: %s", err)
- }
- if !bytes.Equal(pubkey1, pubkey2) {
- t.Errorf("pubkey mismatch: want: %x have: %x", pubkey1, pubkey2)
- }
-}
-
-func BenchmarkSign(b *testing.B) {
- _, seckey := generateKeyPair()
- msg := csprngEntropy(32)
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- Sign(msg, seckey)
- }
-}
-
-func BenchmarkRecover(b *testing.B) {
- msg := csprngEntropy(32)
- _, seckey := generateKeyPair()
- sig, _ := Sign(msg, seckey)
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- RecoverPubkey(msg, sig)
- }
-}
diff --git a/crypto/signature_cgo.go b/crypto/signature_cgo.go
deleted file mode 100644
index 2339e52015..0000000000
--- a/crypto/signature_cgo.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-//go:build !nacl && !js && cgo && !gofuzz
-// +build !nacl,!js,cgo,!gofuzz
-
-package crypto
-
-import (
- "crypto/ecdsa"
- "crypto/elliptic"
- "errors"
- "fmt"
-
- "github.com/ethereum/go-ethereum/common/math"
- "github.com/ethereum/go-ethereum/crypto/secp256k1"
-)
-
-// Ecrecover returns the uncompressed public key that created the given signature.
-func Ecrecover(hash, sig []byte) ([]byte, error) {
- return secp256k1.RecoverPubkey(hash, sig)
-}
-
-// SigToPub returns the public key that created the given signature.
-func SigToPub(hash, sig []byte) (*ecdsa.PublicKey, error) {
- s, err := Ecrecover(hash, sig)
- if err != nil {
- return nil, err
- }
-
- x, y := elliptic.Unmarshal(S256(), s)
- return &ecdsa.PublicKey{Curve: S256(), X: x, Y: y}, nil
-}
-
-// Sign calculates an ECDSA signature.
-//
-// This function is susceptible to chosen plaintext attacks that can leak
-// information about the private key that is used for signing. Callers must
-// be aware that the given digest cannot be chosen by an adversary. Common
-// solution is to hash any input before calculating the signature.
-//
-// The produced signature is in the [R || S || V] format where V is 0 or 1.
-func Sign(digestHash []byte, prv *ecdsa.PrivateKey) (sig []byte, err error) {
- if len(digestHash) != DigestLength {
- return nil, fmt.Errorf("hash is required to be exactly %d bytes (%d)", DigestLength, len(digestHash))
- }
- seckey := math.PaddedBigBytes(prv.D, prv.Params().BitSize/8)
- defer zeroBytes(seckey)
- return secp256k1.Sign(digestHash, seckey)
-}
-
-// VerifySignature checks that the given public key created signature over digest.
-// The public key should be in compressed (33 bytes) or uncompressed (65 bytes) format.
-// The signature should have the 64 byte [R || S] format.
-func VerifySignature(pubkey, digestHash, signature []byte) bool {
- return secp256k1.VerifySignature(pubkey, digestHash, signature)
-}
-
-// DecompressPubkey parses a public key in the 33-byte compressed format.
-func DecompressPubkey(pubkey []byte) (*ecdsa.PublicKey, error) {
- x, y := secp256k1.DecompressPubkey(pubkey)
- if x == nil {
- return nil, errors.New("invalid public key")
- }
- return &ecdsa.PublicKey{X: x, Y: y, Curve: S256()}, nil
-}
-
-// CompressPubkey encodes a public key to the 33-byte compressed format.
-func CompressPubkey(pubkey *ecdsa.PublicKey) []byte {
- return secp256k1.CompressPubkey(pubkey.X, pubkey.Y)
-}
-
-// S256 returns an instance of the secp256k1 curve.
-func S256() elliptic.Curve {
- return secp256k1.S256()
-}
diff --git a/crypto/signature_nocgo.go b/crypto/signature_nocgo.go
deleted file mode 100644
index 6d628d758d..0000000000
--- a/crypto/signature_nocgo.go
+++ /dev/null
@@ -1,152 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-//go:build nacl || js || !cgo || gofuzz
-// +build nacl js !cgo gofuzz
-
-package crypto
-
-import (
- "crypto/ecdsa"
- "crypto/elliptic"
- "errors"
- "fmt"
-
- "github.com/btcsuite/btcd/btcec/v2"
- btc_ecdsa "github.com/btcsuite/btcd/btcec/v2/ecdsa"
-)
-
-// Ecrecover returns the uncompressed public key that created the given signature.
-func Ecrecover(hash, sig []byte) ([]byte, error) {
- pub, err := sigToPub(hash, sig)
- if err != nil {
- return nil, err
- }
- bytes := pub.SerializeUncompressed()
- return bytes, err
-}
-
-func sigToPub(hash, sig []byte) (*btcec.PublicKey, error) {
- if len(sig) != SignatureLength {
- return nil, errors.New("invalid signature")
- }
- // Convert to btcec input format with 'recovery id' v at the beginning.
- btcsig := make([]byte, SignatureLength)
- btcsig[0] = sig[RecoveryIDOffset] + 27
- copy(btcsig[1:], sig)
-
- pub, _, err := btc_ecdsa.RecoverCompact(btcsig, hash)
- return pub, err
-}
-
-// SigToPub returns the public key that created the given signature.
-func SigToPub(hash, sig []byte) (*ecdsa.PublicKey, error) {
- pub, err := sigToPub(hash, sig)
- if err != nil {
- return nil, err
- }
- return pub.ToECDSA(), nil
-}
-
-// Sign calculates an ECDSA signature.
-//
-// This function is susceptible to chosen plaintext attacks that can leak
-// information about the private key that is used for signing. Callers must
-// be aware that the given hash cannot be chosen by an adversary. Common
-// solution is to hash any input before calculating the signature.
-//
-// The produced signature is in the [R || S || V] format where V is 0 or 1.
-func Sign(hash []byte, prv *ecdsa.PrivateKey) ([]byte, error) {
- if len(hash) != 32 {
- return nil, fmt.Errorf("hash is required to be exactly 32 bytes (%d)", len(hash))
- }
- if prv.Curve != btcec.S256() {
- return nil, errors.New("private key curve is not secp256k1")
- }
- // ecdsa.PrivateKey -> btcec.PrivateKey
- var priv btcec.PrivateKey
- if overflow := priv.Key.SetByteSlice(prv.D.Bytes()); overflow || priv.Key.IsZero() {
- return nil, errors.New("invalid private key")
- }
- defer priv.Zero()
- sig, err := btc_ecdsa.SignCompact(&priv, hash, false) // ref uncompressed pubkey
- if err != nil {
- return nil, err
- }
- // Convert to Ethereum signature format with 'recovery id' v at the end.
- v := sig[0] - 27
- copy(sig, sig[1:])
- sig[RecoveryIDOffset] = v
- return sig, nil
-}
-
-// VerifySignature checks that the given public key created signature over hash.
-// The public key should be in compressed (33 bytes) or uncompressed (65 bytes) format.
-// The signature should have the 64 byte [R || S] format.
-func VerifySignature(pubkey, hash, signature []byte) bool {
- if len(signature) != 64 {
- return false
- }
- var r, s btcec.ModNScalar
- if r.SetByteSlice(signature[:32]) {
- return false // overflow
- }
- if s.SetByteSlice(signature[32:]) {
- return false
- }
- sig := btc_ecdsa.NewSignature(&r, &s)
- key, err := btcec.ParsePubKey(pubkey)
- if err != nil {
- return false
- }
- // Reject malleable signatures. libsecp256k1 does this check but btcec doesn't.
- if s.IsOverHalfOrder() {
- return false
- }
- return sig.Verify(hash, key)
-}
-
-// DecompressPubkey parses a public key in the 33-byte compressed format.
-func DecompressPubkey(pubkey []byte) (*ecdsa.PublicKey, error) {
- if len(pubkey) != 33 {
- return nil, errors.New("invalid compressed public key length")
- }
- key, err := btcec.ParsePubKey(pubkey)
- if err != nil {
- return nil, err
- }
- return key.ToECDSA(), nil
-}
-
-// CompressPubkey encodes a public key to the 33-byte compressed format. The
-// provided PublicKey must be valid. Namely, the coordinates must not be larger
-// than 32 bytes each, they must be less than the field prime, and it must be a
-// point on the secp256k1 curve. This is the case for a PublicKey constructed by
-// elliptic.Unmarshal (see UnmarshalPubkey), or by ToECDSA and ecdsa.GenerateKey
-// when constructing a PrivateKey.
-func CompressPubkey(pubkey *ecdsa.PublicKey) []byte {
- // NOTE: the coordinates may be validated with
- // btcec.ParsePubKey(FromECDSAPub(pubkey))
- var x, y btcec.FieldVal
- x.SetByteSlice(pubkey.X.Bytes())
- y.SetByteSlice(pubkey.Y.Bytes())
- return btcec.NewPublicKey(&x, &y).SerializeCompressed()
-}
-
-// S256 returns an instance of the secp256k1 curve.
-func S256() elliptic.Curve {
- return btcec.S256()
-}
diff --git a/crypto/signature_test.go b/crypto/signature_test.go
deleted file mode 100644
index aecff76bfb..0000000000
--- a/crypto/signature_test.go
+++ /dev/null
@@ -1,160 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-package crypto
-
-import (
- "bytes"
- "crypto/ecdsa"
- "reflect"
- "testing"
-
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
-)
-
-var (
- testmsg = hexutil.MustDecode("0xce0677bb30baa8cf067c88db9811f4333d131bf8bcf12fe7065d211dce971008")
- testsig = hexutil.MustDecode("0x90f27b8b488db00b00606796d2987f6a5f59ae62ea05effe84fef5b8b0e549984a691139ad57a3f0b906637673aa2f63d1f55cb1a69199d4009eea23ceaddc9301")
- testpubkey = hexutil.MustDecode("0x04e32df42865e97135acfb65f3bae71bdc86f4d49150ad6a440b6f15878109880a0a2b2667f7e725ceea70c673093bf67663e0312623c8e091b13cf2c0f11ef652")
- testpubkeyc = hexutil.MustDecode("0x02e32df42865e97135acfb65f3bae71bdc86f4d49150ad6a440b6f15878109880a")
-)
-
-func TestEcrecover(t *testing.T) {
- pubkey, err := Ecrecover(testmsg, testsig)
- if err != nil {
- t.Fatalf("recover error: %s", err)
- }
- if !bytes.Equal(pubkey, testpubkey) {
- t.Errorf("pubkey mismatch: want: %x have: %x", testpubkey, pubkey)
- }
-}
-
-func TestVerifySignature(t *testing.T) {
- sig := testsig[:len(testsig)-1] // remove recovery id
- if !VerifySignature(testpubkey, testmsg, sig) {
- t.Errorf("can't verify signature with uncompressed key")
- }
- if !VerifySignature(testpubkeyc, testmsg, sig) {
- t.Errorf("can't verify signature with compressed key")
- }
-
- if VerifySignature(nil, testmsg, sig) {
- t.Errorf("signature valid with no key")
- }
- if VerifySignature(testpubkey, nil, sig) {
- t.Errorf("signature valid with no message")
- }
- if VerifySignature(testpubkey, testmsg, nil) {
- t.Errorf("nil signature valid")
- }
- if VerifySignature(testpubkey, testmsg, append(common.CopyBytes(sig), 1, 2, 3)) {
- t.Errorf("signature valid with extra bytes at the end")
- }
- if VerifySignature(testpubkey, testmsg, sig[:len(sig)-2]) {
- t.Errorf("signature valid even though it's incomplete")
- }
- wrongkey := common.CopyBytes(testpubkey)
- wrongkey[10]++
- if VerifySignature(wrongkey, testmsg, sig) {
- t.Errorf("signature valid with with wrong public key")
- }
-}
-
-// This test checks that VerifySignature rejects malleable signatures with s > N/2.
-func TestVerifySignatureMalleable(t *testing.T) {
- sig := hexutil.MustDecode("0x638a54215d80a6713c8d523a6adc4e6e73652d859103a36b700851cb0e61b66b8ebfc1a610c57d732ec6e0a8f06a9a7a28df5051ece514702ff9cdff0b11f454")
- key := hexutil.MustDecode("0x03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd3138")
- msg := hexutil.MustDecode("0xd301ce462d3e639518f482c7f03821fec1e602018630ce621e1e7851c12343a6")
- if VerifySignature(key, msg, sig) {
- t.Error("VerifySignature returned true for malleable signature")
- }
-}
-
-func TestDecompressPubkey(t *testing.T) {
- key, err := DecompressPubkey(testpubkeyc)
- if err != nil {
- t.Fatal(err)
- }
- if uncompressed := FromECDSAPub(key); !bytes.Equal(uncompressed, testpubkey) {
- t.Errorf("wrong public key result: got %x, want %x", uncompressed, testpubkey)
- }
- if _, err := DecompressPubkey(nil); err == nil {
- t.Errorf("no error for nil pubkey")
- }
- if _, err := DecompressPubkey(testpubkeyc[:5]); err == nil {
- t.Errorf("no error for incomplete pubkey")
- }
- if _, err := DecompressPubkey(append(common.CopyBytes(testpubkeyc), 1, 2, 3)); err == nil {
- t.Errorf("no error for pubkey with extra bytes at the end")
- }
-}
-
-func TestCompressPubkey(t *testing.T) {
- key := &ecdsa.PublicKey{
- Curve: S256(),
- X: math.MustParseBig256("0xe32df42865e97135acfb65f3bae71bdc86f4d49150ad6a440b6f15878109880a"),
- Y: math.MustParseBig256("0x0a2b2667f7e725ceea70c673093bf67663e0312623c8e091b13cf2c0f11ef652"),
- }
- compressed := CompressPubkey(key)
- if !bytes.Equal(compressed, testpubkeyc) {
- t.Errorf("wrong public key result: got %x, want %x", compressed, testpubkeyc)
- }
-}
-
-func TestPubkeyRandom(t *testing.T) {
- const runs = 200
-
- for i := 0; i < runs; i++ {
- key, err := GenerateKey()
- if err != nil {
- t.Fatalf("iteration %d: %v", i, err)
- }
- pubkey2, err := DecompressPubkey(CompressPubkey(&key.PublicKey))
- if err != nil {
- t.Fatalf("iteration %d: %v", i, err)
- }
- if !reflect.DeepEqual(key.PublicKey, *pubkey2) {
- t.Fatalf("iteration %d: keys not equal", i)
- }
- }
-}
-
-func BenchmarkEcrecoverSignature(b *testing.B) {
- for i := 0; i < b.N; i++ {
- if _, err := Ecrecover(testmsg, testsig); err != nil {
- b.Fatal("ecrecover error", err)
- }
- }
-}
-
-func BenchmarkVerifySignature(b *testing.B) {
- sig := testsig[:len(testsig)-1] // remove recovery id
- for i := 0; i < b.N; i++ {
- if !VerifySignature(testpubkey, testmsg, sig) {
- b.Fatal("verify error")
- }
- }
-}
-
-func BenchmarkDecompressPubkey(b *testing.B) {
- for i := 0; i < b.N; i++ {
- if _, err := DecompressPubkey(testpubkeyc); err != nil {
- b.Fatal(err)
- }
- }
-}
diff --git a/crypto/signify/signify.go b/crypto/signify/signify.go
deleted file mode 100644
index eb029e5099..0000000000
--- a/crypto/signify/signify.go
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright 2020 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-// signFile reads the contents of an input file and signs it (in armored format)
-// with the key provided, placing the signature into the output file.
-
-package signify
-
-import (
- "bytes"
- "crypto/ed25519"
- "encoding/base64"
- "errors"
- "fmt"
- "os"
- "strings"
- "time"
-)
-
-var (
- errInvalidKeyHeader = errors.New("incorrect key header")
- errInvalidKeyLength = errors.New("invalid, key length != 104")
-)
-
-func parsePrivateKey(key string) (k ed25519.PrivateKey, header []byte, keyNum []byte, err error) {
- keydata, err := base64.StdEncoding.DecodeString(key)
- if err != nil {
- return nil, nil, nil, err
- }
- if len(keydata) != 104 {
- return nil, nil, nil, errInvalidKeyLength
- }
- if string(keydata[:2]) != "Ed" {
- return nil, nil, nil, errInvalidKeyHeader
- }
- return keydata[40:], keydata[:2], keydata[32:40], nil
-}
-
-// SignFile creates a signature of the input file.
-//
-// This accepts base64 keys in the format created by the 'signify' tool.
-// The signature is written to the 'output' file.
-func SignFile(input string, output string, key string, untrustedComment string, trustedComment string) error {
- // Pre-check comments and ensure they're set to something.
- if strings.IndexByte(untrustedComment, '\n') >= 0 {
- return errors.New("untrusted comment must not contain newline")
- }
- if strings.IndexByte(trustedComment, '\n') >= 0 {
- return errors.New("trusted comment must not contain newline")
- }
- if untrustedComment == "" {
- untrustedComment = "verify with " + input + ".pub"
- }
- if trustedComment == "" {
- trustedComment = fmt.Sprintf("timestamp:%d", time.Now().Unix())
- }
-
- filedata, err := os.ReadFile(input)
- if err != nil {
- return err
- }
- skey, header, keyNum, err := parsePrivateKey(key)
- if err != nil {
- return err
- }
-
- // Create the main data signature.
- rawSig := ed25519.Sign(skey, filedata)
- var dataSig []byte
- dataSig = append(dataSig, header...)
- dataSig = append(dataSig, keyNum...)
- dataSig = append(dataSig, rawSig...)
-
- // Create the comment signature.
- var commentSigInput []byte
- commentSigInput = append(commentSigInput, rawSig...)
- commentSigInput = append(commentSigInput, []byte(trustedComment)...)
- commentSig := ed25519.Sign(skey, commentSigInput)
-
- // Create the output file.
- var out = new(bytes.Buffer)
- fmt.Fprintln(out, "untrusted comment:", untrustedComment)
- fmt.Fprintln(out, base64.StdEncoding.EncodeToString(dataSig))
- fmt.Fprintln(out, "trusted comment:", trustedComment)
- fmt.Fprintln(out, base64.StdEncoding.EncodeToString(commentSig))
- return os.WriteFile(output, out.Bytes(), 0644)
-}
diff --git a/crypto/signify/signify_fuzz.go b/crypto/signify/signify_fuzz.go
deleted file mode 100644
index 457af044d1..0000000000
--- a/crypto/signify/signify_fuzz.go
+++ /dev/null
@@ -1,150 +0,0 @@
-// Copyright 2020 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-//go:build gofuzz
-// +build gofuzz
-
-package signify
-
-import (
- "bufio"
- "fmt"
- "log"
- "os"
- "os/exec"
-
- fuzz "github.com/google/gofuzz"
- "github.com/jedisct1/go-minisign"
-)
-
-func Fuzz(data []byte) int {
- if len(data) < 32 {
- return -1
- }
- tmpFile, err := os.CreateTemp("", "")
- if err != nil {
- panic(err)
- }
- defer os.Remove(tmpFile.Name())
- defer tmpFile.Close()
-
- testSecKey, testPubKey := createKeyPair()
- // Create message
- tmpFile.Write(data)
- if err = tmpFile.Close(); err != nil {
- panic(err)
- }
- // Fuzz comments
- var untrustedComment string
- var trustedComment string
- f := fuzz.NewFromGoFuzz(data)
- f.Fuzz(&untrustedComment)
- f.Fuzz(&trustedComment)
- fmt.Printf("untrusted: %v\n", untrustedComment)
- fmt.Printf("trusted: %v\n", trustedComment)
-
- err = SignifySignFile(tmpFile.Name(), tmpFile.Name()+".sig", testSecKey, untrustedComment, trustedComment)
- if err != nil {
- panic(err)
- }
- defer os.Remove(tmpFile.Name() + ".sig")
-
- signify := "signify"
- path := os.Getenv("SIGNIFY")
- if path != "" {
- signify = path
- }
-
- _, err := exec.LookPath(signify)
- if err != nil {
- panic(err)
- }
-
- // Write the public key into the file to pass it as
- // an argument to signify-openbsd
- pubKeyFile, err := os.CreateTemp("", "")
- if err != nil {
- panic(err)
- }
- defer os.Remove(pubKeyFile.Name())
- defer pubKeyFile.Close()
- pubKeyFile.WriteString("untrusted comment: signify public key\n")
- pubKeyFile.WriteString(testPubKey)
- pubKeyFile.WriteString("\n")
-
- cmd := exec.Command(signify, "-V", "-p", pubKeyFile.Name(), "-x", tmpFile.Name()+".sig", "-m", tmpFile.Name())
- if output, err := cmd.CombinedOutput(); err != nil {
- panic(fmt.Sprintf("could not verify the file: %v, output: \n%s", err, output))
- }
-
- // Verify the signature using a golang library
- sig, err := minisign.NewSignatureFromFile(tmpFile.Name() + ".sig")
- if err != nil {
- panic(err)
- }
-
- pKey, err := minisign.NewPublicKey(testPubKey)
- if err != nil {
- panic(err)
- }
-
- valid, err := pKey.VerifyFromFile(tmpFile.Name(), sig)
- if err != nil {
- panic(err)
- }
- if !valid {
- panic("invalid signature")
- }
- return 1
-}
-
-func getKey(fileS string) (string, error) {
- file, err := os.Open(fileS)
- if err != nil {
- log.Fatal(err)
- }
- defer file.Close()
-
- scanner := bufio.NewScanner(file)
- // Discard the first line
- scanner.Scan()
- scanner.Scan()
- return scanner.Text(), scanner.Err()
-}
-
-func createKeyPair() (string, string) {
- // Create key and put it in correct format
- tmpKey, err := os.CreateTemp("", "")
- if err != nil {
- panic(err)
- }
- defer os.Remove(tmpKey.Name())
- defer os.Remove(tmpKey.Name() + ".pub")
- defer os.Remove(tmpKey.Name() + ".sec")
- cmd := exec.Command("signify", "-G", "-n", "-p", tmpKey.Name()+".pub", "-s", tmpKey.Name()+".sec")
- if output, err := cmd.CombinedOutput(); err != nil {
- panic(fmt.Sprintf("could not verify the file: %v, output: \n%s", err, output))
- }
- secKey, err := getKey(tmpKey.Name() + ".sec")
- if err != nil {
- panic(err)
- }
- pubKey, err := getKey(tmpKey.Name() + ".pub")
- if err != nil {
- panic(err)
- }
- return secKey, pubKey
-}
diff --git a/crypto/signify/signify_test.go b/crypto/signify/signify_test.go
deleted file mode 100644
index 9bac2c825f..0000000000
--- a/crypto/signify/signify_test.go
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright 2020 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-// signFile reads the contents of an input file and signs it (in armored format)
-// with the key provided, placing the signature into the output file.
-
-package signify
-
-import (
- "crypto/rand"
- "os"
- "testing"
-
- "github.com/jedisct1/go-minisign"
-)
-
-var (
- testSecKey = "RWRCSwAAAABVN5lr2JViGBN8DhX3/Qb/0g0wBdsNAR/APRW2qy9Fjsfr12sK2cd3URUFis1jgzQzaoayK8x4syT4G3Gvlt9RwGIwUYIQW/0mTeI+ECHu1lv5U4Wa2YHEPIesVPyRm5M="
- testPubKey = "RWTAPRW2qy9FjsBiMFGCEFv9Jk3iPhAh7tZb+VOFmtmBxDyHrFT8kZuT"
-)
-
-func TestSignify(t *testing.T) {
- tmpFile, err := os.CreateTemp("", "")
- if err != nil {
- t.Fatal(err)
- }
- defer os.Remove(tmpFile.Name())
- defer tmpFile.Close()
-
- data := make([]byte, 1024)
- rand.Read(data)
- tmpFile.Write(data)
-
- if err = tmpFile.Close(); err != nil {
- t.Fatal(err)
- }
-
- err = SignFile(tmpFile.Name(), tmpFile.Name()+".sig", testSecKey, "clé", "croissants")
- if err != nil {
- t.Fatal(err)
- }
- defer os.Remove(tmpFile.Name() + ".sig")
-
- // Verify the signature using a golang library
- sig, err := minisign.NewSignatureFromFile(tmpFile.Name() + ".sig")
- if err != nil {
- t.Fatal(err)
- }
-
- pKey, err := minisign.NewPublicKey(testPubKey)
- if err != nil {
- t.Fatal(err)
- }
-
- valid, err := pKey.VerifyFromFile(tmpFile.Name(), sig)
- if err != nil {
- t.Fatal(err)
- }
- if !valid {
- t.Fatal("invalid signature")
- }
-}
-
-func TestSignifyTrustedCommentTooManyLines(t *testing.T) {
- tmpFile, err := os.CreateTemp("", "")
- if err != nil {
- t.Fatal(err)
- }
- defer os.Remove(tmpFile.Name())
- defer tmpFile.Close()
-
- data := make([]byte, 1024)
- rand.Read(data)
- tmpFile.Write(data)
-
- if err = tmpFile.Close(); err != nil {
- t.Fatal(err)
- }
-
- err = SignFile(tmpFile.Name(), tmpFile.Name()+".sig", testSecKey, "", "crois\nsants")
- if err == nil || err.Error() == "" {
- t.Fatalf("should have errored on a multi-line trusted comment, got %v", err)
- }
- defer os.Remove(tmpFile.Name() + ".sig")
-}
-
-func TestSignifyTrustedCommentTooManyLinesLF(t *testing.T) {
- tmpFile, err := os.CreateTemp("", "")
- if err != nil {
- t.Fatal(err)
- }
- defer os.Remove(tmpFile.Name())
- defer tmpFile.Close()
-
- data := make([]byte, 1024)
- rand.Read(data)
- tmpFile.Write(data)
-
- if err = tmpFile.Close(); err != nil {
- t.Fatal(err)
- }
-
- err = SignFile(tmpFile.Name(), tmpFile.Name()+".sig", testSecKey, "crois\rsants", "")
- if err != nil {
- t.Fatal(err)
- }
- defer os.Remove(tmpFile.Name() + ".sig")
-}
-
-func TestSignifyTrustedCommentEmpty(t *testing.T) {
- tmpFile, err := os.CreateTemp("", "")
- if err != nil {
- t.Fatal(err)
- }
- defer os.Remove(tmpFile.Name())
- defer tmpFile.Close()
-
- data := make([]byte, 1024)
- rand.Read(data)
- tmpFile.Write(data)
-
- if err = tmpFile.Close(); err != nil {
- t.Fatal(err)
- }
-
- err = SignFile(tmpFile.Name(), tmpFile.Name()+".sig", testSecKey, "", "")
- if err != nil {
- t.Fatal(err)
- }
- defer os.Remove(tmpFile.Name() + ".sig")
-}