X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fd0_blind_id.git;a=blobdiff_plain;f=d0_blind_id.c;h=e138642c240a7d490a76ee722b68a779c125cf67;hp=108f082495381f74f3cc4f275830d2c56d5252be;hb=503ed535983a12b4333428712ac404d062519782;hpb=5fc7bf00135320d0426dc153f7d63c1867727d13 diff --git a/d0_blind_id.c b/d0_blind_id.c index 108f082..e138642 100644 --- a/d0_blind_id.c +++ b/d0_blind_id.c @@ -22,7 +22,16 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #include #include #include "d0_bignum.h" -#include "sha1.h" +#include "sha2.h" + +// our SHA is SHA-256 +#define SHA_DIGESTSIZE 32 +const char *sha(const char *in, size_t len) +{ + static char h[32]; + d0_blind_id_util_sha256(h, in, len); + return h; +} // for zero knowledge, we need multiple instances of schnorr ID scheme... should normally be sequential // parallel schnorr ID is not provably zero knowledge :( @@ -32,9 +41,10 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #define SCHNORR_BITS 20 // probability of cheat: 2^(-bits+1) -#define SCHNORR_HASHSIZE 3 -// cannot be >= SHA_DIGEST_LENGTH +#define SCHNORR_HASHSIZE SHA_DIGESTSIZE +// cannot be >= SHA_DIGESTSIZE // *8 must be >= SCHNORR_BITS +// no need to save bits here #define MSGSIZE 640 // ought to be enough for anyone @@ -50,14 +60,17 @@ struct d0_blind_id_s d0_bignum_t *schnorr_s; // public data (player ID public key, this is what the server gets to know) - d0_bignum_t *schnorr_4_to_s; - d0_bignum_t *schnorr_4_to_s_signature; // 0 when signature is invalid + d0_bignum_t *schnorr_g_to_s; + d0_bignum_t *schnorr_H_g_to_s_signature; // 0 when signature is invalid + // as hash function H, we get the SHA1 and reinterpret as bignum - yes, it always is < 160 bits // temp data d0_bignum_t *rsa_blind_signature_camouflage; // random number blind signature d0_bignum_t *r; // random number for schnorr ID - d0_bignum_t *other_4_to_r; // for DH key exchange + d0_bignum_t *t; // for DH key exchange + d0_bignum_t *g_to_t; // for DH key exchange + d0_bignum_t *other_g_to_t; // for DH key exchange d0_bignum_t *challenge; // challenge char msghash[SCHNORR_HASHSIZE]; // init hash @@ -67,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)); @@ -84,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) @@ -189,7 +205,7 @@ BOOL d0_rsa_generate_key(size_t size, const d0_bignum_t *challenge, d0_bignum_t // n = temp0*temp1 CHECK(d0_bignum_mul(n, temp0, temp1)); - + // d = challenge^-1 mod (temp0-1)(temp1-1) CHECK(d0_bignum_mul(temp0, temp2, temp3)); CHECK(d0_bignum_mod_inv(d, challenge, temp0)); @@ -198,6 +214,90 @@ fail: return 0; } +BOOL d0_rsa_generate_key_fastreject(size_t size, d0_fastreject_function reject, d0_blind_id_t *ctx, void *pass) +{ + // uses temp0 to temp4 + int fail = 0; + int gcdfail = 0; + int pb = (size + 1)/2; + int qb = size - pb; + if(pb < 8) + pb = 8; + if(qb < 8) + qb = 8; + for (;;) + { + CHECK(d0_bignum_rand_bit_exact(temp0, pb)); + if(d0_bignum_isprime(temp0, 10) == 0) + continue; + CHECK(d0_bignum_sub(temp2, temp0, one)); + CHECK(d0_bignum_gcd(temp4, NULL, NULL, temp2, ctx->rsa_e)); + if(!d0_bignum_cmp(temp4, one)) + break; + if(++gcdfail == 3) + return 0; + ++gcdfail; + } + gcdfail = 0; + for (;;) + { + CHECK(d0_bignum_rand_bit_exact(temp1, qb)); + if(!d0_bignum_cmp(temp1, temp0)) + { + if(++fail == 3) + return 0; + } + fail = 0; + + // n = temp0*temp1 + CHECK(d0_bignum_mul(ctx->rsa_n, temp0, temp1)); + if(reject(ctx, pass)) + continue; + + if(d0_bignum_isprime(temp1, 10) == 0) + continue; + CHECK(d0_bignum_sub(temp3, temp1, one)); + CHECK(d0_bignum_gcd(temp4, NULL, NULL, temp3, ctx->rsa_e)); + if(!d0_bignum_cmp(temp4, one)) + break; + if(++gcdfail == 3) + return 0; + ++gcdfail; + } + + // ctx->rsa_d = ctx->rsa_e^-1 mod (temp0-1)(temp1-1) + CHECK(d0_bignum_mul(temp0, temp2, temp3)); + CHECK(d0_bignum_mod_inv(ctx->rsa_d, ctx->rsa_e, temp0)); + return 1; +fail: + return 0; +} + +WARN_UNUSED_RESULT BOOL d0_longhash_destructive(d0_bignum_t *clobberme, char *outbuf, size_t outbuflen) +{ + d0_iobuf_t *out = NULL; + static unsigned char convbuf[1024]; + size_t n, sz; + + n = outbuflen; + while(n > SHA_DIGESTSIZE) + { + sz = (d0_bignum_size(clobberme) + 7) / 8; + CHECK(d0_bignum_export_unsigned(clobberme, convbuf, sizeof(convbuf)) >= 0); + memcpy(outbuf, sha(convbuf, sz), SHA_DIGESTSIZE); + outbuf += SHA_DIGESTSIZE; + n -= SHA_DIGESTSIZE; + CHECK(d0_bignum_add(clobberme, clobberme, one)); + } + sz = (d0_bignum_size(clobberme) + 7) / 8; + CHECK(d0_bignum_export_unsigned(clobberme, convbuf, sizeof(convbuf)) >= 0); + memcpy(outbuf, sha(convbuf, sz), n); + return 1; + +fail: + return 0; +} + void d0_blind_id_clear(d0_blind_id_t *ctx) { if(ctx->rsa_n) d0_bignum_free(ctx->rsa_n); @@ -205,47 +305,63 @@ void d0_blind_id_clear(d0_blind_id_t *ctx) if(ctx->rsa_d) d0_bignum_free(ctx->rsa_d); if(ctx->schnorr_G) d0_bignum_free(ctx->schnorr_G); if(ctx->schnorr_s) d0_bignum_free(ctx->schnorr_s); - if(ctx->schnorr_4_to_s) d0_bignum_free(ctx->schnorr_4_to_s); - if(ctx->schnorr_4_to_s_signature) d0_bignum_free(ctx->schnorr_4_to_s_signature); + if(ctx->schnorr_g_to_s) d0_bignum_free(ctx->schnorr_g_to_s); + if(ctx->schnorr_H_g_to_s_signature) d0_bignum_free(ctx->schnorr_H_g_to_s_signature); if(ctx->rsa_blind_signature_camouflage) d0_bignum_free(ctx->rsa_blind_signature_camouflage); if(ctx->r) d0_bignum_free(ctx->r); if(ctx->challenge) d0_bignum_free(ctx->challenge); - if(ctx->other_4_to_r) d0_bignum_free(ctx->other_4_to_r); + if(ctx->t) d0_bignum_free(ctx->t); + if(ctx->g_to_t) d0_bignum_free(ctx->g_to_t); + if(ctx->other_g_to_t) d0_bignum_free(ctx->other_g_to_t); memset(ctx, 0, sizeof(*ctx)); } -void d0_blind_id_copy(d0_blind_id_t *ctx, const d0_blind_id_t *src) +WARN_UNUSED_RESULT BOOL d0_blind_id_copy(d0_blind_id_t *ctx, const d0_blind_id_t *src) { d0_blind_id_clear(ctx); - if(src->rsa_n) ctx->rsa_n = d0_bignum_mov(NULL, src->rsa_n); - if(src->rsa_e) ctx->rsa_e = d0_bignum_mov(NULL, src->rsa_e); - if(src->rsa_d) ctx->rsa_d = d0_bignum_mov(NULL, src->rsa_d); - if(src->schnorr_G) ctx->schnorr_G = d0_bignum_mov(NULL, src->schnorr_G); - if(src->schnorr_s) ctx->schnorr_s = d0_bignum_mov(NULL, src->schnorr_s); - if(src->schnorr_4_to_s) ctx->schnorr_4_to_s = d0_bignum_mov(NULL, ctx->schnorr_G); - if(src->schnorr_4_to_s_signature) ctx->schnorr_4_to_s_signature = d0_bignum_mov(NULL, src->schnorr_4_to_s_signature); - if(src->rsa_blind_signature_camouflage) ctx->rsa_blind_signature_camouflage = d0_bignum_mov(NULL, src->rsa_blind_signature_camouflage); - if(src->r) ctx->r = d0_bignum_mov(NULL, src->r); - if(src->challenge) ctx->challenge = d0_bignum_mov(NULL, src->challenge); - if(src->other_4_to_r) ctx->other_4_to_r = d0_bignum_mov(NULL, src->other_4_to_r); + if(src->rsa_n) CHECK_ASSIGN(ctx->rsa_n, d0_bignum_mov(NULL, src->rsa_n)); + if(src->rsa_e) CHECK_ASSIGN(ctx->rsa_e, d0_bignum_mov(NULL, src->rsa_e)); + if(src->rsa_d) CHECK_ASSIGN(ctx->rsa_d, d0_bignum_mov(NULL, src->rsa_d)); + if(src->schnorr_G) CHECK_ASSIGN(ctx->schnorr_G, d0_bignum_mov(NULL, src->schnorr_G)); + if(src->schnorr_s) CHECK_ASSIGN(ctx->schnorr_s, d0_bignum_mov(NULL, src->schnorr_s)); + if(src->schnorr_g_to_s) CHECK_ASSIGN(ctx->schnorr_g_to_s, d0_bignum_mov(NULL, src->schnorr_g_to_s)); + if(src->schnorr_H_g_to_s_signature) CHECK_ASSIGN(ctx->schnorr_H_g_to_s_signature, d0_bignum_mov(NULL, src->schnorr_H_g_to_s_signature)); + if(src->rsa_blind_signature_camouflage) CHECK_ASSIGN(ctx->rsa_blind_signature_camouflage, d0_bignum_mov(NULL, src->rsa_blind_signature_camouflage)); + if(src->r) CHECK_ASSIGN(ctx->r, d0_bignum_mov(NULL, src->r)); + if(src->challenge) CHECK_ASSIGN(ctx->challenge, d0_bignum_mov(NULL, src->challenge)); + if(src->t) CHECK_ASSIGN(ctx->t, d0_bignum_mov(NULL, src->t)); + if(src->g_to_t) CHECK_ASSIGN(ctx->g_to_t, d0_bignum_mov(NULL, src->g_to_t)); + if(src->other_g_to_t) CHECK_ASSIGN(ctx->other_g_to_t, d0_bignum_mov(NULL, src->other_g_to_t)); memcpy(ctx->msg, src->msg, sizeof(ctx->msg)); ctx->msglen = src->msglen; memcpy(ctx->msghash, src->msghash, sizeof(ctx->msghash)); + return 1; +fail: + d0_blind_id_clear(ctx); + return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_key(d0_blind_id_t *ctx, int k) +WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_key_fastreject(d0_blind_id_t *ctx, int k, d0_fastreject_function reject, void *pass) { REPLACING(rsa_e); REPLACING(rsa_d); REPLACING(rsa_n); CHECK_ASSIGN(ctx->rsa_e, d0_bignum_int(ctx->rsa_e, 65537)); CHECK_ASSIGN(ctx->rsa_d, d0_bignum_zero(ctx->rsa_d)); CHECK_ASSIGN(ctx->rsa_n, d0_bignum_zero(ctx->rsa_n)); - CHECK(d0_rsa_generate_key(k+1, ctx->rsa_e, ctx->rsa_d, ctx->rsa_n)); // must fit G for sure + if(reject) + CHECK(d0_rsa_generate_key_fastreject(k+1, reject, ctx, pass)); // must fit G for sure + else + CHECK(d0_rsa_generate_key(k+1, ctx->rsa_e, ctx->rsa_d, ctx->rsa_n)); // must fit G for sure return 1; fail: return 0; } +WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_key(d0_blind_id_t *ctx, int k) +{ + return d0_blind_id_generate_private_key_fastreject(ctx, k, NULL, NULL); +} + WARN_UNUSED_RESULT BOOL d0_blind_id_read_private_key(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) { d0_iobuf_t *in = NULL; @@ -280,7 +396,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_write_private_key(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +WARN_UNUSED_RESULT BOOL d0_blind_id_write_private_key(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) { d0_iobuf_t *out = NULL; @@ -297,7 +413,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_write_public_key(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +WARN_UNUSED_RESULT BOOL d0_blind_id_write_public_key(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) { d0_iobuf_t *out = NULL; @@ -314,6 +430,38 @@ fail: return 0; } +WARN_UNUSED_RESULT BOOL d0_blind_id_fingerprint64_public_key(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +{ + d0_iobuf_t *out = NULL; + static unsigned char convbuf[2048]; + d0_iobuf_t *conv = NULL; + size_t sz, n; + + USING(rsa_n); USING(rsa_e); + + out = d0_iobuf_open_write(outbuf, *outbuflen); + conv = d0_iobuf_open_write(convbuf, sizeof(convbuf)); + + CHECK(d0_iobuf_write_bignum(conv, ctx->rsa_n)); + CHECK(d0_iobuf_write_bignum(conv, ctx->rsa_e)); + CHECK(d0_iobuf_close(conv, &sz)); + conv = NULL; + + 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_conv_base64_out(out)); + + return d0_iobuf_close(out, outbuflen); + +fail: + if(conv) + d0_iobuf_close(conv, &sz); + d0_iobuf_close(out, outbuflen); + return 0; +} + WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_id_modulus(d0_blind_id_t *ctx) { USING(rsa_n); @@ -341,7 +489,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_write_private_id_modulus(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +WARN_UNUSED_RESULT BOOL d0_blind_id_write_private_id_modulus(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) { d0_iobuf_t *out = NULL; @@ -360,12 +508,12 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_id_start(d0_blind_id_t *ctx { // temps: temp0 = order USING(schnorr_G); - REPLACING(schnorr_s); REPLACING(schnorr_4_to_s); + REPLACING(schnorr_s); REPLACING(schnorr_g_to_s); CHECK(d0_dl_get_order(temp0, ctx->schnorr_G)); CHECK_ASSIGN(ctx->schnorr_s, d0_bignum_rand_range(ctx->schnorr_s, zero, temp0)); - CHECK_ASSIGN(ctx->schnorr_4_to_s, d0_bignum_mod_pow(ctx->schnorr_4_to_s, four, ctx->schnorr_s, ctx->schnorr_G)); - CHECK_ASSIGN(ctx->schnorr_4_to_s_signature, d0_bignum_zero(ctx->schnorr_4_to_s_signature)); + CHECK_ASSIGN(ctx->schnorr_g_to_s, d0_bignum_mod_pow(ctx->schnorr_g_to_s, four, ctx->schnorr_s, ctx->schnorr_G)); + CHECK_ASSIGN(ctx->schnorr_H_g_to_s_signature, d0_bignum_zero(ctx->schnorr_H_g_to_s_signature)); return 1; fail: @@ -375,16 +523,28 @@ fail: WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_id_request(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) { d0_iobuf_t *out = NULL; + static unsigned char convbuf[2048], shabuf[2048]; + size_t sz; // temps: temp0 rsa_blind_signature_camouflage^challenge, temp1 (4^s)*rsa_blind_signature_camouflage^challenge - USING(rsa_n); USING(rsa_e); USING(schnorr_4_to_s); + USING(rsa_n); USING(rsa_e); USING(schnorr_g_to_s); REPLACING(rsa_blind_signature_camouflage); out = d0_iobuf_open_write(outbuf, *outbuflen); CHECK_ASSIGN(ctx->rsa_blind_signature_camouflage, d0_bignum_rand_bit_atmost(ctx->rsa_blind_signature_camouflage, d0_bignum_size(ctx->rsa_n))); CHECK(d0_bignum_mod_pow(temp0, ctx->rsa_blind_signature_camouflage, ctx->rsa_e, ctx->rsa_n)); - CHECK(d0_bignum_mod_mul(temp1, ctx->schnorr_4_to_s, temp0, ctx->rsa_n)); + + // we will actually sign HA(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)); + + // hash complete + CHECK(d0_bignum_mod_mul(temp1, temp2, temp0, ctx->rsa_n)); CHECK(d0_iobuf_write_bignum(out, temp1)); return d0_iobuf_close(out, outbuflen); @@ -393,7 +553,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_answer_private_id_request(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen, char *outbuf, size_t *outbuflen) +WARN_UNUSED_RESULT BOOL d0_blind_id_answer_private_id_request(const d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen, char *outbuf, size_t *outbuflen) { d0_iobuf_t *in = NULL; d0_iobuf_t *out = NULL; @@ -423,13 +583,13 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_finish_private_id_request(d0_blind_id_t *ctx // temps: temp0 input, temp1 rsa_blind_signature_camouflage^-1 USING(rsa_blind_signature_camouflage); USING(rsa_n); - REPLACING(schnorr_4_to_s_signature); + REPLACING(schnorr_H_g_to_s_signature); in = d0_iobuf_open_read(inbuf, inbuflen); CHECK(d0_iobuf_read_bignum(in, temp0)); CHECK(d0_bignum_mod_inv(temp1, ctx->rsa_blind_signature_camouflage, ctx->rsa_n)); - CHECK_ASSIGN(ctx->schnorr_4_to_s_signature, d0_bignum_mod_mul(ctx->schnorr_4_to_s_signature, temp0, temp1, ctx->rsa_n)); + CHECK_ASSIGN(ctx->schnorr_H_g_to_s_signature, d0_bignum_mod_mul(ctx->schnorr_H_g_to_s_signature, temp0, temp1, ctx->rsa_n)); return d0_iobuf_close(in, NULL); @@ -438,17 +598,51 @@ fail: return 0; } +WARN_UNUSED_RESULT BOOL d0_blind_id_read_private_id_request_camouflage(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) +{ + d0_iobuf_t *in = NULL; + + REPLACING(rsa_blind_signature_camouflage); + + in = d0_iobuf_open_read(inbuf, inbuflen); + + CHECK_ASSIGN(ctx->rsa_blind_signature_camouflage, d0_iobuf_read_bignum(in, ctx->rsa_blind_signature_camouflage)); + + return d0_iobuf_close(in, NULL); + +fail: + d0_iobuf_close(in, NULL); + return 0; +} + +WARN_UNUSED_RESULT BOOL d0_blind_id_write_private_id_request_camouflage(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +{ + d0_iobuf_t *out = NULL; + + USING(rsa_blind_signature_camouflage); + + out = d0_iobuf_open_write(outbuf, *outbuflen); + + CHECK(d0_iobuf_write_bignum(out, ctx->rsa_blind_signature_camouflage)); + + return d0_iobuf_close(out, outbuflen); + +fail: + d0_iobuf_close(out, outbuflen); + return 0; +} + WARN_UNUSED_RESULT BOOL d0_blind_id_read_private_id(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) { d0_iobuf_t *in = NULL; - REPLACING(schnorr_s); REPLACING(schnorr_4_to_s); REPLACING(schnorr_4_to_s_signature); + REPLACING(schnorr_s); REPLACING(schnorr_g_to_s); REPLACING(schnorr_H_g_to_s_signature); in = d0_iobuf_open_read(inbuf, inbuflen); CHECK_ASSIGN(ctx->schnorr_s, d0_iobuf_read_bignum(in, ctx->schnorr_s)); - CHECK_ASSIGN(ctx->schnorr_4_to_s, d0_iobuf_read_bignum(in, ctx->schnorr_4_to_s)); - CHECK_ASSIGN(ctx->schnorr_4_to_s_signature, d0_iobuf_read_bignum(in, ctx->schnorr_4_to_s_signature)); + CHECK_ASSIGN(ctx->schnorr_g_to_s, d0_iobuf_read_bignum(in, ctx->schnorr_g_to_s)); + CHECK_ASSIGN(ctx->schnorr_H_g_to_s_signature, d0_iobuf_read_bignum(in, ctx->schnorr_H_g_to_s_signature)); return d0_iobuf_close(in, NULL); @@ -461,12 +655,12 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_read_public_id(d0_blind_id_t *ctx, const cha { d0_iobuf_t *in = NULL; - REPLACING(schnorr_4_to_s); REPLACING(schnorr_4_to_s_signature); + REPLACING(schnorr_g_to_s); REPLACING(schnorr_H_g_to_s_signature); in = d0_iobuf_open_read(inbuf, inbuflen); - CHECK_ASSIGN(ctx->schnorr_4_to_s, d0_iobuf_read_bignum(in, ctx->schnorr_4_to_s)); - CHECK_ASSIGN(ctx->schnorr_4_to_s_signature, d0_iobuf_read_bignum(in, ctx->schnorr_4_to_s_signature)); + CHECK_ASSIGN(ctx->schnorr_g_to_s, d0_iobuf_read_bignum(in, ctx->schnorr_g_to_s)); + CHECK_ASSIGN(ctx->schnorr_H_g_to_s_signature, d0_iobuf_read_bignum(in, ctx->schnorr_H_g_to_s_signature)); return d0_iobuf_close(in, NULL); @@ -475,17 +669,17 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_write_private_id(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +WARN_UNUSED_RESULT BOOL d0_blind_id_write_private_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) { d0_iobuf_t *out = NULL; - USING(schnorr_s); USING(schnorr_4_to_s); USING(schnorr_4_to_s_signature); + USING(schnorr_s); USING(schnorr_g_to_s); USING(schnorr_H_g_to_s_signature); out = d0_iobuf_open_write(outbuf, *outbuflen); CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_s)); - CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_4_to_s)); - CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_4_to_s_signature)); + CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_g_to_s)); + CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_H_g_to_s_signature)); return d0_iobuf_close(out, outbuflen); @@ -494,16 +688,16 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_write_public_id(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +WARN_UNUSED_RESULT BOOL d0_blind_id_write_public_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) { d0_iobuf_t *out = NULL; - USING(schnorr_4_to_s); USING(schnorr_4_to_s_signature); + USING(schnorr_g_to_s); USING(schnorr_H_g_to_s_signature); out = d0_iobuf_open_write(outbuf, *outbuflen); - CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_4_to_s)); - CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_4_to_s_signature)); + CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_g_to_s)); + CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_H_g_to_s_signature)); return d0_iobuf_close(out, outbuflen); @@ -521,14 +715,15 @@ 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) { - USING(schnorr_4_to_s); USING(schnorr_4_to_s_signature); + USING(schnorr_g_to_s); USING(schnorr_H_g_to_s_signature); } USING(schnorr_G); - REPLACING(r); + REPLACING(r); REPLACING(t); REPLACING(g_to_t); out = d0_iobuf_open_write(outbuf, *outbuflen); @@ -537,21 +732,42 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_start(d0_blind_ // send ID if(send_modulus) CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_G)); - CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_4_to_s)); - CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_4_to_s_signature)); + CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_g_to_s)); + CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_H_g_to_s_signature)); } // start schnorr ID scheme // 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 + // 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)); + CHECK(d0_iobuf_write_bignum(conv, ctx->g_to_t)); CHECK(d0_iobuf_write_packet(conv, msg, msglen)); CHECK(d0_iobuf_write_bignum(conv, temp0)); + 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); @@ -572,11 +788,13 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_challenge(d0_bl { d0_iobuf_t *in = NULL; d0_iobuf_t *out = NULL; + static unsigned char shabuf[2048]; + size_t sz; // temps: temp0 order, temp0 signature check if(is_first) { - REPLACING(schnorr_4_to_s); REPLACING(schnorr_4_to_s_signature); + REPLACING(schnorr_g_to_s); REPLACING(schnorr_H_g_to_s_signature); if(recv_modulus) REPLACING(schnorr_G); else @@ -584,11 +802,11 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_challenge(d0_bl } else { - USING(schnorr_4_to_s); USING(schnorr_4_to_s_signature); + USING(schnorr_g_to_s); USING(schnorr_H_g_to_s_signature); USING(schnorr_G); } USING(rsa_e); USING(rsa_n); - REPLACING(challenge); REPLACING(msg); REPLACING(msglen); REPLACING(msghash); REPLACING(r); + REPLACING(challenge); REPLACING(msg); REPLACING(msglen); REPLACING(msghash); REPLACING(r); REPLACING(t); in = d0_iobuf_open_read(inbuf, inbuflen); out = d0_iobuf_open_write(outbuf, *outbuflen); @@ -601,19 +819,32 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_challenge(d0_bl CHECK(d0_bignum_cmp(ctx->schnorr_G, zero) > 0); CHECK(d0_bignum_cmp(ctx->schnorr_G, ctx->rsa_n) < 0); } - CHECK_ASSIGN(ctx->schnorr_4_to_s, d0_iobuf_read_bignum(in, ctx->schnorr_4_to_s)); - CHECK(d0_bignum_cmp(ctx->schnorr_4_to_s, zero) > 0); - CHECK(d0_bignum_cmp(ctx->schnorr_4_to_s, ctx->schnorr_G) < 0); - CHECK_ASSIGN(ctx->schnorr_4_to_s_signature, d0_iobuf_read_bignum(in, ctx->schnorr_4_to_s_signature)); - CHECK(d0_bignum_cmp(ctx->schnorr_4_to_s_signature, zero) >= 0); - CHECK(d0_bignum_cmp(ctx->schnorr_4_to_s_signature, ctx->rsa_n) < 0); + CHECK_ASSIGN(ctx->schnorr_g_to_s, d0_iobuf_read_bignum(in, ctx->schnorr_g_to_s)); + CHECK(d0_bignum_cmp(ctx->schnorr_g_to_s, zero) >= 0); + CHECK(d0_bignum_cmp(ctx->schnorr_g_to_s, ctx->schnorr_G) < 0); + CHECK_ASSIGN(ctx->schnorr_H_g_to_s_signature, d0_iobuf_read_bignum(in, ctx->schnorr_H_g_to_s_signature)); + CHECK(d0_bignum_cmp(ctx->schnorr_H_g_to_s_signature, zero) >= 0); + CHECK(d0_bignum_cmp(ctx->schnorr_H_g_to_s_signature, ctx->rsa_n) < 0); // check signature of key (t = k^d, so, t^challenge = k) - CHECK(d0_bignum_mod_pow(temp0, ctx->schnorr_4_to_s_signature, ctx->rsa_e, ctx->rsa_n)); - if(d0_bignum_cmp(temp0, ctx->schnorr_4_to_s)) + CHECK(d0_bignum_mod_pow(temp0, ctx->schnorr_H_g_to_s_signature, ctx->rsa_e, ctx->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)); + + // hash complete + if(d0_bignum_cmp(temp0, temp1)) { // accept the key anyway, but mark as failed signature! will later return 0 in status - CHECK(d0_bignum_zero(ctx->schnorr_4_to_s_signature)); + CHECK(d0_bignum_zero(ctx->schnorr_H_g_to_s_signature)); } } @@ -623,17 +854,16 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_challenge(d0_bl // send challenge CHECK_ASSIGN(ctx->challenge, d0_bignum_rand_bit_atmost(ctx->challenge, SCHNORR_BITS)); - CHECK(d0_iobuf_write_bignum(out, ctx->challenge)); - // Diffie Hellmann + // Diffie Hellmann send 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_ASSIGN(ctx->t, d0_bignum_rand_range(ctx->t, zero, temp0)); + CHECK(d0_bignum_mod_pow(temp0, four, ctx->t, ctx->schnorr_G)); CHECK(d0_iobuf_write_bignum(out, temp0)); if(status) - *status = !!d0_bignum_cmp(ctx->schnorr_4_to_s_signature, zero); + *status = !!d0_bignum_cmp(ctx->schnorr_H_g_to_s_signature, zero); d0_iobuf_close(in, NULL); return d0_iobuf_close(out, outbuflen); @@ -652,8 +882,8 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_response(d0_bli d0_iobuf_t *out = NULL; // temps: 0 order, 1 prod, 2 y, 3 challenge - REPLACING(other_4_to_r); - USING(schnorr_G); USING(schnorr_s); USING(r); + REPLACING(other_g_to_t); REPLACING(t); + USING(schnorr_G); USING(schnorr_s); USING(r); USING(g_to_t); in = d0_iobuf_open_read(inbuf, inbuflen); out = d0_iobuf_open_write(outbuf, *outbuflen); @@ -662,11 +892,6 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_response(d0_bli CHECK(d0_bignum_cmp(temp3, zero) >= 0); CHECK(d0_bignum_size(temp3) <= SCHNORR_BITS); - // Diffie Hellmann - CHECK_ASSIGN(ctx->other_4_to_r, d0_iobuf_read_bignum(in, ctx->other_4_to_r)); - CHECK(d0_bignum_cmp(ctx->other_4_to_r, zero) > 0); - CHECK(d0_bignum_cmp(ctx->other_4_to_r, ctx->schnorr_G) < 0); - // send response for schnorr ID scheme // i.challenge. r + ctx->schnorr_s * temp3 CHECK(d0_dl_get_order(temp0, ctx->schnorr_G)); @@ -674,6 +899,13 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_response(d0_bli CHECK(d0_bignum_mod_add(temp2, temp1, ctx->r, temp0)); CHECK(d0_iobuf_write_bignum(out, temp2)); + // Diffie Hellmann recv + CHECK_ASSIGN(ctx->other_g_to_t, d0_iobuf_read_bignum(in, ctx->other_g_to_t)); + CHECK(d0_bignum_cmp(ctx->other_g_to_t, zero) > 0); + CHECK(d0_bignum_cmp(ctx->other_g_to_t, ctx->schnorr_G) < 0); + // Diffie Hellmann send + CHECK(d0_iobuf_write_bignum(out, ctx->g_to_t)); + d0_iobuf_close(in, NULL); return d0_iobuf_close(out, outbuflen); @@ -695,7 +927,7 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_verify(d0_blind // temps: 0 y 1 order USING(challenge); USING(schnorr_G); - REPLACING(other_4_to_r); + REPLACING(other_g_to_t); in = d0_iobuf_open_read(inbuf, inbuflen); @@ -705,18 +937,24 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_verify(d0_blind CHECK(d0_bignum_cmp(temp0, temp1) < 0); // verify schnorr ID scheme - // we need 4^temp0 (g^s)^-challenge - CHECK(d0_bignum_neg(temp1, ctx->challenge)); - CHECK(d0_bignum_mod_pow(temp2, ctx->schnorr_4_to_s, temp1, ctx->schnorr_G)); + // we need 4^r = 4^temp0 (g^s)^-challenge + 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(ctx->other_4_to_r, d0_bignum_mod_mul(ctx->other_4_to_r, temp1, temp2, ctx->schnorr_G)); - // hash must be equal to msghash + CHECK_ASSIGN(temp3, d0_bignum_mod_mul(temp3, temp1, temp2, ctx->schnorr_G)); + + // Diffie Hellmann recv + CHECK_ASSIGN(ctx->other_g_to_t, d0_iobuf_read_bignum(in, ctx->other_g_to_t)); + CHECK(d0_bignum_cmp(ctx->other_g_to_t, zero) > 0); + CHECK(d0_bignum_cmp(ctx->other_g_to_t, ctx->schnorr_G) < 0); // hash it, hash it, everybody hash it conv = d0_iobuf_open_write(convbuf, sizeof(convbuf)); - CHECK(d0_iobuf_write_bignum(conv, ctx->other_4_to_r)); + CHECK(d0_iobuf_write_bignum(conv, temp3)); + CHECK(d0_iobuf_write_bignum(conv, ctx->other_g_to_t)); CHECK(d0_iobuf_write_packet(conv, ctx->msg, ctx->msglen)); - CHECK(d0_iobuf_write_bignum(conv, ctx->other_4_to_r)); + CHECK(d0_iobuf_write_bignum(conv, temp3)); + 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)) @@ -726,7 +964,7 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_verify(d0_blind } if(status) - *status = !!d0_bignum_cmp(ctx->schnorr_4_to_s_signature, zero); + *status = !!d0_bignum_cmp(ctx->schnorr_H_g_to_s_signature, zero); if(ctx->msglen <= *msglen) memcpy(msg, ctx->msg, ctx->msglen); @@ -742,19 +980,44 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_fingerprint64_public_id(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +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; static unsigned char convbuf[1024]; d0_iobuf_t *conv = NULL; size_t sz, n; - USING(schnorr_4_to_s); + USING(schnorr_g_to_s); out = d0_iobuf_open_write(outbuf, *outbuflen); conv = d0_iobuf_open_write(convbuf, sizeof(convbuf)); - CHECK(d0_iobuf_write_bignum(conv, ctx->schnorr_4_to_s)); + CHECK(d0_iobuf_write_bignum(conv, ctx->schnorr_g_to_s)); CHECK(d0_iobuf_close(conv, &sz)); conv = NULL; @@ -773,35 +1036,15 @@ fail: return 0; } -BOOL d0_blind_id_sessionkey_public_id(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +BOOL d0_blind_id_sessionkey_public_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) { - d0_iobuf_t *out = NULL; - static unsigned char convbuf[1024]; - d0_iobuf_t *conv = NULL; - size_t n, sz; - - USING(r); USING(other_4_to_r); USING(schnorr_G); - - out = d0_iobuf_open_write(outbuf, *outbuflen); - conv = d0_iobuf_open_write(convbuf, sizeof(convbuf)); + USING(t); USING(other_g_to_t); USING(schnorr_G); // temps: temp0 result - CHECK(d0_bignum_mod_pow(temp0, ctx->other_4_to_r, ctx->r, ctx->schnorr_G)); - CHECK(d0_iobuf_write_bignum(conv, temp0)); - CHECK(d0_iobuf_close(conv, &sz)); - conv = NULL; - - n = *outbuflen; - if(n > SHA_DIGESTSIZE) - n = SHA_DIGESTSIZE; - CHECK(d0_iobuf_write_raw(out, sha(convbuf, sz), n) == n); - - return d0_iobuf_close(out, outbuflen); + CHECK(d0_bignum_mod_pow(temp0, ctx->other_g_to_t, ctx->t, ctx->schnorr_G)); + return d0_longhash_destructive(temp0, outbuf, *outbuflen); fail: - if(conv) - d0_iobuf_close(conv, &sz); - d0_iobuf_close(out, outbuflen); return 0; } @@ -817,3 +1060,11 @@ void d0_blind_id_free(d0_blind_id_t *a) d0_blind_id_clear(a); d0_free(a); } + +void d0_blind_id_util_sha256(char *out, const char *in, size_t n) +{ + SHA256_CTX context; + SHA256_Init(&context); + SHA256_Update(&context, (const unsigned char *) in, n); + return SHA256_Final((unsigned char *) out, &context); +}