detect failed RNG initialization

[xonotic/d0_blind_id.git] / d0_blind_id.c

diff --git a/d0_blind_id.c b/d0_blind_id.c
index 614f49a217ddd81fa4caa145dc85d847932e8490..e138642c240a7d490a76ee722b68a779c125cf67 100644 (file)
--- a/d0_blind_id.c
+++ b/d0_blind_id.c
@@ -80,15 +80,17 @@ struct d0_blind_id_s
 
 #define CHECK(x) do { if(!(x)) goto fail; } while(0)
 #define CHECK_ASSIGN(var, value) do { d0_bignum_t *val; val = value; if(!val) goto fail; var = val; } while(0)
+#define MPCHECK(x) do { if(!failed) if(!(x)) failed = 1; } while(0)
+#define MPCHECK_ASSIGN(var, value) do { if(!failed) { d0_bignum_t *val; val = value; if(val) var = val; else failed = 1; } } while(0)
 
 #define USING(x) if(!(ctx->x)) return 0
 #define REPLACING(x)
 
 static d0_bignum_t *zero, *one, *four, *temp0, *temp1, *temp2, *temp3, *temp4;
 
-void d0_blind_id_INITIALIZE(void)
+WARN_UNUSED_RESULT BOOL d0_blind_id_INITIALIZE(void)
 {
-       d0_bignum_INITIALIZE();
+       CHECK(d0_bignum_INITIALIZE());
        CHECK_ASSIGN(zero, d0_bignum_int(zero, 0));
        CHECK_ASSIGN(one, d0_bignum_int(one, 1));
        CHECK_ASSIGN(four, d0_bignum_int(four, 4));
@@ -97,8 +99,9 @@ void d0_blind_id_INITIALIZE(void)
        CHECK_ASSIGN(temp2, d0_bignum_int(temp2, 0));
        CHECK_ASSIGN(temp3, d0_bignum_int(temp3, 0));
        CHECK_ASSIGN(temp4, d0_bignum_int(temp4, 0));
+       return 1;
 fail:
-       ;
+       return 0;
 }
 
 void d0_blind_id_SHUTDOWN(void)
@@ -712,6 +715,7 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_start(d0_blind_
        static unsigned char convbuf[1024];
        d0_iobuf_t *conv = NULL;
        size_t sz = 0;
+       BOOL failed = 0;
 
        // temps: temp0 order, temp0 4^r
        if(is_first)
@@ -736,14 +740,27 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_start(d0_blind_
        // generate random number r; x = g^r; send hash of x, remember r, forget x
        CHECK(d0_dl_get_order(temp0, ctx->schnorr_G));
        CHECK_ASSIGN(ctx->r, d0_bignum_rand_range(ctx->r, zero, temp0));
-       CHECK(d0_bignum_mod_pow(temp0, four, ctx->r, ctx->schnorr_G));
+       //CHECK(d0_bignum_mod_pow(temp0, four, ctx->r, ctx->schnorr_G));
 
        // initialize Signed Diffie Hellmann
-       CHECK(d0_dl_get_order(temp1, ctx->schnorr_G));
-       CHECK_ASSIGN(ctx->t, d0_bignum_rand_range(ctx->t, zero, temp1));
-       CHECK_ASSIGN(ctx->g_to_t, d0_bignum_mod_pow(ctx->g_to_t, four, ctx->t, ctx->schnorr_G));
+       // we already have the group order in temp1
+       CHECK_ASSIGN(ctx->t, d0_bignum_rand_range(ctx->t, zero, temp0));
        // can we SOMEHOW do this with just one mod_pow?
 
+#pragma omp parallel default(shared) reduction(||:failed)
+#pragma omp sections
+       {
+#pragma omp section
+               {
+                       MPCHECK(d0_bignum_mod_pow(temp0, four, ctx->r, ctx->schnorr_G));
+               }
+#pragma omp section
+               {
+                       MPCHECK_ASSIGN(ctx->g_to_t, d0_bignum_mod_pow(ctx->g_to_t, four, ctx->t, ctx->schnorr_G));
+               }
+       }
+       CHECK(!failed);
+
        // hash it, hash it, everybody hash it
        conv = d0_iobuf_open_write(convbuf, sizeof(convbuf));
        CHECK(d0_iobuf_write_bignum(conv, temp0));
@@ -921,8 +938,8 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_verify(d0_blind
 
        // verify schnorr ID scheme
        // we need 4^r = 4^temp0 (g^s)^-challenge
-       CHECK(d0_bignum_neg(temp1, ctx->challenge));
-       CHECK(d0_bignum_mod_pow(temp2, ctx->schnorr_g_to_s, temp1, ctx->schnorr_G));
+       CHECK(d0_bignum_mod_inv(temp1, ctx->schnorr_g_to_s, ctx->schnorr_G));
+       CHECK(d0_bignum_mod_pow(temp2, temp1, ctx->challenge, ctx->schnorr_G));
        CHECK(d0_bignum_mod_pow(temp1, four, temp0, ctx->schnorr_G));
        CHECK_ASSIGN(temp3, d0_bignum_mod_mul(temp3, temp1, temp2, ctx->schnorr_G));
 
@@ -963,6 +980,31 @@ fail:
        return 0;
 }
 
+WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_generate_missing_signature(d0_blind_id_t *ctx)
+{
+       size_t sz;
+       static unsigned char shabuf[2048];
+
+       REPLACING(schnorr_H_g_to_s_signature);
+       USING(schnorr_g_to_s); USING(rsa_d); USING(rsa_n);
+
+       // 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_destructive(temp2, shabuf, sz));
+       CHECK(d0_bignum_import_unsigned(temp2, shabuf, sz));
+
+       // + 7 / 8 is too large, so let's mod it
+       CHECK(d0_bignum_divmod(NULL, temp1, temp2, ctx->rsa_n));
+       CHECK(d0_bignum_mod_pow(ctx->schnorr_H_g_to_s_signature, temp1, ctx->rsa_d, ctx->rsa_n));
+       return 1;
+
+fail:
+       return 0;
+}
+
 WARN_UNUSED_RESULT BOOL d0_blind_id_fingerprint64_public_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen)
 {
        d0_iobuf_t *out = NULL;