3 #include <d0_blind_id/d0_blind_id.h>
13 #include <sys/types.h>
16 // BEGIN stuff shared with crypto.c
17 #define FOURCC_D0PK (('d' << 0) | ('0' << 8) | ('p' << 16) | ('k' << 24))
18 #define FOURCC_D0SK (('d' << 0) | ('0' << 8) | ('s' << 16) | ('k' << 24))
19 #define FOURCC_D0PI (('d' << 0) | ('0' << 8) | ('p' << 16) | ('i' << 24))
20 #define FOURCC_D0SI (('d' << 0) | ('0' << 8) | ('s' << 16) | ('i' << 24))
21 #define FOURCC_D0IQ (('d' << 0) | ('0' << 8) | ('i' << 16) | ('q' << 24))
22 #define FOURCC_D0IR (('d' << 0) | ('0' << 8) | ('i' << 16) | ('r' << 24))
23 #define FOURCC_D0ER (('d' << 0) | ('0' << 8) | ('e' << 16) | ('r' << 24))
24 #define FOURCC_D0IC (('d' << 0) | ('0' << 8) | ('i' << 16) | ('c' << 24))
26 static unsigned long Crypto_LittleLong(const char *data)
29 ((unsigned char) data[0]) |
30 (((unsigned char) data[1]) << 8) |
31 (((unsigned char) data[2]) << 16) |
32 (((unsigned char) data[3]) << 24);
35 static void Crypto_UnLittleLong(char *data, unsigned long l)
38 data[1] = (l >> 8) & 0xFF;
39 data[2] = (l >> 16) & 0xFF;
40 data[3] = (l >> 24) & 0xFF;
43 static size_t Crypto_ParsePack(const char *buf, size_t len, unsigned long header, const char **lumps, size_t *lumpsize, size_t nlumps)
52 if(Crypto_LittleLong(buf) != header)
56 for(i = 0; i < nlumps; ++i)
60 lumpsize[i] = Crypto_LittleLong(&buf[pos]);
62 if(pos + lumpsize[i] > len)
70 static size_t Crypto_UnParsePack(char *buf, size_t len, unsigned long header, const char *const *lumps, const size_t *lumpsize, size_t nlumps)
79 Crypto_UnLittleLong(buf, header);
82 for(i = 0; i < nlumps; ++i)
84 if(pos + 4 + lumpsize[i] > len)
86 Crypto_UnLittleLong(&buf[pos], lumpsize[i]);
88 memcpy(&buf[pos], lumps[i], lumpsize[i]);
94 void file2buf(const char *fn, char **data, size_t *datasize)
107 *data = realloc(*data, *datasize += 8192);
113 dn = fread(*data + n, 1, *datasize - n, f);
122 int buf2file(const char *fn, const char *data, size_t n)
128 n = fwrite(data, n, 1, f);
134 void file2lumps(const char *fn, unsigned long header, const char **lumps, size_t *lumpsize, size_t nlumps)
138 file2buf(fn, &buf, &n);
141 fprintf(stderr, "could not open %s\n", fn);
144 if(!Crypto_ParsePack(buf, n, header, lumps, lumpsize, nlumps))
146 fprintf(stderr, "could not parse %s as %c%c%c%c (%d lumps expected)\n", fn, (int) header & 0xFF, (int) (header >> 8) & 0xFF, (int) (header >> 16) & 0xFF, (int) (header >> 24) & 0xFF, (int) nlumps);
154 void lumps2file(const char *fn, unsigned long header, const char *const *lumps, size_t *lumpsize, size_t nlumps, D0_BOOL private)
159 umask(umask_save | 0077);
162 if(!(n = Crypto_UnParsePack(buf, sizeof(buf), header, lumps, lumpsize, nlumps)))
164 fprintf(stderr, "could not unparse for %s\n", fn);
167 if(!buf2file(fn, buf, n))
169 fprintf(stderr, "could not write %s\n", fn);
174 void USAGE(const char *me)
177 "%s [-F] [-b bits] [-n progress-denominator] [-x prefix] [-X infix] [-C] -o private.d0sk\n"
178 "%s -P private.d0sk -o public.d0pk\n"
179 "%s [-n progress-denominator] [-x prefix] [-X infix] [-C] -p public.d0pk -o idkey-unsigned.d0si\n"
180 "%s -p public.d0pk -I idkey-unsigned.d0si -o request.d0iq -O camouflage.d0ic\n"
181 "%s -P private.d0sk -j request.d0iq -o response.d0ir\n"
182 "%s -p public.d0pk -I idkey-unsigned.d0si -c camouflage.d0ic -J response.d0ir -o idkey.d0si\n"
183 "%s -P private.d0sk -I idkey-unsigned.d0si -o idkey.d0si\n"
184 "%s -I idkey.d0si -o id.d0pi\n"
185 "%s -p public.d0pk\n"
186 "%s -P private.d0sk\n"
187 "%s -p public.d0pk -i id.d0pi\n"
188 "%s -p public.d0pk -I idkey.d0si\n"
189 "%s -0 -p public.d0pk -I idkey.d0si\n"
190 "%s -0 -p public.d0pk\n"
191 "%s -p public.d0pk -I idkey.d0si -f file-to-sign.dat -o file-signed.dat\n"
192 "%s -p public.d0pk -f file-signed.dat -o file-content.dat\n"
193 "%s -p public.d0pk -f file-signed.dat -o file-content.dat -O idkey.d0pi\n",
194 me, me, me, me, me, me, me, me, me, me, me, me, me, me, me, me, me
198 unsigned int seconds;
199 unsigned int generated;
200 unsigned int ntasks = 1;
201 double generated_offset;
204 void print_generated(int signo)
208 if(generated >= 1000000000)
210 generated_offset += generated;
213 fprintf(stderr, "Generated: %.0f (about %.0f, %.1f/s, about %.2f hours for %.0f)\n",
214 // nasty and dishonest hack:
215 // we are adjusting the values "back", so the total count is
216 // divided by guessfactor (as the check function is called
217 // guessfactor as often as it would be if no fastreject were
219 // so the values indicate the relative speed of fastreject vs
221 (generated + generated_offset) / guessfactor,
222 (generated + generated_offset) * ntasks / guessfactor,
223 (generated + generated_offset) * ntasks / (guessfactor * seconds),
224 guesscount * ((guessfactor * seconds) / (generated + generated_offset) / ntasks) / 3600.0,
229 #define CHECK(x) if(!(x)) { fprintf(stderr, "error exit: error returned by %s\n", #x); exit(2); }
231 const char *prefix = NULL, *infix = NULL;
232 size_t prefixlen = 0;
234 typedef D0_BOOL (*fingerprint_func) (const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen);
235 D0_BOOL fastreject(const d0_blind_id_t *ctx, void *pass)
237 static char fp64[513]; size_t fp64size = 512;
238 CHECK(((fingerprint_func) pass)(ctx, fp64, &fp64size));
243 if(strncasecmp(fp64, prefix, prefixlen))
248 if(!strcasestr(fp64, infix))
255 if(memcmp(fp64, prefix, prefixlen))
260 if(!strstr(fp64, infix))
267 int main(int argc, char **argv)
271 const char *lumps[2];
272 char *databuf_in; size_t databufsize_in;
273 char *databuf_out; size_t databufsize_out;
274 char lumps_w0[65536];
275 char lumps_w1[65536];
276 const char *pubkeyfile = NULL, *privkeyfile = NULL, *pubidfile = NULL, *prividfile = NULL, *idreqfile = NULL, *idresfile = NULL, *outfile = NULL, *outfile2 = NULL, *camouflagefile = NULL, *datafile = NULL;
277 char fp64[513]; size_t fp64size = 512;
281 D0_BOOL do_fastreject = 1;
283 if(!d0_blind_id_INITIALIZE())
285 fprintf(stderr, "could not initialize\n");
289 umask_save = umask(0022);
291 ctx = d0_blind_id_new();
292 while((opt = getopt(argc, argv, "f:p:P:i:I:j:J:o:O:c:b:x:X:y:Fn:C0")) != -1)
300 ntasks = atoi(optarg);
305 case 'p': // d0pk = <pubkey> <modulus>
309 case 'P': // d0sk = <privkey> <modulus>
310 privkeyfile = optarg;
313 case 'i': // d0pi = <pubid>
317 case 'I': // d0si = <privid>
321 case 'j': // d0iq = <req>
325 case 'J': // d0ir = <resp>
338 camouflagefile = optarg;
343 prefixlen = strlen(prefix);
365 // fastreject is a slight slowdown when rejecting nothing at all
366 if(!infix && !prefixlen)
369 guesscount = pow(64.0, prefixlen);
371 guesscount /= (1 - pow(1 - pow(1/64.0, strlen(infix)), 44 - prefixlen - strlen(infix)));
372 // 44 chars; prefix is assumed to not match the infix (although it theoretically could)
373 // 43'th char however is always '=' and does not count
377 for(i = 0; infix[i]; ++i)
378 if(toupper(infix[i]) != tolower(infix[i]))
380 for(i = 0; i < (int)prefixlen; ++i)
381 if(toupper(prefix[i]) != tolower(prefix[i]))
387 // fastreject: reject function gets called about log(2^bits) times more often
388 guessfactor = bits * log(2) / 2;
389 // so guess function gets called guesscount * guessfactor times, and it tests as many valid keys as guesscount
394 file2lumps(pubkeyfile, FOURCC_D0PK, lumps, lumpsize, 2);
395 if(!d0_blind_id_read_public_key(ctx, lumps[0], lumpsize[0]))
397 fprintf(stderr, "could not decode public key\n");
400 if(!d0_blind_id_read_private_id_modulus(ctx, lumps[1], lumpsize[1]))
402 fprintf(stderr, "could not decode modulus\n");
408 file2lumps(privkeyfile, FOURCC_D0SK, lumps, lumpsize, 2);
409 if(!d0_blind_id_read_private_key(ctx, lumps[0], lumpsize[0]))
411 fprintf(stderr, "could not decode private key\n");
414 if(!d0_blind_id_read_private_id_modulus(ctx, lumps[1], lumpsize[1]))
416 fprintf(stderr, "could not decode modulus\n");
423 file2lumps(pubidfile, FOURCC_D0PI, lumps, lumpsize, 1);
424 if(!d0_blind_id_read_public_id(ctx, lumps[0], lumpsize[0]))
426 fprintf(stderr, "could not decode public ID\n");
432 file2lumps(prividfile, FOURCC_D0SI, lumps, lumpsize, 1);
433 if(!d0_blind_id_read_private_id(ctx, lumps[0], lumpsize[0]))
435 fprintf(stderr, "could not decode private ID\n");
442 file2lumps(idreqfile, FOURCC_D0IQ, lumps, lumpsize, 1);
443 lumpsize[1] = sizeof(lumps_w1);
445 if(!d0_blind_id_answer_private_id_request(ctx, lumps[0], lumpsize[0], lumps_w1, &lumpsize[1]))
447 fprintf(stderr, "could not answer private ID request\n");
451 else if((mask & 0x120) == 0x120)
453 file2lumps(camouflagefile, FOURCC_D0IC, lumps, lumpsize, 1);
454 if(!d0_blind_id_read_private_id_request_camouflage(ctx, lumps[0], lumpsize[0]))
456 fprintf(stderr, "could not decode camouflage\n");
460 file2lumps(idresfile, FOURCC_D0IR, lumps, lumpsize, 1);
461 if(!d0_blind_id_finish_private_id_request(ctx, lumps[0], lumpsize[0]))
463 fprintf(stderr, "could not finish private ID request\n");
470 file2buf(datafile, &databuf_in, &databufsize_in);
473 fprintf(stderr, "could not decode private ID\n");
480 // modes of operation:
482 // nothing -> private key file (incl modulus), print fingerprint
484 generated_offset = 0;
486 signal(SIGALRM, print_generated);
490 CHECK(d0_blind_id_generate_private_key_fastreject(ctx, bits, fastreject, d0_blind_id_fingerprint64_public_key));
494 guessfactor = 1; // no fastreject here
497 CHECK(d0_blind_id_generate_private_key(ctx, bits));
499 while(fastreject(ctx, d0_blind_id_fingerprint64_public_key));
502 signal(SIGALRM, NULL);
503 CHECK(d0_blind_id_generate_private_id_modulus(ctx));
505 lumpsize[0] = sizeof(lumps_w0);
507 lumpsize[1] = sizeof(lumps_w1);
508 CHECK(d0_blind_id_write_private_key(ctx, lumps_w0, &lumpsize[0]));
509 CHECK(d0_blind_id_write_private_id_modulus(ctx, lumps_w1, &lumpsize[1]));
510 lumps2file(outfile, FOURCC_D0SK, lumps, lumpsize, 2, 1);
513 // private key file -> public key file (incl modulus)
515 lumpsize[0] = sizeof(lumps_w0);
517 lumpsize[1] = sizeof(lumps_w1);
518 CHECK(d0_blind_id_write_public_key(ctx, lumps_w0, &lumpsize[0]));
519 CHECK(d0_blind_id_write_private_id_modulus(ctx, lumps_w1, &lumpsize[1]));
520 lumps2file(outfile, FOURCC_D0PK, lumps, lumpsize, 2, 0);
523 // public key file -> unsigned private ID file
525 generated_offset = 0;
527 signal(SIGALRM, print_generated);
529 guessfactor = 1; // no fastreject here
532 CHECK(d0_blind_id_generate_private_id_start(ctx));
534 while(fastreject(ctx, d0_blind_id_fingerprint64_public_id));
538 lumpsize[0] = sizeof(lumps_w0);
539 CHECK(d0_blind_id_write_private_id(ctx, lumps_w0, &lumpsize[0]));
540 lumps2file(outfile, FOURCC_D0SI, lumps, lumpsize, 1, 1);
543 // public key file, unsigned private ID file -> ID request file and camouflage file
545 lumpsize[0] = sizeof(lumps_w0);
546 CHECK(d0_blind_id_generate_private_id_request(ctx, lumps_w0, &lumpsize[0]));
547 lumps2file(outfile, FOURCC_D0IQ, lumps, lumpsize, 1, 0);
548 lumpsize[0] = sizeof(lumps_w0);
549 CHECK(d0_blind_id_write_private_id_request_camouflage(ctx, lumps_w0, &lumpsize[0]));
550 lumps2file(outfile2, FOURCC_D0IC, lumps, lumpsize, 1, 1);
553 // private key file, ID request file -> ID response file
554 lumps2file(outfile, FOURCC_D0IR, lumps+1, lumpsize+1, 1, 0);
557 // public key file, ID response file, private ID file -> signed private ID file
559 lumpsize[0] = sizeof(lumps_w0);
560 CHECK(d0_blind_id_write_private_id(ctx, lumps_w0, &lumpsize[0]));
561 lumps2file(outfile, FOURCC_D0SI, lumps, lumpsize, 1, 1);
564 // private key file, private ID file -> signed private ID file
566 char buf[65536]; size_t bufsize;
567 char buf2[65536]; size_t buf2size;
569 d0_blind_id_t *ctx2 = d0_blind_id_new();
570 CHECK(d0_blind_id_copy(ctx2, ctx));
571 bufsize = sizeof(buf);
572 CHECK(d0_blind_id_authenticate_with_private_id_start(ctx, 1, 1, "hello world", 11, buf, &bufsize));
573 buf2size = sizeof(buf2);
574 CHECK(d0_blind_id_authenticate_with_private_id_challenge(ctx2, 1, 1, buf, bufsize, buf2, &buf2size, &status));
575 bufsize = sizeof(buf);
576 CHECK(d0_blind_id_authenticate_with_private_id_response(ctx, buf2, buf2size, buf, &bufsize));
577 buf2size = sizeof(buf2);
578 CHECK(d0_blind_id_authenticate_with_private_id_verify(ctx2, buf, bufsize, buf2, &buf2size, &status));
580 CHECK(d0_blind_id_authenticate_with_private_id_generate_missing_signature(ctx2));
582 lumpsize[0] = sizeof(lumps_w0);
583 CHECK(d0_blind_id_write_private_id(ctx2, lumps_w0, &lumpsize[0]));
584 lumps2file(outfile, FOURCC_D0SI, lumps, lumpsize, 1, 1);
588 // private ID file -> public ID file
590 lumpsize[0] = sizeof(lumps_w0);
591 CHECK(d0_blind_id_write_public_id(ctx, lumps_w0, &lumpsize[0]));
592 lumps2file(outfile, FOURCC_D0PI, lumps, lumpsize, 1, 0);
596 // public/private key file -> fingerprint
597 CHECK(d0_blind_id_fingerprint64_public_key(ctx, fp64, &fp64size));
598 printf("%.*s\n", (int)fp64size, fp64);
602 // public/private ID file -> fingerprint
603 CHECK(d0_blind_id_fingerprint64_public_id(ctx, fp64, &fp64size));
604 printf("%.*s\n", (int)fp64size, fp64);
607 // public key, private ID, data -> signed data
608 databufsize_out = databufsize_in + 8192;
609 databuf_out = malloc(databufsize_out);
610 CHECK(d0_blind_id_sign_with_private_id_sign(ctx, 1, 0, databuf_in, databufsize_in, databuf_out, &databufsize_out));
611 buf2file(outfile, databuf_out, databufsize_out);
615 // public key, data -> signed data, optional public ID
618 databufsize_out = databufsize_in;
619 databuf_out = malloc(databufsize_out);
620 CHECK(d0_blind_id_sign_with_private_id_verify(ctx, 1, 0, databuf_in, databufsize_in, databuf_out, &databufsize_out, &status));
621 CHECK(d0_blind_id_fingerprint64_public_id(ctx, fp64, &fp64size));
622 printf("%d\n", (int)status);
623 printf("%.*s\n", (int)fp64size, fp64);
624 buf2file(outfile, databuf_out, databufsize_out);
629 lumpsize[0] = sizeof(lumps_w0);
631 lumpsize[1] = sizeof(lumps_w1);
632 CHECK(d0_blind_id_write_public_key(ctx, lumps_w0, &lumpsize[0]));
633 CHECK(d0_blind_id_write_private_id_modulus(ctx, lumps_w1, &lumpsize[1]));
634 lumps2file(outfile2, FOURCC_D0PK, lumps, lumpsize, 2, 0);
640 // public key, private ID file -> test whether key is properly signed
642 char buf[65536]; size_t bufsize;
643 char buf2[65536]; size_t buf2size;
645 d0_blind_id_t *ctx2 = d0_blind_id_new();
646 CHECK(d0_blind_id_copy(ctx2, ctx));
647 bufsize = sizeof(buf);
648 CHECK(d0_blind_id_authenticate_with_private_id_start(ctx, 1, 1, "hello world", 11, buf, &bufsize));
649 buf2size = sizeof(buf2);
650 CHECK(d0_blind_id_authenticate_with_private_id_challenge(ctx2, 1, 1, buf, bufsize, buf2, &buf2size, &status));
651 bufsize = sizeof(buf);
652 CHECK(d0_blind_id_authenticate_with_private_id_response(ctx, buf2, buf2size, buf, &bufsize));
653 buf2size = sizeof(buf2);
654 CHECK(d0_blind_id_authenticate_with_private_id_verify(ctx2, buf, bufsize, buf2, &buf2size, &status));
658 printf("EPIC FAIL\n");
666 const char hex[] = "0123456789abcdef";
667 char buf[65536]; size_t bufsize;
668 char buf2[65536]; size_t buf2size;
669 bufsize = sizeof(buf);
670 CHECK(d0_blind_id_authenticate_with_private_id_start(ctx, 1, 1, "hello world", 11, buf, &bufsize));
671 for(i = 0; i < (int)bufsize; ++i)
672 sprintf(&hexbuf[2*i], "%02x", (unsigned char)buf[i]);
673 printf("%s\n", hexbuf);
674 fgets(hexbuf, sizeof(hexbuf), stdin);
675 buf2size = strlen(hexbuf) / 2;
676 for(i = 0; i < (int)buf2size; ++i)
677 buf2[i] = ((strchr(hex, hexbuf[2*i]) - hex) << 4) | (strchr(hex, hexbuf[2*i+1]) - hex);
678 bufsize = sizeof(buf);
679 CHECK(d0_blind_id_authenticate_with_private_id_response(ctx, buf2, buf2size, buf, &bufsize));
680 for(i = 0; i < (int)bufsize; ++i)
681 sprintf(&hexbuf[2*i], "%02x", (unsigned char)buf[i]);
682 printf("%s\n", hexbuf);
689 const char hex[] = "0123456789abcdef";
690 char buf[65536]; size_t bufsize;
691 char buf2[65536]; size_t buf2size;
693 fgets(hexbuf, sizeof(hexbuf), stdin);
694 buf2size = strlen(hexbuf) / 2;
695 for(i = 0; i < (int)buf2size; ++i)
696 buf2[i] = ((strchr(hex, hexbuf[2*i]) - hex) << 4) | (strchr(hex, hexbuf[2*i+1]) - hex);
697 bufsize = sizeof(buf);
698 CHECK(d0_blind_id_authenticate_with_private_id_challenge(ctx, 1, 1, buf2, buf2size, buf, &bufsize, &status));
699 for(i = 0; i < (int)bufsize; ++i)
700 sprintf(&hexbuf[2*i], "%02x", (unsigned char)buf[i]);
701 printf("%s\n", hexbuf);
702 fgets(hexbuf, sizeof(hexbuf), stdin);
703 buf2size = strlen(hexbuf) / 2;
704 for(i = 0; i < (int)buf2size; ++i)
705 buf2[i] = ((strchr(hex, hexbuf[2*i]) - hex) << 4) | (strchr(hex, hexbuf[2*i+1]) - hex);
706 bufsize = sizeof(buf);
707 CHECK(d0_blind_id_authenticate_with_private_id_verify(ctx, buf2, buf2size, buf, &bufsize, &status));
708 printf("verify status: %d\n", status);
710 CHECK(d0_blind_id_fingerprint64_public_id(ctx, fp64, &fp64size));
711 printf("%.*s\n", (int)fp64size, fp64);
719 d0_blind_id_SHUTDOWN();