d0_blind_id.c

   1 /*
   2 Blind-ID library for user identification using RSA blind signatures
   3 Copyright (C) 2010  Rudolf Polzer
   4
   5 This library is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU Lesser General Public
   7 License as published by the Free Software Foundation; either
   8 version 2.1 of the License, or (at your option) any later version.
   9
  10 This library is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public
  16 License along with this library; if not, write to the Free Software
  17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18 */
  19
  20 #include "d0_blind_id.h"
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include "d0_bignum.h"
  25 #include "sha1.h"
  26
  27 // for zero knowledge, we need multiple instances of schnorr ID scheme... should normally be sequential
  28 // parallel schnorr ID is not provably zero knowledge :(
  29 //   (evil verifier can know all questions in advance, so sequential is disadvantage for him)
  30 // we'll just live with a 1:1048576 chance of cheating, and support reauthenticating
  31
  32 #define SCHNORR_BITS 20
  33 // probability of cheat: 2^(-bits+1)
  34
  35 #define SCHNORR_HASHSIZE 3
  36 // cannot be >= SHA_DIGEST_LENGTH
  37 // *8 must be >= SCHNORR_BITS
  38
  39 #define MSGSIZE 640 // ought to be enough for anyone
  40
  41 struct d0_blind_id_s
  42 {
  43         // signing (Xonotic pub and priv key)
  44         d0_bignum_t *rsa_n, *rsa_e, *rsa_d;
  45
  46         // public data (Schnorr ID)
  47         d0_bignum_t *schnorr_G;
  48
  49         // private data (player ID private key)
  50         d0_bignum_t *schnorr_s;
  51
  52         // public data (player ID public key, this is what the server gets to know)
  53         d0_bignum_t *schnorr_4_to_s;
  54         d0_bignum_t *schnorr_4_to_s_signature;
  55
  56         // temp data
  57         d0_bignum_t *rn; // random number blind signature
  58         d0_bignum_t *r; // random number for schnorr ID
  59         char xnbh[SCHNORR_HASHSIZE]; // init hash
  60         d0_bignum_t *e; // challenge
  61         char msg[MSGSIZE]; // message
  62         size_t msglen; // message length
  63 };
  64
  65 #define CHECK(x) do { if(!(x)) goto fail; } while(0)
  66 #define CHECK_ASSIGN(var, value) do { d0_bignum_t *val; val = value; if(!val) goto fail; var = val; } while(0)
  67
  68 static d0_bignum_t *zero, *one, *four, *temp0, *temp1, *temp2, *temp3, *temp4;
  69
  70 void d0_blind_id_INITIALIZE(void)
  71 {
  72         d0_bignum_INITIALIZE();
  73         CHECK_ASSIGN(zero, d0_bignum_int(zero, 0));
  74         CHECK_ASSIGN(one, d0_bignum_int(one, 1));
  75         CHECK_ASSIGN(four, d0_bignum_int(four, 4));
  76         CHECK_ASSIGN(temp0, d0_bignum_int(temp0, 0));
  77         CHECK_ASSIGN(temp1, d0_bignum_int(temp1, 0));
  78         CHECK_ASSIGN(temp2, d0_bignum_int(temp2, 0));
  79         CHECK_ASSIGN(temp3, d0_bignum_int(temp3, 0));
  80         CHECK_ASSIGN(temp4, d0_bignum_int(temp4, 0));
  81 fail:
  82         ;
  83 }
  84
  85 void d0_blind_id_SHUTDOWN(void)
  86 {
  87         d0_bignum_free(zero);
  88         d0_bignum_free(one);
  89         d0_bignum_free(four);
  90         d0_bignum_free(temp0);
  91         d0_bignum_free(temp1);
  92         d0_bignum_free(temp2);
  93         d0_bignum_free(temp3);
  94         d0_bignum_free(temp4);
  95         d0_bignum_SHUTDOWN();
  96 }
  97
  98 // (G-1)/2
  99 d0_bignum_t *d0_dl_get_order(d0_bignum_t *o, const d0_bignum_t *G)
 100 {
 101         CHECK_ASSIGN(o, d0_bignum_sub(o, G, one));
 102         CHECK(d0_bignum_shl(o, o, -1)); // order o = (G-1)/2
 103         return o;
 104 fail:
 105         return NULL;
 106 }
 107 // 2o+1
 108 d0_bignum_t *d0_dl_get_from_order(d0_bignum_t *G, const d0_bignum_t *o)
 109 {
 110         CHECK_ASSIGN(G, d0_bignum_shl(G, o, 1));
 111         CHECK(d0_bignum_add(G, G, one));
 112         return G;
 113 fail:
 114         return NULL;
 115 }
 116
 117 BOOL d0_dl_generate_key(size_t size, d0_bignum_t *G)
 118 {
 119         // using: temp0
 120         if(size < 16)
 121                 size = 16;
 122         for(;;)
 123         {
 124                 CHECK(d0_bignum_rand_bit_exact(temp0, size-1));
 125                 if(d0_bignum_isprime(temp0, 0) == 0)
 126                         continue;
 127                 CHECK(d0_dl_get_from_order(G, temp0));
 128                 if(d0_bignum_isprime(G, 10) == 0)
 129                         continue;
 130                 if(d0_bignum_isprime(temp0, 10) == 0) // finish the previous test
 131                         continue;
 132                 break;
 133         }
 134         return 1;
 135 fail:
 136         return 0;
 137 }
 138
 139 BOOL d0_rsa_generate_key(size_t size, const d0_bignum_t *e, d0_bignum_t *d, d0_bignum_t *n)
 140 {
 141         // uses temp0 to temp4
 142         int fail = 0;
 143         int gcdfail = 0;
 144         int pb = (size + 1)/2;
 145         int qb = size - pb;
 146         if(pb < 8)
 147                 pb = 8;
 148         if(qb < 8)
 149                 qb = 8;
 150         for (;;)
 151         {
 152                 CHECK(d0_bignum_rand_bit_exact(temp0, pb));
 153                 if(d0_bignum_isprime(temp0, 10) == 0)
 154                         continue;
 155                 CHECK(d0_bignum_sub(temp2, temp0, one));
 156                 CHECK(d0_bignum_gcd(temp4, NULL, NULL, temp2, e));
 157                 if(!d0_bignum_cmp(temp4, one))
 158                         break;
 159                 if(++gcdfail == 3)
 160                         return 0;
 161                 ++gcdfail;
 162         }
 163         gcdfail = 0;
 164         for (;;)
 165         {
 166                 CHECK(d0_bignum_rand_bit_exact(temp1, qb));
 167                 if(!d0_bignum_cmp(temp1, temp0))
 168                 {
 169                         if(++fail == 3)
 170                                 return 0;
 171                 }
 172                 fail = 0;
 173                 if(d0_bignum_isprime(temp1, 10) == 0)
 174                         continue;
 175                 CHECK(d0_bignum_sub(temp3, temp1, one));
 176                 CHECK(d0_bignum_gcd(temp4, NULL, NULL, temp3, e));
 177                 if(!d0_bignum_cmp(temp4, one))
 178                         break;
 179                 if(++gcdfail == 3)
 180                         return 0;
 181                 ++gcdfail;
 182         }
 183
 184         // n = temp0*temp1
 185         CHECK(d0_bignum_mul(n, temp0, temp1));
 186
 187         // d = e^-1 mod (temp0-1)(temp1-1)
 188         CHECK(d0_bignum_mul(temp0, temp2, temp3));
 189         CHECK(d0_bignum_mod_inv(d, e, temp0));
 190         return 1;
 191 fail:
 192         return 0;
 193 }
 194
 195 void d0_blind_id_clear(d0_blind_id_t *ctx)
 196 {
 197         if(ctx->rsa_n) d0_bignum_free(ctx->rsa_n);
 198         if(ctx->rsa_e) d0_bignum_free(ctx->rsa_e);
 199         if(ctx->rsa_d) d0_bignum_free(ctx->rsa_d);
 200         if(ctx->schnorr_G) d0_bignum_free(ctx->schnorr_G);
 201         if(ctx->schnorr_s) d0_bignum_free(ctx->schnorr_s);
 202         if(ctx->schnorr_4_to_s) d0_bignum_free(ctx->schnorr_4_to_s);
 203         if(ctx->schnorr_4_to_s_signature) d0_bignum_free(ctx->schnorr_4_to_s_signature);
 204         if(ctx->rn) d0_bignum_free(ctx->rn);
 205         if(ctx->r) d0_bignum_free(ctx->r);
 206         if(ctx->e) d0_bignum_free(ctx->e);
 207         memset(ctx, 0, sizeof(*ctx));
 208 }
 209
 210 void d0_blind_id_copy(d0_blind_id_t *ctx, const d0_blind_id_t *src)
 211 {
 212         d0_blind_id_clear(ctx);
 213         if(src->rsa_n) ctx->rsa_n = d0_bignum_mov(NULL, src->rsa_n);
 214         if(src->rsa_e) ctx->rsa_e = d0_bignum_mov(NULL, src->rsa_e);
 215         if(src->rsa_d) ctx->rsa_d = d0_bignum_mov(NULL, src->rsa_d);
 216         if(src->schnorr_G) ctx->schnorr_G = d0_bignum_mov(NULL, src->schnorr_G);
 217         if(src->schnorr_s) ctx->schnorr_s = d0_bignum_mov(NULL, src->schnorr_s);
 218         if(src->schnorr_4_to_s) ctx->schnorr_4_to_s = d0_bignum_mov(NULL, ctx->schnorr_G);
 219         if(src->schnorr_4_to_s_signature) ctx->schnorr_4_to_s_signature = d0_bignum_mov(NULL, src->schnorr_4_to_s_signature);
 220         if(src->rn) ctx->rn = d0_bignum_mov(NULL, src->rn);
 221         if(src->r) ctx->r = d0_bignum_mov(NULL, src->r);
 222         if(src->e) ctx->e = d0_bignum_mov(NULL, src->e);
 223         // TODO xnbh, msg, msglen?
 224 }
 225
 226 WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_keys(d0_blind_id_t *ctx, int k)
 227 {
 228         d0_blind_id_clear(ctx);
 229         CHECK_ASSIGN(ctx->schnorr_G, d0_bignum_new());
 230         CHECK(d0_dl_generate_key(k, ctx->schnorr_G));
 231         CHECK_ASSIGN(ctx->rsa_e, d0_bignum_int(NULL, 65537));
 232         CHECK_ASSIGN(ctx->rsa_d, d0_bignum_new());
 233         CHECK_ASSIGN(ctx->rsa_n, d0_bignum_new());
 234         CHECK(d0_rsa_generate_key(k+1, ctx->rsa_e, ctx->rsa_d, ctx->rsa_n)); // must fit G for sure
 235         return 1;
 236 fail:
 237         return 0;
 238 }
 239
 240 WARN_UNUSED_RESULT BOOL d0_blind_id_read_private_keys(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen)
 241 {
 242         d0_iobuf_t *in = d0_iobuf_open_read(inbuf, inbuflen);
 243         d0_blind_id_clear(ctx);
 244         CHECK_ASSIGN(ctx->schnorr_G, d0_iobuf_read_bignum(in, NULL));
 245         CHECK_ASSIGN(ctx->rsa_n, d0_iobuf_read_bignum(in, NULL));
 246         CHECK_ASSIGN(ctx->rsa_e, d0_iobuf_read_bignum(in, NULL));
 247         CHECK_ASSIGN(ctx->rsa_d, d0_iobuf_read_bignum(in, NULL));
 248         return d0_iobuf_close(in, NULL);
 249
 250 fail:
 251         d0_iobuf_close(in, NULL);
 252         return 0;
 253 }
 254
 255 WARN_UNUSED_RESULT BOOL d0_blind_id_read_public_keys(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen)
 256 {
 257         d0_iobuf_t *in = d0_iobuf_open_read(inbuf, inbuflen);
 258         d0_blind_id_clear(ctx);
 259         CHECK_ASSIGN(ctx->schnorr_G, d0_iobuf_read_bignum(in, NULL));
 260         CHECK_ASSIGN(ctx->rsa_n, d0_iobuf_read_bignum(in, NULL));
 261         CHECK_ASSIGN(ctx->rsa_e, d0_iobuf_read_bignum(in, NULL));
 262         return d0_iobuf_close(in, NULL);
 263
 264 fail:
 265         d0_iobuf_close(in, NULL);
 266         return 0;
 267 }
 268
 269 #define USING(x) if(!(ctx->x)) return 0
 270 #define REPLACING(x)
 271
 272 WARN_UNUSED_RESULT BOOL d0_blind_id_write_private_keys(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen)
 273 {
 274         d0_iobuf_t *out;
 275
 276         USING(rsa_n); USING(rsa_e); USING(rsa_d);
 277
 278         out = d0_iobuf_open_write(outbuf, *outbuflen);
 279         CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_G));
 280         CHECK(d0_iobuf_write_bignum(out, ctx->rsa_n));
 281         CHECK(d0_iobuf_write_bignum(out, ctx->rsa_e));
 282         CHECK(d0_iobuf_write_bignum(out, ctx->rsa_d));
 283         return d0_iobuf_close(out, outbuflen);
 284
 285 fail:
 286         d0_iobuf_close(out, outbuflen);
 287         return 0;
 288 }
 289
 290 WARN_UNUSED_RESULT BOOL d0_blind_id_write_public_keys(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen)
 291 {
 292         d0_iobuf_t *out;
 293
 294         USING(rsa_n); USING(rsa_e); USING(rsa_d);
 295
 296         out = d0_iobuf_open_write(outbuf, *outbuflen);
 297         CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_G));
 298         CHECK(d0_iobuf_write_bignum(out, ctx->rsa_n));
 299         CHECK(d0_iobuf_write_bignum(out, ctx->rsa_e));
 300         return d0_iobuf_close(out, outbuflen);
 301
 302 fail:
 303         if(!d0_iobuf_close(out, outbuflen))
 304                 return 0;
 305         return 0;
 306 }
 307
 308 WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_id_start(d0_blind_id_t *ctx)
 309 {
 310         // temps: temp0 order
 311         USING(schnorr_G);
 312         REPLACING(schnorr_s); REPLACING(schnorr_4_to_s);
 313
 314         CHECK(d0_dl_get_order(temp0, ctx->schnorr_G));
 315         CHECK_ASSIGN(ctx->schnorr_s, d0_bignum_rand_range(ctx->schnorr_s, zero, temp0));
 316         CHECK_ASSIGN(ctx->schnorr_4_to_s, d0_bignum_mod_pow(ctx->schnorr_4_to_s, four, ctx->schnorr_s, ctx->schnorr_G));
 317         return 1;
 318
 319 fail:
 320         return 0;
 321 }
 322
 323 WARN_UNUSED_RESULT BOOL d0_blind_id_generate_private_id_request(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen)
 324 {
 325         d0_iobuf_t *out;
 326
 327         // temps: temp0 temp1
 328         USING(rsa_n); USING(rsa_e); USING(schnorr_4_to_s);
 329         REPLACING(rn);
 330
 331         out = d0_iobuf_open_write(outbuf, *outbuflen);
 332
 333         CHECK_ASSIGN(ctx->rn, d0_bignum_rand_bit_atmost(ctx->rn, d0_bignum_size(ctx->rsa_n)));
 334         CHECK(d0_bignum_mod_pow(temp0, ctx->rn, ctx->rsa_e, ctx->rsa_n));
 335         CHECK(d0_bignum_mod_mul(temp1, ctx->schnorr_4_to_s, temp0, ctx->rsa_n));
 336         CHECK(d0_iobuf_write_bignum(out, temp1));
 337         return d0_iobuf_close(out, outbuflen);
 338
 339 fail:
 340         d0_iobuf_close(out, outbuflen);
 341         return 0;
 342 }
 343
 344 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)
 345 {
 346         d0_iobuf_t *in;
 347         d0_iobuf_t *out;
 348
 349         // temps: temp0 temp1
 350         USING(rsa_d); USING(rsa_n);
 351
 352         in = d0_iobuf_open_read(inbuf, inbuflen);
 353         out = d0_iobuf_open_write(outbuf, *outbuflen);
 354
 355         CHECK(d0_iobuf_read_bignum(in, temp0));
 356         CHECK(d0_bignum_mod_pow(temp1, temp0, ctx->rsa_d, ctx->rsa_n));
 357         CHECK(d0_iobuf_write_bignum(out, temp1));
 358
 359         d0_iobuf_close(in, NULL);
 360         return d0_iobuf_close(out, outbuflen);
 361
 362 fail:
 363         d0_iobuf_close(in, NULL);
 364         d0_iobuf_close(out, outbuflen);
 365         return 0;
 366 }
 367
 368 WARN_UNUSED_RESULT BOOL d0_blind_id_finish_private_id_request(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen)
 369 {
 370         d0_iobuf_t *in;
 371
 372         // temps: temp0 temp1
 373         USING(rn); USING(rsa_n);
 374         REPLACING(schnorr_4_to_s_signature);
 375
 376         in = d0_iobuf_open_read(inbuf, inbuflen);
 377
 378         CHECK(d0_iobuf_read_bignum(in, temp0));
 379         CHECK(d0_bignum_mod_inv(temp1, ctx->rn, ctx->rsa_n));
 380         CHECK_ASSIGN(ctx->schnorr_4_to_s_signature, d0_bignum_mod_mul(ctx->schnorr_4_to_s_signature, temp0, temp1, ctx->rsa_n));
 381
 382         return d0_iobuf_close(in, NULL);
 383
 384 fail:
 385         d0_iobuf_close(in, NULL);
 386         return 0;
 387 }
 388
 389 WARN_UNUSED_RESULT BOOL d0_blind_id_read_private_id(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen)
 390 {
 391         d0_iobuf_t *in;
 392
 393         REPLACING(schnorr_s); REPLACING(schnorr_4_to_s); REPLACING(schnorr_4_to_s_signature);
 394
 395         in = d0_iobuf_open_read(inbuf, inbuflen);
 396
 397         CHECK_ASSIGN(ctx->schnorr_s, d0_iobuf_read_bignum(in, ctx->schnorr_s));
 398         CHECK_ASSIGN(ctx->schnorr_4_to_s, d0_iobuf_read_bignum(in, ctx->schnorr_4_to_s));
 399         CHECK_ASSIGN(ctx->schnorr_4_to_s_signature, d0_iobuf_read_bignum(in, ctx->schnorr_4_to_s_signature));
 400
 401         return d0_iobuf_close(in, NULL);
 402
 403 fail:
 404         d0_iobuf_close(in, NULL);
 405         return 0;
 406 }
 407
 408 WARN_UNUSED_RESULT BOOL d0_blind_id_read_public_id(d0_blind_id_t *ctx, const char *inbuf, size_t inbuflen)
 409 {
 410         d0_iobuf_t *in;
 411
 412         REPLACING(schnorr_4_to_s); REPLACING(schnorr_4_to_s_signature);
 413
 414         in = d0_iobuf_open_read(inbuf, inbuflen);
 415
 416         CHECK_ASSIGN(ctx->schnorr_4_to_s, d0_iobuf_read_bignum(in, ctx->schnorr_4_to_s));
 417         CHECK_ASSIGN(ctx->schnorr_4_to_s_signature, d0_iobuf_read_bignum(in, ctx->schnorr_4_to_s_signature));
 418
 419         return d0_iobuf_close(in, NULL);
 420
 421 fail:
 422         d0_iobuf_close(in, NULL);
 423         return 0;
 424 }
 425
 426 WARN_UNUSED_RESULT BOOL d0_blind_id_write_private_id(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen)
 427 {
 428         d0_iobuf_t *out;
 429
 430         USING(schnorr_s); USING(schnorr_4_to_s); USING(schnorr_4_to_s_signature);
 431
 432         out = d0_iobuf_open_write(outbuf, *outbuflen);
 433
 434         CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_s));
 435         CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_4_to_s));
 436         CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_4_to_s_signature));
 437
 438         return d0_iobuf_close(out, outbuflen);
 439
 440 fail:
 441         d0_iobuf_close(out, outbuflen);
 442         return 0;
 443 }
 444
 445 WARN_UNUSED_RESULT BOOL d0_blind_id_write_public_id(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen)
 446 {
 447         d0_iobuf_t *out;
 448
 449         USING(schnorr_4_to_s); USING(schnorr_4_to_s_signature);
 450
 451         out = d0_iobuf_open_write(outbuf, *outbuflen);
 452
 453         CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_4_to_s));
 454         CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_4_to_s_signature));
 455
 456         return d0_iobuf_close(out, outbuflen);
 457
 458 fail:
 459         d0_iobuf_close(out, outbuflen);
 460         return 0;
 461 }
 462
 463 WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_start(d0_blind_id_t *ctx, int is_first, char *msg, size_t msglen, char *outbuf, size_t *outbuflen)
 464 // start =
 465 //   first run: send 4^s, 4^s signature
 466 //   1. get random r, send HASH(4^r)
 467 {
 468         d0_iobuf_t *out;
 469         unsigned char convbuf[1024];
 470         d0_iobuf_t *conv;
 471         size_t sz;
 472
 473         if(is_first)
 474         {
 475                 USING(schnorr_4_to_s); USING(schnorr_4_to_s_signature);
 476         }
 477         USING(schnorr_G);
 478         REPLACING(r);
 479
 480         out = d0_iobuf_open_write(outbuf, *outbuflen);
 481
 482         if(is_first)
 483         {
 484                 // send ID
 485                 CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_4_to_s));
 486                 CHECK(d0_iobuf_write_bignum(out, ctx->schnorr_4_to_s_signature));
 487         }
 488
 489         // start schnorr ID scheme
 490         // generate random number r; x = g^r; send hash of x, remember r, forget x
 491         CHECK(d0_dl_get_order(temp0, ctx->schnorr_G));
 492         CHECK_ASSIGN(ctx->r, d0_bignum_rand_range(ctx->r, zero, temp0));
 493         CHECK(d0_bignum_mod_pow(temp0, four, ctx->r, ctx->schnorr_G));
 494
 495         // hash it, hash it, everybody hash it
 496         conv = d0_iobuf_open_write(convbuf, sizeof(convbuf));
 497         CHECK(d0_iobuf_write_bignum(conv, temp0));
 498         CHECK(d0_iobuf_write_packet(conv, msg, msglen));
 499         CHECK(d0_iobuf_write_bignum(conv, temp0));
 500         d0_iobuf_close(conv, &sz);
 501         conv = NULL;
 502         CHECK(d0_iobuf_write_raw(out, sha(convbuf, sz), SCHNORR_HASHSIZE) == SCHNORR_HASHSIZE);
 503         CHECK(d0_iobuf_write_packet(out, msg, msglen));
 504
 505         return d0_iobuf_close(out, outbuflen);
 506
 507 fail:
 508         d0_iobuf_close(out, outbuflen);
 509         return 0;
 510 }
 511
 512 WARN_UNUSED_RESULT BOOL d0_blind_id_authenticate_with_private_id_challenge(d0_blind_id_t *ctx, int is_first, const char *inbuf, size_t inbuflen, char *outbuf, size_t *outbuflen)
 513 //   first run: get 4^s, 4^s signature
 514 //   1. check sig
 515 //   2. save HASH(4^r)
 516 //   3. send challenge e of SCHNORR_BITS
 517 {
 518         d0_iobuf_t *in;
 519         d0_iobuf_t *out;
 520
 521         if(is_first)
 522         {
 523                 REPLACING(schnorr_4_to_s); REPLACING(k); REPLACING(schnorr_4_to_s_signature);
 524                 USING(schnorr_G); USING(rsa_n);
 525         }
 526         else
 527         {
 528                 USING(schnorr_4_to_s_signature); USING(schnorr_4_to_s);
 529         }
 530         USING(rsa_e); USING(rsa_n);
 531         REPLACING(e); REPLACING(msg); REPLACING(msglen);
 532
 533         in = d0_iobuf_open_read(inbuf, inbuflen);
 534         out = d0_iobuf_open_write(outbuf, *outbuflen);
 535
 536         if(is_first)
 537         {
 538                 CHECK_ASSIGN(ctx->schnorr_4_to_s, d0_iobuf_read_bignum(in, NULL));
 539                 CHECK(d0_bignum_cmp(ctx->schnorr_4_to_s, zero) >= 0);
 540                 CHECK(d0_bignum_cmp(ctx->schnorr_4_to_s, ctx->schnorr_G) < 0);
 541                 CHECK_ASSIGN(ctx->schnorr_4_to_s_signature, d0_iobuf_read_bignum(in, ctx->schnorr_4_to_s_signature));
 542                 CHECK(d0_bignum_cmp(ctx->schnorr_4_to_s_signature, zero) >= 0);
 543                 CHECK(d0_bignum_cmp(ctx->schnorr_4_to_s_signature, ctx->rsa_n) < 0);
 544         }
 545
 546         // check signature of key (t = k^d, so, t^e = k)
 547         CHECK(d0_bignum_mod_pow(temp0, ctx->schnorr_4_to_s_signature, ctx->rsa_e, ctx->rsa_n));
 548         if(d0_bignum_cmp(temp0, ctx->schnorr_4_to_s))
 549         {
 550                 // FAIL (not signed by Xonotic)
 551                 goto fail;
 552                 // TODO: accept the key anyway, but mark as failed signature!
 553         }
 554
 555         CHECK(d0_iobuf_read_raw(in, ctx->xnbh, SCHNORR_HASHSIZE));
 556         ctx->msglen = MSGSIZE;
 557         CHECK(d0_iobuf_read_packet(in, ctx->msg, &ctx->msglen));
 558
 559         // send challenge
 560         CHECK_ASSIGN(ctx->e, d0_bignum_rand_bit_atmost(ctx->e, SCHNORR_BITS));
 561
 562         CHECK(d0_iobuf_write_bignum(out, ctx->e));
 563
 564         d0_iobuf_close(in, NULL);
 565         return d0_iobuf_close(out, outbuflen);
 566
 567 fail:
 568         d0_iobuf_close(in, NULL);
 569         d0_iobuf_close(out, outbuflen);
 570         return 0;
 571 }
 572
 573 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)
 574 //   1. read challenge e of SCHNORR_BITS
 575 //   2. reply with r + s * e mod order
 576 {
 577         d0_iobuf_t *in;
 578         d0_iobuf_t *out;
 579
 580         // temps: 0 order, 1 prod, 2 y, 3 e
 581         USING(schnorr_G); USING(schnorr_s); USING(r);
 582
 583         in = d0_iobuf_open_read(inbuf, inbuflen);
 584         out = d0_iobuf_open_write(outbuf, *outbuflen);
 585
 586         CHECK(d0_iobuf_read_bignum(in, temp3));
 587         // TODO check if >= 2^SCHNORR_BITS or < 0, if yes, then fail (needed for zero knowledge)
 588         CHECK(d0_bignum_cmp(temp3, zero) >= 0);
 589         CHECK(d0_bignum_size(temp3) <= SCHNORR_BITS);
 590
 591         // send response for schnorr ID scheme
 592         // i.e. r + ctx->schnorr_s * temp3
 593         CHECK(d0_dl_get_order(temp0, ctx->schnorr_G));
 594         CHECK(d0_bignum_mod_mul(temp1, ctx->schnorr_s, temp3, temp0));
 595         CHECK(d0_bignum_mod_add(temp2, temp1, ctx->r, temp0));
 596         CHECK(d0_iobuf_write_bignum(out, temp2));
 597
 598         d0_iobuf_close(in, NULL);
 599         return d0_iobuf_close(out, outbuflen);
 600
 601 fail:
 602         d0_iobuf_close(in, NULL);
 603         d0_iobuf_close(out, outbuflen);
 604         return 0;
 605 }
 606
 607 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, ssize_t *msglen)
 608 //   1. read y = r + s * e mod order
 609 //   2. verify: g^y (g^s)^-e = g^(r+s*e-s*e) = g^r
 610 //      (check using H(g^r) which we know)
 611 {
 612         d0_iobuf_t *in;
 613         unsigned char convbuf[1024];
 614         d0_iobuf_t *conv;
 615         size_t sz;
 616
 617         // temps: 0 y 1 order
 618         USING(e); USING(schnorr_G);
 619
 620         in = d0_iobuf_open_read(inbuf, inbuflen);
 621
 622         *msglen = -1;
 623         CHECK(d0_dl_get_order(temp1, ctx->schnorr_G));
 624         CHECK(d0_iobuf_read_bignum(in, temp0));
 625         CHECK(d0_bignum_cmp(temp0, zero) >= 0);
 626         CHECK(d0_bignum_cmp(temp0, temp1) < 0);
 627
 628         // verify schnorr ID scheme
 629         // we need 4^temp0 (g^s)^-e
 630         CHECK(d0_bignum_neg(temp1, ctx->e));
 631         CHECK(d0_bignum_mod_pow(temp2, ctx->schnorr_4_to_s, temp1, ctx->schnorr_G));
 632         CHECK(d0_bignum_mod_pow(temp1, four, temp0, ctx->schnorr_G));
 633         CHECK(d0_bignum_mod_mul(temp3, temp1, temp2, ctx->schnorr_G));
 634         // hash must be equal to xnbh
 635
 636         // hash it, hash it, everybody hash it
 637         conv = d0_iobuf_open_write(convbuf, sizeof(convbuf));
 638         CHECK(d0_iobuf_write_bignum(conv, temp3));
 639         CHECK(d0_iobuf_write_packet(conv, ctx->msg, ctx->msglen));
 640         CHECK(d0_iobuf_write_bignum(conv, temp3));
 641         d0_iobuf_close(conv, &sz);
 642         conv = NULL;
 643         if(memcmp(sha(convbuf, sz), ctx->xnbh, SCHNORR_HASHSIZE))
 644         {
 645                 // FAIL (not owned by player)
 646                 goto fail;
 647         }
 648
 649         if(ctx->msglen <= (size_t) *msglen)
 650                 memcpy(msg, ctx->msg, ctx->msglen);
 651         else
 652                 memcpy(msg, ctx->msg, *msglen);
 653         *msglen = ctx->msglen;
 654
 655         d0_iobuf_close(in, NULL);
 656         return 1;
 657
 658 fail:
 659         d0_iobuf_close(in, NULL);
 660         return 0;
 661 }
 662
 663 WARN_UNUSED_RESULT BOOL d0_blind_id_fingerprint64_public_id(d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen)
 664 {
 665         d0_iobuf_t *out;
 666         d0_iobuf_t *conv;
 667         static unsigned char convbuf[1024];
 668         size_t sz, n;
 669
 670         USING(schnorr_4_to_s);
 671
 672         out = d0_iobuf_open_write(outbuf, *outbuflen);
 673         conv = d0_iobuf_open_write(convbuf, sizeof(convbuf));
 674
 675         CHECK(d0_iobuf_write_bignum(conv, ctx->schnorr_4_to_s));
 676         CHECK(d0_iobuf_close(conv, &sz));
 677         conv = NULL;
 678
 679         n = (*outbuflen / 4) * 3;
 680         if(n > SHA_DIGESTSIZE)
 681                 n = SHA_DIGESTSIZE;
 682         if(d0_iobuf_write_raw(out, sha(convbuf, sz), n) != n)
 683                 goto fail;
 684         if(!d0_iobuf_conv_base64_out(out))
 685                 goto fail;
 686
 687         return d0_iobuf_close(out, outbuflen);
 688
 689 fail:
 690         if(conv)
 691                 if(!d0_iobuf_close(conv, &sz)) { }
 692         if(!d0_iobuf_close(out, outbuflen))
 693                 return 0;
 694         return 0;
 695 }
 696
 697 d0_blind_id_t *d0_blind_id_new(void)
 698 {
 699         d0_blind_id_t *b = d0_malloc(sizeof(d0_blind_id_t));
 700         memset(b, 0, sizeof(*b));
 701         return b;
 702 }
 703
 704 void d0_blind_id_free(d0_blind_id_t *a)
 705 {
 706         d0_blind_id_clear(a);
 707         d0_free(a);
 708 }