X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=d0_blind_id.c;h=9bb650c7b9dae4b6a84f7f20039cbe7ec5cc4d05;hb=a0b5239a7c040e5694b62993ee09d3bfbc589b03;hp=9c7a5137fb91ea02c0868aa166a7cb65805c3ad7;hpb=f1c5f7544308619eb35d410e2e46e62543b6b916;p=xonotic%2Fd0_blind_id.git diff --git a/d0_blind_id.c b/d0_blind_id.c index 9c7a513..9bb650c 100644 --- a/d0_blind_id.c +++ b/d0_blind_id.c @@ -1,21 +1,37 @@ /* -Blind-ID library for user identification using RSA blind signatures -Copyright (C) 2010 Rudolf Polzer - -This 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 2.1 of the License, or (at your option) any later version. - -This 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 this library; if not, write to the Free Software -Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -*/ + * FILE: d0_blind_id.c + * AUTHOR: Rudolf Polzer - divVerent@xonotic.org + * + * Copyright (c) 2010, Rudolf Polzer + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holder nor the names of contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Format:commit %H$ + * $Id$ + */ #include "d0_blind_id.h" @@ -60,8 +76,8 @@ 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_H_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 @@ -69,7 +85,8 @@ struct d0_blind_id_s d0_bignum_t *r; // random number for schnorr ID d0_bignum_t *t; // for DH key exchange - d0_bignum_t *other_4_to_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 @@ -79,15 +96,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) +D0_WARN_UNUSED_RESULT D0_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)); @@ -96,8 +115,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) @@ -132,7 +152,7 @@ fail: return NULL; } -BOOL d0_dl_generate_key(size_t size, d0_bignum_t *G) +D0_BOOL d0_dl_generate_key(size_t size, d0_bignum_t *G) { // using: temp0 if(size < 16) @@ -154,7 +174,7 @@ fail: return 0; } -BOOL d0_rsa_generate_key(size_t size, const d0_bignum_t *challenge, d0_bignum_t *d, d0_bignum_t *n) +D0_BOOL d0_rsa_generate_key(size_t size, const d0_bignum_t *challenge, d0_bignum_t *d, d0_bignum_t *n) { // uses temp0 to temp4 int fail = 0; @@ -210,7 +230,7 @@ fail: return 0; } -BOOL d0_rsa_generate_key_fastreject(size_t size, d0_fastreject_function reject, d0_blind_id_t *ctx, void *pass) +D0_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; @@ -269,7 +289,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_longhash_destructive(d0_bignum_t *clobberme, char *outbuf, size_t outbuflen) +D0_WARN_UNUSED_RESULT D0_BOOL d0_longhash_destructive(d0_bignum_t *clobberme, char *outbuf, size_t outbuflen) { d0_iobuf_t *out = NULL; static unsigned char convbuf[1024]; @@ -301,17 +321,18 @@ 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_H_4_to_s_signature) d0_bignum_free(ctx->schnorr_H_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->t) d0_bignum_free(ctx->t); - if(ctx->other_4_to_t) d0_bignum_free(ctx->other_4_to_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)); } -WARN_UNUSED_RESULT BOOL d0_blind_id_copy(d0_blind_id_t *ctx, const d0_blind_id_t *src) +D0_WARN_UNUSED_RESULT D0_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) CHECK_ASSIGN(ctx->rsa_n, d0_bignum_mov(NULL, src->rsa_n)); @@ -319,13 +340,14 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_copy(d0_blind_id_t *ctx, const d0_blind_id_t 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_4_to_s) CHECK_ASSIGN(ctx->schnorr_4_to_s, d0_bignum_mov(NULL, src->schnorr_4_to_s)); - if(src->schnorr_H_4_to_s_signature) CHECK_ASSIGN(ctx->schnorr_H_4_to_s_signature, d0_bignum_mov(NULL, src->schnorr_H_4_to_s_signature)); + 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->other_4_to_t) CHECK_ASSIGN(ctx->other_4_to_t, d0_bignum_mov(NULL, src->other_4_to_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)); @@ -335,7 +357,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_key_fastreject(d0_blind_id_t *ctx, int k, d0_fastreject_function reject, void *pass) +D0_WARN_UNUSED_RESULT D0_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); @@ -351,12 +373,12 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_key(d0_blind_id_t *ctx, int k) +D0_WARN_UNUSED_RESULT D0_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_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_read_private_key(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) { d0_iobuf_t *in = NULL; @@ -374,7 +396,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_read_public_key(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) +D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_read_public_key(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) { d0_iobuf_t *in = NULL; @@ -390,7 +412,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_write_private_key(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_write_private_key(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) { d0_iobuf_t *out = NULL; @@ -407,7 +429,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_write_public_key(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_write_public_key(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) { d0_iobuf_t *out = NULL; @@ -424,7 +446,7 @@ 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_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 unsigned char convbuf[2048]; @@ -456,7 +478,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_id_modulus(d0_blind_id_t *ctx) +D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_generate_private_id_modulus(d0_blind_id_t *ctx) { USING(rsa_n); REPLACING(schnorr_G); @@ -468,7 +490,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_read_private_id_modulus(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) +D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_read_private_id_modulus(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) { d0_iobuf_t *in = NULL; @@ -483,7 +505,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_write_private_id_modulus(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_write_private_id_modulus(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) { d0_iobuf_t *out = NULL; @@ -498,30 +520,30 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_id_start(d0_blind_id_t *ctx) +D0_WARN_UNUSED_RESULT D0_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_H_4_to_s_signature, d0_bignum_zero(ctx->schnorr_H_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: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_id_request(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +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]; 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); @@ -530,7 +552,7 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_id_request(d0_blind_id_t *c CHECK(d0_bignum_mod_pow(temp0, ctx->rsa_blind_signature_camouflage, ctx->rsa_e, ctx->rsa_n)); // we will actually sign HA(4^s) to prevent a malleability attack! - CHECK(d0_bignum_mov(temp2, ctx->schnorr_4_to_s)); + 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); @@ -547,7 +569,7 @@ fail: return 0; } -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_WARN_UNUSED_RESULT D0_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; @@ -571,19 +593,19 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_finish_private_id_request(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) +D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_finish_private_id_request(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) { d0_iobuf_t *in = NULL; // temps: temp0 input, temp1 rsa_blind_signature_camouflage^-1 USING(rsa_blind_signature_camouflage); USING(rsa_n); - REPLACING(schnorr_H_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_H_4_to_s_signature, d0_bignum_mod_mul(ctx->schnorr_H_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); @@ -592,7 +614,7 @@ 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_WARN_UNUSED_RESULT D0_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; @@ -609,7 +631,7 @@ fail: 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_WARN_UNUSED_RESULT D0_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; @@ -626,17 +648,17 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_read_private_id(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) +D0_WARN_UNUSED_RESULT D0_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_H_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_H_4_to_s_signature, d0_iobuf_read_bignum(in, ctx->schnorr_H_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); @@ -645,16 +667,16 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_read_public_id(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) +D0_WARN_UNUSED_RESULT D0_BOOL d0_blind_id_read_public_id(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen) { d0_iobuf_t *in = NULL; - REPLACING(schnorr_4_to_s); REPLACING(schnorr_H_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_H_4_to_s_signature, d0_iobuf_read_bignum(in, ctx->schnorr_H_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); @@ -663,17 +685,17 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_write_private_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +D0_WARN_UNUSED_RESULT D0_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_H_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_H_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); @@ -682,16 +704,16 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_write_public_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +D0_WARN_UNUSED_RESULT D0_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_H_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_H_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); @@ -700,7 +722,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_start(d0_blind_id_t *ctx, BOOL is_first, 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, 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) @@ -709,14 +731,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; + D0_BOOL failed = 0; // temps: temp0 order, temp0 4^r if(is_first) { - USING(schnorr_4_to_s); USING(schnorr_H_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); @@ -725,21 +748,32 @@ 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_H_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? + + 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(!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); @@ -752,7 +786,7 @@ fail: return 0; } -WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_challenge(d0_blind_id_t *ctx, BOOL is_first, BOOL recv_modulus, const char *inbuf, size_t inbuflen, char *outbuf, size_t *outbuflen, BOOL *status) +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) // first run: get 4^s, 4^s signature // 1. check sig // 2. save HASH(4^r) @@ -766,7 +800,7 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_challenge(d0_bl // temps: temp0 order, temp0 signature check if(is_first) { - REPLACING(schnorr_4_to_s); REPLACING(schnorr_H_4_to_s_signature); + REPLACING(schnorr_g_to_s); REPLACING(schnorr_H_g_to_s_signature); if(recv_modulus) REPLACING(schnorr_G); else @@ -774,7 +808,7 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_challenge(d0_bl } else { - USING(schnorr_4_to_s); USING(schnorr_H_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); @@ -791,18 +825,18 @@ 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_H_4_to_s_signature, d0_iobuf_read_bignum(in, ctx->schnorr_H_4_to_s_signature)); - CHECK(d0_bignum_cmp(ctx->schnorr_H_4_to_s_signature, zero) >= 0); - CHECK(d0_bignum_cmp(ctx->schnorr_H_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_H_4_to_s_signature, ctx->rsa_e, ctx->rsa_n)); + 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_4_to_s)); + 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); @@ -816,7 +850,7 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_challenge(d0_bl 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_4_to_s_signature)); + CHECK(d0_bignum_zero(ctx->schnorr_H_g_to_s_signature)); } } @@ -835,7 +869,7 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_challenge(d0_bl CHECK(d0_iobuf_write_bignum(out, temp0)); if(status) - *status = !!d0_bignum_cmp(ctx->schnorr_H_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); @@ -846,7 +880,7 @@ fail: return 0; } -WARN_UNUSED_RESULT 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_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) // 1. read challenge challenge of SCHNORR_BITS // 2. reply with r + s * challenge mod order { @@ -854,8 +888,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_t); REPLACING(t); - 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); @@ -872,22 +906,11 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_response(d0_bli CHECK(d0_iobuf_write_bignum(out, temp2)); // Diffie Hellmann recv - CHECK_ASSIGN(ctx->other_4_to_t, d0_iobuf_read_bignum(in, ctx->other_4_to_t)); - CHECK(d0_bignum_cmp(ctx->other_4_to_t, zero) > 0); - CHECK(d0_bignum_cmp(ctx->other_4_to_t, ctx->schnorr_G) < 0); + 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_dl_get_order(temp0, ctx->schnorr_G)); - CHECK_ASSIGN(ctx->t, d0_bignum_rand_range(ctx->t, zero, temp0)); - // modify DH key value! (add |G|-r) - CHECK(d0_bignum_add(temp1, ctx->t, temp0)); - CHECK(d0_bignum_sub(temp2, temp1, ctx->r)); - // can be undone by multiplying with 4^r in the end - // ensures the party of the DH key exchange is the same party as the one of - // the auth protocol (MITM who changes DH key exchange must break auth protocol) - // trick is that MITM has no knowledge about g^r at this point, as he only - // knows it in hashed form - CHECK(d0_bignum_mod_pow(temp0, four, temp2, ctx->schnorr_G)); - CHECK(d0_iobuf_write_bignum(out, temp0)); + CHECK(d0_iobuf_write_bignum(out, ctx->g_to_t)); d0_iobuf_close(in, NULL); return d0_iobuf_close(out, outbuflen); @@ -898,7 +921,7 @@ fail: return 0; } -WARN_UNUSED_RESULT 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, BOOL *status) +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) // 1. read y = r + s * challenge mod order // 2. verify: g^y (g^s)^-challenge = g^(r+s*challenge-s*challenge) = g^r // (check using H(g^r) which we know) @@ -910,7 +933,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_t); + REPLACING(other_g_to_t); in = d0_iobuf_open_read(inbuf, inbuflen); @@ -921,23 +944,23 @@ 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_4_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)); // Diffie Hellmann recv - CHECK_ASSIGN(ctx->other_4_to_t, d0_iobuf_read_bignum(in, ctx->other_4_to_t)); - CHECK(d0_bignum_cmp(ctx->other_4_to_t, zero) > 0); - CHECK(d0_bignum_cmp(ctx->other_4_to_t, ctx->schnorr_G) < 0); - // recover DH key value! - CHECK(d0_bignum_mod_mul(ctx->other_4_to_t, ctx->other_4_to_t, temp3, ctx->schnorr_G)); + 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, 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, 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)) @@ -947,7 +970,7 @@ WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_verify(d0_blind } if(status) - *status = !!d0_bignum_cmp(ctx->schnorr_H_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); @@ -963,19 +986,48 @@ 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_WARN_UNUSED_RESULT D0_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; +} + +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 unsigned char convbuf[1024]; d0_iobuf_t *conv = NULL; size_t sz, n; - USING(schnorr_4_to_s); + USING(rsa_n); + USING(rsa_e); + 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->rsa_n)); + CHECK(d0_iobuf_write_bignum(conv, ctx->rsa_e)); + CHECK(d0_iobuf_write_bignum(conv, ctx->schnorr_g_to_s)); CHECK(d0_iobuf_close(conv, &sz)); conv = NULL; @@ -994,12 +1046,12 @@ fail: return 0; } -BOOL d0_blind_id_sessionkey_public_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) +D0_BOOL d0_blind_id_sessionkey_public_id(const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen) { - USING(t); USING(other_4_to_t); USING(schnorr_G); + USING(t); USING(other_g_to_t); USING(schnorr_G); // temps: temp0 result - CHECK(d0_bignum_mod_pow(temp0, ctx->other_4_to_t, ctx->t, ctx->schnorr_G)); + CHECK(d0_bignum_mod_pow(temp0, ctx->other_g_to_t, ctx->t, ctx->schnorr_G)); return d0_longhash_destructive(temp0, outbuf, *outbuflen); fail: