on G*nt**, initialized globals seem to be made of fail and crash

[xonotic/d0_blind_id.git] / d0_blind_id.c

diff --git a/d0_blind_id.c b/d0_blind_id.c
index 58cdd5ee1544079189430f45aa7dc3b86607dbdc..03670532959a4f3b3c8be4230df0985a79855d84 100644 (file)
--- a/d0_blind_id.c
+++ b/d0_blind_id.c
@@ -45,10 +45,9 @@
 
 // our SHA is SHA-256
 #define SHA_DIGESTSIZE 32
-const char *sha(const unsigned char *in, size_t len)
+const unsigned char *sha(unsigned char *h, const unsigned char *in, size_t len)
 {
-       static __thread char h[32];
-       d0_blind_id_util_sha256(h, (const char *) in, len);
+       d0_blind_id_util_sha256((char *) h, (const char *) in, len);
        return h;
 }
 
@@ -121,6 +120,7 @@ static void *tempmutex = NULL; // hold this mutex when using temp0 to temp4
 D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_INITIALIZE(void)
 {
        USINGTEMPS();
+       d0_initfuncs();
        tempmutex = d0_createmutex();
        LOCKTEMPS();
        CHECK(d0_bignum_INITIALIZE());
@@ -367,24 +367,25 @@ fail:
 D0_WARN_UNUSED_RESULT D0_BOOL d0_longhash_destructive(unsigned char *convbuf, size_t sz, unsigned char *outbuf, size_t outbuflen)
 {
        size_t n, i;
+       char shabuf[32];
 
        n = outbuflen;
        while(n > SHA_DIGESTSIZE)
        {
-               memcpy(outbuf, sha(convbuf, sz), SHA_DIGESTSIZE);
+               memcpy(outbuf, sha(shabuf, convbuf, sz), SHA_DIGESTSIZE);
                outbuf += SHA_DIGESTSIZE;
                n -= SHA_DIGESTSIZE;
                for(i = 0; i < sz; ++i)
                        if(++convbuf[i])
                                break; // stop until no carry
        }
-       memcpy(outbuf, sha(convbuf, sz), n);
+       memcpy(outbuf, sha(shabuf, convbuf, sz), n);
        return 1;
 }
 
 D0_WARN_UNUSED_RESULT D0_BOOL d0_longhash_bignum(const d0_bignum_t *in, unsigned char *outbuf, size_t outbuflen)
 {
-       static __thread unsigned char convbuf[1024];
+       unsigned char convbuf[1024];
        size_t sz;
 
        CHECK(d0_bignum_export_unsigned(in, convbuf, sizeof(convbuf)) >= 0);
@@ -531,9 +532,10 @@ fail:
 D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_fingerprint64_public_key(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen)
 {
        d0_iobuf_t *out = NULL;
-       static __thread unsigned char convbuf[2048];
+       unsigned char convbuf[2048];
        d0_iobuf_t *conv = NULL;
        size_t sz, n;
+       char shabuf[32];
 
        USING(rsa_n); USING(rsa_e);
 
@@ -548,7 +550,7 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_fingerprint64_public_key(const d0_blin
        n = (*outbuflen / 4) * 3;
        if(n > SHA_DIGESTSIZE)
                n = SHA_DIGESTSIZE;
-       CHECK(d0_iobuf_write_raw(out, sha(convbuf, sz), n) == n);
+       CHECK(d0_iobuf_write_raw(out, sha(shabuf, convbuf, sz), n) == n);
        CHECK(d0_iobuf_conv_base64_out(out));
 
        return d0_iobuf_close(out, outbuflen);
@@ -624,7 +626,7 @@ fail:
 D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_generate_private_id_request(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen)
 {
        d0_iobuf_t *out = NULL;
-       static __thread unsigned char shabuf[2048];
+       unsigned char hashbuf[2048];
        size_t sz;
 
        USINGTEMPS(); // temps: temp0 rsa_blind_signature_camouflage^challenge, temp1 (4^s)*rsa_blind_signature_camouflage^challenge
@@ -640,10 +642,10 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_generate_private_id_request(d0_blind_i
        LOCKTEMPS();
        CHECK(d0_bignum_mov(temp2, ctx->schnorr_g_to_s));
        sz = (d0_bignum_size(ctx->rsa_n) + 7) / 8; // this is too long, so we have to take the value % rsa_n when "decrypting"
-       if(sz > sizeof(shabuf))
-               sz = sizeof(shabuf);
-       CHECK(d0_longhash_bignum(temp2, shabuf, sz));
-       CHECK(d0_bignum_import_unsigned(temp2, shabuf, sz));
+       if(sz > sizeof(hashbuf))
+               sz = sizeof(hashbuf);
+       CHECK(d0_longhash_bignum(temp2, hashbuf, sz));
+       CHECK(d0_bignum_import_unsigned(temp2, hashbuf, sz));
 
        // hash complete
        CHECK(d0_bignum_mod_mul(temp1, temp2, temp0, ctx->rsa_n));
@@ -823,10 +825,11 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_start(d0_
 //   1. get random r, send HASH(4^r)
 {
        d0_iobuf_t *out = NULL;
-       static __thread unsigned char convbuf[1024];
+       unsigned char convbuf[1024];
        d0_iobuf_t *conv = NULL;
        size_t sz = 0;
        D0_BOOL failed = 0;
+       char shabuf[32];
 
        USINGTEMPS(); // temps: temp0 order, temp0 4^r
        if(is_first)
@@ -880,7 +883,7 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_start(d0_
        CHECK(d0_iobuf_write_bignum(conv, ctx->g_to_t));
        d0_iobuf_close(conv, &sz);
        conv = NULL;
-       CHECK(d0_iobuf_write_raw(out, sha(convbuf, sz), SCHNORR_HASHSIZE) == SCHNORR_HASHSIZE);
+       CHECK(d0_iobuf_write_raw(out, sha(shabuf, convbuf, sz), SCHNORR_HASHSIZE) == SCHNORR_HASHSIZE);
        CHECK(d0_iobuf_write_packet(out, msg, msglen));
 
        return d0_iobuf_close(out, outbuflen);
@@ -899,7 +902,7 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_challenge
 {
        d0_iobuf_t *in = NULL;
        d0_iobuf_t *out = NULL;
-       static __thread unsigned char shabuf[2048];
+       unsigned char hashbuf[2048];
        size_t sz;
 
        USINGTEMPS(); // temps: temp0 order, temp0 signature check
@@ -944,10 +947,10 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_challenge
                // we will actually sign SHA(4^s) to prevent a malleability attack!
                CHECK(d0_bignum_mov(temp2, ctx->schnorr_g_to_s));
                sz = (d0_bignum_size(ctx->rsa_n) + 7) / 8; // this is too long, so we have to take the value % rsa_n when "decrypting"
-               if(sz > sizeof(shabuf))
-                       sz = sizeof(shabuf);
-               CHECK(d0_longhash_bignum(temp2, shabuf, sz));
-               CHECK(d0_bignum_import_unsigned(temp2, shabuf, sz));
+               if(sz > sizeof(hashbuf))
+                       sz = sizeof(hashbuf);
+               CHECK(d0_longhash_bignum(temp2, hashbuf, sz));
+               CHECK(d0_bignum_import_unsigned(temp2, hashbuf, sz));
 
                // + 7 / 8 is too large, so let's mod it
                CHECK(d0_bignum_divmod(NULL, temp1, temp2, ctx->rsa_n));
@@ -1051,9 +1054,10 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_verify(d0
 //      (check using H(g^r) which we know)
 {
        d0_iobuf_t *in = NULL;
-       static __thread unsigned char convbuf[1024];
+       unsigned char convbuf[1024];
        d0_iobuf_t *conv = NULL;
        size_t sz;
+       char shabuf[32];
 
        USINGTEMPS(); // temps: 0 y 1 order
        USING(challenge); USING(schnorr_G);
@@ -1095,7 +1099,7 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_verify(d0
        CHECK(d0_iobuf_write_bignum(conv, ctx->other_g_to_t));
        d0_iobuf_close(conv, &sz);
        conv = NULL;
-       if(memcmp(sha(convbuf, sz), ctx->msghash, SCHNORR_HASHSIZE))
+       if(memcmp(sha(shabuf, convbuf, sz), ctx->msghash, SCHNORR_HASHSIZE))
        {
                // FAIL (not owned by player)
                goto fail;
@@ -1122,7 +1126,7 @@ fail:
 D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_generate_missing_signature(d0_blind_id_t *ctx)
 {
        size_t sz;
-       static __thread unsigned char shabuf[2048];
+       unsigned char hashbuf[2048];
 
        USINGTEMPS(); // temps: 2 hash
        REPLACING(schnorr_H_g_to_s_signature);
@@ -1132,11 +1136,11 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_generate_
 
        // we will actually sign SHA(4^s) to prevent a malleability attack!
        sz = (d0_bignum_size(ctx->rsa_n) + 7) / 8; // this is too long, so we have to take the value % rsa_n when "decrypting"
-       if(sz > sizeof(shabuf))
-               sz = sizeof(shabuf);
-       CHECK(d0_longhash_bignum(ctx->schnorr_g_to_s, shabuf, sz));
+       if(sz > sizeof(hashbuf))
+               sz = sizeof(hashbuf);
+       CHECK(d0_longhash_bignum(ctx->schnorr_g_to_s, hashbuf, sz));
        LOCKTEMPS();
-       CHECK(d0_bignum_import_unsigned(temp2, shabuf, sz));
+       CHECK(d0_bignum_import_unsigned(temp2, hashbuf, sz));
 
        // + 7 / 8 is too large, so let's mod it
        CHECK(d0_bignum_divmod(NULL, temp1, temp2, ctx->rsa_n));
@@ -1154,7 +1158,7 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_sign_with_private_id_sign_internal(d0_
 {
        d0_iobuf_t *out = NULL;
        unsigned char *convbuf = NULL;
-       static __thread unsigned char shabuf[2048];
+       unsigned char hashbuf[2048];
        d0_iobuf_t *conv = NULL;
        size_t sz = 0;
 
@@ -1191,10 +1195,10 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_sign_with_private_id_sign_internal(d0_
        CHECK(d0_iobuf_write_bignum(conv, temp1));
        d0_iobuf_close(conv, &sz);
        conv = NULL;
-       CHECK(d0_longhash_destructive(convbuf, sz, shabuf, (d0_bignum_size(temp0) + 7) / 8));
+       CHECK(d0_longhash_destructive(convbuf, sz, hashbuf, (d0_bignum_size(temp0) + 7) / 8));
        d0_free(convbuf);
        convbuf = NULL;
-       CHECK(d0_bignum_import_unsigned(temp2, shabuf, (d0_bignum_size(temp0) + 7) / 8));
+       CHECK(d0_bignum_import_unsigned(temp2, hashbuf, (d0_bignum_size(temp0) + 7) / 8));
        CHECK(d0_iobuf_write_bignum(out, temp2));
 
        // multiply with secret, sub k, modulo order
@@ -1232,7 +1236,7 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_sign_with_private_id_verify_internal(d
        d0_iobuf_t *in = NULL;
        d0_iobuf_t *conv = NULL;
        unsigned char *convbuf = NULL;
-       static __thread unsigned char shabuf[2048];
+       unsigned char hashbuf[2048];
        size_t sz;
 
        USINGTEMPS(); // temps: 0 sig^e 2 g^s 3 g^-s 4 order
@@ -1274,10 +1278,10 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_sign_with_private_id_verify_internal(d
 
                // we will actually sign SHA(4^s) to prevent a malleability attack!
                sz = (d0_bignum_size(ctx->rsa_n) + 7) / 8; // this is too long, so we have to take the value % rsa_n when "decrypting"
-               if(sz > sizeof(shabuf))
-                       sz = sizeof(shabuf);
-               CHECK(d0_longhash_bignum(ctx->schnorr_g_to_s, shabuf, sz));
-               CHECK(d0_bignum_import_unsigned(temp2, shabuf, sz));
+               if(sz > sizeof(hashbuf))
+                       sz = sizeof(hashbuf);
+               CHECK(d0_longhash_bignum(ctx->schnorr_g_to_s, hashbuf, sz));
+               CHECK(d0_bignum_import_unsigned(temp2, hashbuf, sz));
 
                // + 7 / 8 is too large, so let's mod it
                CHECK(d0_bignum_divmod(NULL, temp1, temp2, ctx->rsa_n));
@@ -1315,10 +1319,10 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_sign_with_private_id_verify_internal(d
        CHECK(d0_iobuf_write_bignum(conv, temp3));
        d0_iobuf_close(conv, &sz);
        conv = NULL;
-       CHECK(d0_longhash_destructive(convbuf, sz, shabuf, (d0_bignum_size(temp4) + 7) / 8));
+       CHECK(d0_longhash_destructive(convbuf, sz, hashbuf, (d0_bignum_size(temp4) + 7) / 8));
        d0_free(convbuf);
        convbuf = NULL;
-       CHECK(d0_bignum_import_unsigned(temp1, shabuf, (d0_bignum_size(temp4) + 7) / 8));
+       CHECK(d0_bignum_import_unsigned(temp1, hashbuf, (d0_bignum_size(temp4) + 7) / 8));
 
        // verify signature
        CHECK(!d0_bignum_cmp(temp0, temp1));
@@ -1347,9 +1351,10 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_sign_with_private_id_verify_detached(d
 D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_fingerprint64_public_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen)
 {
        d0_iobuf_t *out = NULL;
-       static __thread unsigned char convbuf[1024];
+       unsigned char convbuf[1024];
        d0_iobuf_t *conv = NULL;
        size_t sz, n;
+       char shabuf[32];
 
        USING(rsa_n);
        USING(rsa_e);
@@ -1367,7 +1372,7 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_fingerprint64_public_id(const d0_blind
        n = (*outbuflen / 4) * 3;
        if(n > SHA_DIGESTSIZE)
                n = SHA_DIGESTSIZE;
-       CHECK(d0_iobuf_write_raw(out, sha(convbuf, sz), n) == n);
+       CHECK(d0_iobuf_write_raw(out, sha(shabuf, convbuf, sz), n) == n);
        CHECK(d0_iobuf_conv_base64_out(out));
 
        return d0_iobuf_close(out, outbuflen);
@@ -1417,3 +1422,12 @@ void d0_blind_id_util_sha256(char *out, const char *in, size_t n)
        SHA256_Update(&context, (const unsigned char *) in, n);
        return SHA256_Final((unsigned char *) out, &context);
 }
+
+void d0_blind_id_setmallocfuncs(d0_malloc_t *m, d0_free_t *f)
+{
+       d0_setmallocfuncs(m, f);
+}
+void d0_blind_id_setmutexfuncs(d0_createmutex_t *c, d0_destroymutex_t *d, d0_lockmutex_t *l, d0_unlockmutex_t *u)
+{
+       d0_setmutexfuncs(c, d, l, u);
+}