From: Rudolf Polzer Date: Fri, 17 Sep 2010 06:33:14 +0000 (+0200) Subject: also support signing X-Git-Tag: xonotic-v0.1.0preview~9 X-Git-Url: https://git.rm.cloudns.org/?a=commitdiff_plain;h=09adb6717861941b70ce52996a6159ffe23c5d0c;p=xonotic%2Fd0_blind_id.git also support signing --- diff --git a/d0_bignum-gmp.c b/d0_bignum-gmp.c index 45f46a2..3b36b7d 100644 --- a/d0_bignum-gmp.c +++ b/d0_bignum-gmp.c @@ -363,6 +363,13 @@ d0_bignum_t *d0_bignum_mod_add(d0_bignum_t *r, const d0_bignum_t *a, const d0_bi return r; } +d0_bignum_t *d0_bignum_mod_sub(d0_bignum_t *r, const d0_bignum_t *a, const d0_bignum_t *b, const d0_bignum_t *m) +{ + r = d0_bignum_sub(r, a, b); + mpz_fdiv_r(r->z, r->z, m->z); + return r; +} + d0_bignum_t *d0_bignum_mod_mul(d0_bignum_t *r, const d0_bignum_t *a, const d0_bignum_t *b, const d0_bignum_t *m) { r = d0_bignum_mul(r, a, b); diff --git a/d0_bignum-openssl.c b/d0_bignum-openssl.c index 9c43e8f..0830ab2 100644 --- a/d0_bignum-openssl.c +++ b/d0_bignum-openssl.c @@ -293,6 +293,13 @@ d0_bignum_t *d0_bignum_mod_add(d0_bignum_t *r, const d0_bignum_t *a, const d0_bi return r; } +d0_bignum_t *d0_bignum_mod_sub(d0_bignum_t *r, const d0_bignum_t *a, const d0_bignum_t *b, const d0_bignum_t *m) +{ + if(!r) r = d0_bignum_new(); if(!r) return NULL; + BN_mod_sub(&r->z, &a->z, &b->z, &m->z, ctx); + return r; +} + d0_bignum_t *d0_bignum_mod_mul(d0_bignum_t *r, const d0_bignum_t *a, const d0_bignum_t *b, const d0_bignum_t *m) { if(!r) r = d0_bignum_new(); if(!r) return NULL; diff --git a/d0_bignum.h b/d0_bignum.h index 9a23979..6d94228 100644 --- a/d0_bignum.h +++ b/d0_bignum.h @@ -69,6 +69,7 @@ D0_WARN_UNUSED_RESULT d0_bignum_t *d0_bignum_sub(d0_bignum_t *r, const d0_bignum D0_WARN_UNUSED_RESULT d0_bignum_t *d0_bignum_mul(d0_bignum_t *r, const d0_bignum_t *a, const d0_bignum_t *b); D0_WARN_UNUSED_RESULT d0_bignum_t *d0_bignum_divmod(d0_bignum_t *q, d0_bignum_t *m, const d0_bignum_t *a, const d0_bignum_t *b); // only do mod if both are NULL D0_WARN_UNUSED_RESULT d0_bignum_t *d0_bignum_mod_add(d0_bignum_t *r, const d0_bignum_t *a, const d0_bignum_t *b, const d0_bignum_t *m); +D0_WARN_UNUSED_RESULT d0_bignum_t *d0_bignum_mod_sub(d0_bignum_t *r, const d0_bignum_t *a, const d0_bignum_t *b, const d0_bignum_t *m); D0_WARN_UNUSED_RESULT d0_bignum_t *d0_bignum_mod_mul(d0_bignum_t *r, const d0_bignum_t *a, const d0_bignum_t *b, const d0_bignum_t *m); D0_WARN_UNUSED_RESULT d0_bignum_t *d0_bignum_mod_pow(d0_bignum_t *r, const d0_bignum_t *a, const d0_bignum_t *b, const d0_bignum_t *m); D0_WARN_UNUSED_RESULT D0_BOOL d0_bignum_mod_inv(d0_bignum_t *r, const d0_bignum_t *a, const d0_bignum_t *m); diff --git a/d0_blind_id.c b/d0_blind_id.c index 9bb650c..3abfb9d 100644 --- a/d0_blind_id.c +++ b/d0_blind_id.c @@ -42,10 +42,10 @@ // our SHA is SHA-256 #define SHA_DIGESTSIZE 32 -const char *sha(const char *in, size_t len) +const char *sha(const unsigned char *in, size_t len) { static char h[32]; - d0_blind_id_util_sha256(h, in, len); + d0_blind_id_util_sha256(h, (const char *) in, len); return h; } @@ -289,26 +289,33 @@ fail: return 0; } -D0_WARN_UNUSED_RESULT D0_BOOL d0_longhash_destructive(d0_bignum_t *clobberme, char *outbuf, size_t outbuflen) +D0_WARN_UNUSED_RESULT D0_BOOL d0_longhash_destructive(unsigned char *convbuf, size_t sz, unsigned char *outbuf, size_t outbuflen) { - d0_iobuf_t *out = NULL; - static unsigned char convbuf[1024]; - size_t n, sz; + size_t n, i; 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)); + for(i = 0; i < sz; ++i) + if(++convbuf[i]) + break; // stop until no carry } - 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; +} + +D0_WARN_UNUSED_RESULT D0_BOOL d0_longhash_bignum(const d0_bignum_t *in, unsigned char *outbuf, size_t outbuflen) +{ + static unsigned char convbuf[1024]; + size_t sz; + + CHECK(d0_bignum_export_unsigned(in, convbuf, sizeof(convbuf)) >= 0); + sz = (d0_bignum_size(in) + 7) / 8; + CHECK(d0_longhash_destructive(convbuf, sz, outbuf, outbuflen)); + return 1; fail: return 0; @@ -539,7 +546,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 unsigned char convbuf[2048], shabuf[2048]; + static unsigned char shabuf[2048]; size_t sz; // temps: temp0 rsa_blind_signature_camouflage^challenge, temp1 (4^s)*rsa_blind_signature_camouflage^challenge @@ -556,7 +563,7 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_generate_private_id_request(d0_blind_i 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_longhash_bignum(temp2, shabuf, sz)); CHECK(d0_bignum_import_unsigned(temp2, shabuf, sz)); // hash complete @@ -722,7 +729,7 @@ fail: return 0; } -D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_start(d0_blind_id_t *ctx, D0_BOOL is_first, D0_BOOL send_modulus, char *msg, size_t msglen, char *outbuf, size_t *outbuflen) +D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_start(d0_blind_id_t *ctx, D0_BOOL is_first, D0_BOOL send_modulus, const char *msg, size_t msglen, char *outbuf, size_t *outbuflen) // start = // first run: send 4^s, 4^s signature // 1. get random r, send HASH(4^r) @@ -763,8 +770,8 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_start(d0_ CHECK_ASSIGN(ctx->t, d0_bignum_rand_range(ctx->t, zero, temp0)); // can we SOMEHOW do this with just one mod_pow? - MPCHECK(d0_bignum_mod_pow(temp0, four, ctx->r, ctx->schnorr_G)); - MPCHECK_ASSIGN(ctx->g_to_t, d0_bignum_mod_pow(ctx->g_to_t, four, ctx->t, ctx->schnorr_G)); + CHECK(d0_bignum_mod_pow(temp0, four, ctx->r, ctx->schnorr_G)); + CHECK_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 @@ -840,7 +847,7 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_challenge 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_longhash_bignum(temp2, shabuf, sz)); CHECK(d0_bignum_import_unsigned(temp2, shabuf, sz)); // + 7 / 8 is too large, so let's mod it @@ -999,7 +1006,7 @@ D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_generate_ 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_longhash_bignum(temp2, shabuf, sz)); CHECK(d0_bignum_import_unsigned(temp2, shabuf, sz)); // + 7 / 8 is too large, so let's mod it @@ -1011,6 +1018,162 @@ fail: return 0; } +D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_sign_with_private_id_sign(d0_blind_id_t *ctx, D0_BOOL is_first, D0_BOOL send_modulus, const char *message, size_t msglen, char *outbuf, size_t *outbuflen) +{ + d0_iobuf_t *out = NULL; + static unsigned char convbuf[1024]; + static unsigned char shabuf[1024]; + d0_iobuf_t *conv = NULL; + size_t sz = 0; + + if(is_first) + { + USING(schnorr_g_to_s); USING(schnorr_H_g_to_s_signature); + } + USING(schnorr_G); + USING(schnorr_s); + REPLACING(r); + + out = d0_iobuf_open_write(outbuf, *outbuflen); + + if(is_first) + { + // send ID + if(send_modulus) + CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_G)); + 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 SIGNATURE scheme + // generate random number r; x = g^r; send hash of H(m||r), 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(temp1, four, ctx->r, ctx->schnorr_G)); + + // hash it, hash it, everybody hash it + conv = d0_iobuf_open_write(convbuf, sizeof(convbuf)); + CHECK(d0_iobuf_write_packet(conv, message, msglen)); + 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_bignum_import_unsigned(temp2, shabuf, (d0_bignum_size(temp0) + 7) / 8)); + CHECK(d0_iobuf_write_bignum(out, temp2)); + + // multiply with secret, sub k, modulo order + CHECK(d0_bignum_mod_mul(temp1, temp2, ctx->schnorr_s, temp0)); + CHECK(d0_bignum_mod_sub(temp2, ctx->r, temp1, temp0)); + CHECK(d0_iobuf_write_bignum(out, temp2)); + + // write the message itself + CHECK(d0_iobuf_write_packet(out, message, msglen)); + + return d0_iobuf_close(out, outbuflen); + +fail: + d0_iobuf_close(out, outbuflen); + return 0; +} + +D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_sign_with_private_id_verify(d0_blind_id_t *ctx, D0_BOOL is_first, D0_BOOL recv_modulus, const char *inbuf, size_t inbuflen, char *msg, size_t *msglen, D0_BOOL *status) +{ + d0_iobuf_t *in = NULL; + d0_iobuf_t *conv = NULL; + static unsigned char convbuf[2048]; + static unsigned char shabuf[2048]; + size_t sz; + + if(is_first) + { + REPLACING(schnorr_g_to_s); REPLACING(schnorr_H_g_to_s_signature); + if(recv_modulus) + REPLACING(schnorr_G); + else + USING(schnorr_G); + } + else + { + USING(schnorr_g_to_s); USING(schnorr_H_g_to_s_signature); + USING(schnorr_G); + } + USING(rsa_e); USING(rsa_n); + + in = d0_iobuf_open_read(inbuf, inbuflen); + + if(is_first) + { + if(recv_modulus) + { + CHECK_ASSIGN(ctx->schnorr_G, d0_iobuf_read_bignum(in, ctx->schnorr_G)); + CHECK(d0_bignum_cmp(ctx->schnorr_G, zero) > 0); + CHECK(d0_bignum_cmp(ctx->schnorr_G, 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_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_bignum(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_H_g_to_s_signature)); + } + } + + CHECK(d0_dl_get_order(temp4, ctx->schnorr_G)); + CHECK(d0_iobuf_read_bignum(in, temp0)); // e == H(m || g^r) + CHECK(d0_iobuf_read_bignum(in, temp1)); // x == (r - s*e) mod |G| + CHECK(d0_iobuf_read_packet(in, msg, msglen)); + + // VERIFY: g^x * (g^s)^-e = g^(x - s*e) = g^r + + // verify schnorr ID scheme + // we need g^r = g^x (g^s)^e + CHECK(d0_bignum_mod_pow(temp2, four, temp1, ctx->schnorr_G)); + CHECK(d0_bignum_mod_pow(temp1, ctx->schnorr_g_to_s, temp0, ctx->schnorr_G)); + CHECK_ASSIGN(temp3, d0_bignum_mod_mul(temp3, temp1, temp2, ctx->schnorr_G)); // temp3 now is g^r + + // hash it, hash it, everybody hash it + conv = d0_iobuf_open_write(convbuf, sizeof(convbuf)); + CHECK(d0_iobuf_write_packet(conv, msg, *msglen)); + 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_bignum_import_unsigned(temp1, shabuf, (d0_bignum_size(temp4) + 7) / 8)); + + // verify signature + CHECK(!d0_bignum_cmp(temp0, temp1)); + + if(status) + *status = !!d0_bignum_cmp(ctx->schnorr_H_g_to_s_signature, zero); + + d0_iobuf_close(in, NULL); + return 1; + +fail: + d0_iobuf_close(in, NULL); + return 0; +} + 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; @@ -1052,7 +1215,7 @@ D0_BOOL d0_blind_id_sessionkey_public_id(const d0_blind_id_t *ctx, char *outbuf, // temps: temp0 result CHECK(d0_bignum_mod_pow(temp0, ctx->other_g_to_t, ctx->t, ctx->schnorr_G)); - return d0_longhash_destructive(temp0, outbuf, *outbuflen); + return d0_longhash_bignum(temp0, (unsigned char *) outbuf, *outbuflen); fail: return 0; diff --git a/d0_blind_id.h b/d0_blind_id.h index 522a02d..a5ce51a 100644 --- a/d0_blind_id.h +++ b/d0_blind_id.h @@ -65,11 +65,13 @@ D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_read_private_id(d0_blind_id_ D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_read_public_id(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen); D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_write_private_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen); D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_write_public_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen); -D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_start(d0_blind_id_t *ctx, D0_BOOL is_first, D0_BOOL send_modulus, char *message, size_t msglen, char *outbuf, size_t *outbuflen); +D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_start(d0_blind_id_t *ctx, D0_BOOL is_first, D0_BOOL send_modulus, const char *message, size_t msglen, char *outbuf, size_t *outbuflen); D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_challenge(d0_blind_id_t *ctx, D0_BOOL is_first, D0_BOOL recv_modulus, const char *inbuf, size_t inbuflen, char *outbuf, size_t *outbuflen, D0_BOOL *status); D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_response(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen, char *outbuf, size_t *outbuflen); D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_verify(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen, char *msg, size_t *msglen, D0_BOOL *status); D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_authenticate_with_private_id_generate_missing_signature(d0_blind_id_t *ctx); +D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_sign_with_private_id_sign(d0_blind_id_t *ctx, D0_BOOL is_first, D0_BOOL send_modulus, const char *message, size_t msglen, char *outbuf, size_t *outbuflen); +D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_sign_with_private_id_verify(d0_blind_id_t *ctx, D0_BOOL is_first, D0_BOOL recv_modulus, const char *inbuf, size_t inbuflen, char *msg, size_t *msglen, D0_BOOL *status); D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_fingerprint64_public_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen); D0_EXPORT D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_sessionkey_public_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen); // can only be done after successful key exchange, this performs a modpow; key length is limited by SHA_DIGESTSIZE for now; also ONLY valid after successful d0_blind_id_authenticate_with_private_id_verify/d0_blind_id_fingerprint64_public_id diff --git a/main.c b/main.c index 9506c1e..bc39797 100644 --- a/main.c +++ b/main.c @@ -141,10 +141,21 @@ int main(int argc, char **argv) errx(8, "readpub2 fail"); n = 0; - double bench_auth = 0, bench_chall = 0, bench_resp = 0, bench_verify = 0, bench_dhkey1 = 0, bench_dhkey2 = 0; + double bench_auth = 0, bench_chall = 0, bench_resp = 0, bench_verify = 0, bench_dhkey1 = 0, bench_dhkey2 = 0, bench_sign = 0, bench_signverify = 0; D0_BOOL status; while(!quit) { + bench(&bench_sign); + bufsize = sizeof(buf); if(!d0_blind_id_sign_with_private_id_sign(ctx_other, 1, 1, "hello world", 11, buf, &bufsize)) + errx(9, "sign fail"); + bench(&bench_signverify); + buf2size = sizeof(buf2); if(!d0_blind_id_sign_with_private_id_verify(ctx_self, 1, 1, buf, bufsize, buf2, &buf2size, &status)) + errx(9, "signverify fail"); + bench(&bench_stop); + if(buf2size != 11 || memcmp(buf2, "hello world", 11)) + errx(13, "signhello fail"); + if(!status) + errx(14, "signsignature fail"); bench(&bench_auth); bufsize = sizeof(buf); if(!d0_blind_id_authenticate_with_private_id_start(ctx_other, 1, 1, "hello world", 11, buf, &bufsize)) errx(9, "start fail"); @@ -174,7 +185,7 @@ int main(int argc, char **argv) errx(17, "dhkey match fail"); ++n; if(n % 1024 == 0) - printf("auth=%f chall=%f resp=%f verify=%f dh1=%f dh2=%f\n", n/bench_auth, n/bench_chall, n/bench_resp, n/bench_verify, n/bench_dhkey1, n/bench_dhkey2); + printf("sign=%f signverify=%f auth=%f chall=%f resp=%f verify=%f dh1=%f dh2=%f\n", n/bench_sign, n/bench_signverify, n/bench_auth, n/bench_chall, n/bench_resp, n/bench_verify, n/bench_dhkey1, n/bench_dhkey2); } return 0;