do not generate vertexposition/vertexmesh arrays in
[divverent/darkplaces.git] / crypto-keygen-standalone.c
1 #define _GNU_SOURCE
2
3 #include <d0_blind_id/d0_blind_id.h>
4
5 #include <ctype.h>
6 #include <stdio.h>
7 #include <unistd.h>
8 #include <getopt.h>
9 #include <string.h>
10 #include <stdlib.h>
11 #include <signal.h>
12 #include <math.h>
13 #include <sys/types.h>
14 #include <sys/stat.h>
15
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))
25
26 static unsigned long Crypto_LittleLong(const char *data)
27 {
28         return
29                 ((unsigned char) data[0]) |
30                 (((unsigned char) data[1]) << 8) |
31                 (((unsigned char) data[2]) << 16) |
32                 (((unsigned char) data[3]) << 24);
33 }
34
35 static void Crypto_UnLittleLong(char *data, unsigned long l)
36 {
37         data[0] = l & 0xFF;
38         data[1] = (l >> 8) & 0xFF;
39         data[2] = (l >> 16) & 0xFF;
40         data[3] = (l >> 24) & 0xFF;
41 }
42
43 static size_t Crypto_ParsePack(const char *buf, size_t len, unsigned long header, const char **lumps, size_t *lumpsize, size_t nlumps)
44 {
45         size_t i;
46         size_t pos;
47         pos = 0;
48         if(header)
49         {
50                 if(len < 4)
51                         return 0;
52                 if(Crypto_LittleLong(buf) != header)
53                         return 0;
54                 pos += 4;
55         }
56         for(i = 0; i < nlumps; ++i)
57         {
58                 if(pos + 4 > len)
59                         return 0;
60                 lumpsize[i] = Crypto_LittleLong(&buf[pos]);
61                 pos += 4;
62                 if(pos + lumpsize[i] > len)
63                         return 0;
64                 lumps[i] = &buf[pos];
65                 pos += lumpsize[i];
66         }
67         return pos;
68 }
69
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)
71 {
72         size_t i;
73         size_t pos;
74         pos = 0;
75         if(header)
76         {
77                 if(len < 4)
78                         return 0;
79                 Crypto_UnLittleLong(buf, header);
80                 pos += 4;
81         }
82         for(i = 0; i < nlumps; ++i)
83         {
84                 if(pos + 4 + lumpsize[i] > len)
85                         return 0;
86                 Crypto_UnLittleLong(&buf[pos], lumpsize[i]);
87                 pos += 4;
88                 memcpy(&buf[pos], lumps[i], lumpsize[i]);
89                 pos += lumpsize[i];
90         }
91         return pos;
92 }
93
94 void file2lumps(const char *fn, unsigned long header, const char **lumps, size_t *lumpsize, size_t nlumps)
95 {
96         FILE *f;
97         char buf[65536];
98         size_t n;
99         f = fopen(fn, "rb");
100         if(!f)
101         {
102                 fprintf(stderr, "could not open %s\n", fn);
103                 exit(1);
104         }
105         n = fread(buf, 1, sizeof(buf), f);
106         fclose(f);
107         if(!Crypto_ParsePack(buf, n, header, lumps, lumpsize, nlumps))
108         {
109                 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);
110                 exit(1);
111         }
112 }
113
114 mode_t umask_save;
115 void lumps2file(const char *fn, unsigned long header, const char *const *lumps, size_t *lumpsize, size_t nlumps, D0_BOOL private)
116 {
117         FILE *f;
118         char buf[65536];
119         size_t n;
120         if(private)
121                 umask(umask_save | 0077);
122         else
123                 umask(umask_save);
124         f = fopen(fn, "wb");
125         if(!f)
126         {
127                 fprintf(stderr, "could not open %s\n", fn);
128                 exit(1);
129         }
130         if(!(n = Crypto_UnParsePack(buf, sizeof(buf), header, lumps, lumpsize, nlumps)))
131         {
132                 fprintf(stderr, "could not unparse for %s\n", fn);
133                 exit(1);
134         }
135         n = fwrite(buf, n, 1, f);
136         if(fclose(f) || !n)
137         {
138                 fprintf(stderr, "could not write %s\n", fn);
139                 exit(1);
140         }
141 }
142
143 void USAGE(const char *me)
144 {
145         printf("Usage:\n"
146                         "%s [-F] [-b bits] [-n progress-denominator] [-x prefix] [-X infix] [-C] -o private.d0sk\n"
147                         "%s -P private.d0sk -o public.d0pk\n"
148                         "%s [-n progress-denominator] [-x prefix] [-X infix] [-C] -p public.d0pk -o idkey-unsigned.d0si\n"
149                         "%s -p public.d0pk -I idkey-unsigned.d0si -o request.d0iq -O camouflage.d0ic\n"
150                         "%s -P private.d0sk -j request.d0iq -o response.d0ir\n"
151                         "%s -p public.d0pk -I idkey-unsigned.d0si -c camouflage.d0ic -J response.d0ir -o idkey.d0si\n"
152                         "%s -P private.d0sk -I idkey-unsigned.d0si -o idkey.d0si\n"
153                         "%s -I idkey.d0si -o id.d0pi\n"
154                         "%s -p public.d0pk\n"
155                         "%s -P private.d0sk\n"
156                         "%s -p public.d0pk -i id.d0pi\n"
157                         "%s -p public.d0pk -I idkey.d0si\n"
158                         "%s -0 -p public.d0pk -I idkey.d0si\n"
159                         "%s -0 -p public.d0pk\n",
160                         me, me, me, me, me, me, me, me, me, me, me, me, me, me
161                    );
162 }
163
164 unsigned int seconds;
165 unsigned int generated;
166 unsigned int ntasks = 1;
167 double generated_offset;
168 double guesscount;
169 double guessfactor;
170 void print_generated(int signo)
171 {
172         (void) signo;
173         ++seconds;
174         if(generated >= 1000000000)
175         {
176                 generated_offset += generated;
177                 generated = 0;
178         }
179         fprintf(stderr, "Generated: %.0f (about %.0f, %.1f/s, about %.2f hours for %.0f)\n",
180                 // nasty and dishonest hack:
181                 // we are adjusting the values "back", so the total count is
182                 // divided by guessfactor (as the check function is called
183                 // guessfactor as often as it would be if no fastreject were
184                 // done)
185                 // so the values indicate the relative speed of fastreject vs
186                 // normal!
187                 (generated + generated_offset) / guessfactor,
188                 (generated + generated_offset) * ntasks / guessfactor,
189                 (generated + generated_offset) * ntasks / (guessfactor * seconds),
190                 guesscount * ((guessfactor * seconds) / (generated + generated_offset) / ntasks) / 3600.0,
191                 guesscount);
192         alarm(1);
193 }
194
195 #define CHECK(x) if(!(x)) { fprintf(stderr, "error exit: error returned by %s\n", #x); exit(2); }
196
197 const char *prefix = NULL, *infix = NULL;
198 size_t prefixlen = 0;
199 int ignorecase;
200 typedef D0_BOOL (*fingerprint_func) (const d0_blind_id_t *ctx, char *outbuf, size_t *outbuflen);
201 D0_BOOL fastreject(const d0_blind_id_t *ctx, void *pass)
202 {
203         static char fp64[513]; size_t fp64size = 512;
204         CHECK(((fingerprint_func) pass)(ctx, fp64, &fp64size));
205         ++generated;
206         if(ignorecase)
207         {
208                 if(prefixlen)
209                         if(strncasecmp(fp64, prefix, prefixlen))
210                                 return 1;
211                 if(infix)
212                 {
213                         fp64[fp64size] = 0;
214                         if(!strcasestr(fp64, infix))
215                                 return 1;
216                 }
217         }
218         else
219         {
220                 if(prefixlen)
221                         if(memcmp(fp64, prefix, prefixlen))
222                                 return 1;
223                 if(infix)
224                 {
225                         fp64[fp64size] = 0;
226                         if(!strstr(fp64, infix))
227                                 return 1;
228                 }
229         }
230         return 0;
231 }
232
233 int main(int argc, char **argv)
234 {
235         int opt;
236         size_t lumpsize[2];
237         const char *lumps[2];
238         char lumps_w0[65536];
239         char lumps_w1[65536];
240         const char *pubkeyfile = NULL, *privkeyfile = NULL, *pubidfile = NULL, *prividfile = NULL, *idreqfile = NULL, *idresfile = NULL, *outfile = NULL, *outfile2 = NULL, *camouflagefile = NULL;
241         char fp64[513]; size_t fp64size = 512;
242         int mask = 0;
243         int bits = 1024;
244         int i;
245         D0_BOOL do_fastreject = 1;
246         d0_blind_id_t *ctx;
247         if(!d0_blind_id_INITIALIZE())
248         {
249                 fprintf(stderr, "could not initialize\n");
250                 exit(1);
251         }
252
253         umask_save = umask(0022);
254
255         ctx = d0_blind_id_new();
256         while((opt = getopt(argc, argv, "p:P:i:I:j:J:o:O:c:b:x:X:y:Fn:C0")) != -1)
257         {
258                 switch(opt)
259                 {
260                         case 'C':
261                                 ignorecase = 1;
262                                 break;
263                         case 'n':
264                                 ntasks = atoi(optarg);
265                                 break;
266                         case 'b':
267                                 bits = atoi(optarg);
268                                 break;
269                         case 'p': // d0pk = <pubkey> <modulus>
270                                 pubkeyfile = optarg;
271                                 mask |= 1;
272                                 break;
273                         case 'P': // d0sk = <privkey> <modulus>
274                                 privkeyfile = optarg;
275                                 mask |= 2;
276                                 break;
277                         case 'i': // d0pi = <pubid>
278                                 pubidfile = optarg;
279                                 mask |= 4;
280                                 break;
281                         case 'I': // d0si = <privid>
282                                 prividfile = optarg;
283                                 mask |= 8;
284                                 break;
285                         case 'j': // d0iq = <req>
286                                 idreqfile = optarg;
287                                 mask |= 0x10;
288                                 break;
289                         case 'J': // d0ir = <resp>
290                                 idresfile = optarg;
291                                 mask |= 0x20;
292                                 break;
293                         case 'o':
294                                 outfile = optarg;
295                                 mask |= 0x40;
296                                 break;
297                         case 'O':
298                                 outfile2 = optarg;
299                                 mask |= 0x80;
300                                 break;
301                         case 'c':
302                                 camouflagefile = optarg;
303                                 mask |= 0x100;
304                                 break;
305                         case 'x':
306                                 prefix = optarg;
307                                 prefixlen = strlen(prefix);
308                                 break;
309                         case '0':
310                                 // test mode
311                                 mask |= 0x200;
312                                 break;
313                         case 'X':
314                                 infix = optarg;
315                                 break;
316                         case 'F':
317                                 do_fastreject = 0;
318                                 break;
319                         default:
320                                 USAGE(*argv);
321                                 return 1;
322                 }
323         }
324
325         // fastreject is a slight slowdown when rejecting nothing at all
326         if(!infix && !prefixlen)
327                 do_fastreject = 0;
328
329         guesscount = pow(64.0, prefixlen);
330         if(infix)
331                 guesscount /= (1 - pow(1 - pow(1/64.0, strlen(infix)), 44 - prefixlen - strlen(infix)));
332         // 44 chars; prefix is assumed to not match the infix (although it theoretically could)
333         // 43'th char however is always '=' and does not count
334         if(ignorecase)
335         {
336                 if(infix)
337                         for(i = 0; infix[i]; ++i)
338                                 if(toupper(infix[i]) != tolower(infix[i]))
339                                         guesscount /= 2;
340                 for(i = 0; i < (int)prefixlen; ++i)
341                         if(toupper(prefix[i]) != tolower(prefix[i]))
342                                 guesscount /= 2;
343         }
344
345         if(do_fastreject)
346         {
347                 // fastreject: reject function gets called about log(2^bits) times more often
348                 guessfactor = bits * log(2) / 2;
349                 // so guess function gets called guesscount * guessfactor times, and it tests as many valid keys as guesscount
350         }
351
352         if(mask & 1)
353         {
354                 file2lumps(pubkeyfile, FOURCC_D0PK, lumps, lumpsize, 2);
355                 if(!d0_blind_id_read_public_key(ctx, lumps[0], lumpsize[0]))
356                 {
357                         fprintf(stderr, "could not decode public key\n");
358                         exit(1);
359                 }
360                 if(!d0_blind_id_read_private_id_modulus(ctx, lumps[1], lumpsize[1]))
361                 {
362                         fprintf(stderr, "could not decode modulus\n");
363                         exit(1);
364                 }
365         }
366         else if(mask & 2)
367         {
368                 file2lumps(privkeyfile, FOURCC_D0SK, lumps, lumpsize, 2);
369                 if(!d0_blind_id_read_private_key(ctx, lumps[0], lumpsize[0]))
370                 {
371                         fprintf(stderr, "could not decode private key\n");
372                         exit(1);
373                 }
374                 if(!d0_blind_id_read_private_id_modulus(ctx, lumps[1], lumpsize[1]))
375                 {
376                         fprintf(stderr, "could not decode modulus\n");
377                         exit(1);
378                 }
379         }
380
381         if(mask & 4)
382         {
383                 file2lumps(pubidfile, FOURCC_D0PI, lumps, lumpsize, 1);
384                 if(!d0_blind_id_read_public_id(ctx, lumps[0], lumpsize[0]))
385                 {
386                         fprintf(stderr, "could not decode public ID\n");
387                         exit(1);
388                 }
389         }
390         if(mask & 8)
391         {
392                 file2lumps(prividfile, FOURCC_D0SI, lumps, lumpsize, 1);
393                 if(!d0_blind_id_read_private_id(ctx, lumps[0], lumpsize[0]))
394                 {
395                         fprintf(stderr, "could not decode private ID\n");
396                         exit(1);
397                 }
398         }
399
400         if(mask & 0x10)
401         {
402                 file2lumps(idreqfile, FOURCC_D0IQ, lumps, lumpsize, 1);
403                 lumpsize[1] = sizeof(lumps_w1);
404                 lumps[1] = lumps_w1;
405                 if(!d0_blind_id_answer_private_id_request(ctx, lumps[0], lumpsize[0], lumps_w1, &lumpsize[1]))
406                 {
407                         fprintf(stderr, "could not answer private ID request\n");
408                         exit(1);
409                 }
410         }
411         else if((mask & 0x120) == 0x120)
412         {
413                 file2lumps(camouflagefile, FOURCC_D0IC, lumps, lumpsize, 1);
414                 if(!d0_blind_id_read_private_id_request_camouflage(ctx, lumps[0], lumpsize[0]))
415                 {
416                         fprintf(stderr, "could not decode camouflage\n");
417                         exit(1);
418                 }
419
420                 file2lumps(idresfile, FOURCC_D0IR, lumps, lumpsize, 1);
421                 if(!d0_blind_id_finish_private_id_request(ctx, lumps[0], lumpsize[0]))
422                 {
423                         fprintf(stderr, "could not finish private ID request\n");
424                         exit(1);
425                 }
426         }
427
428         switch(mask)
429         {
430                 // modes of operation:
431                 case 0x40:
432                         //   nothing -> private key file (incl modulus), print fingerprint
433                         generated = 0;
434                         generated_offset = 0;
435                         seconds = 0;
436                         signal(SIGALRM, print_generated);
437                         alarm(1);
438                         if(do_fastreject)
439                         {
440                                 CHECK(d0_blind_id_generate_private_key_fastreject(ctx, bits, fastreject, d0_blind_id_fingerprint64_public_key));
441                         }
442                         else
443                         {
444                                 guessfactor = 1; // no fastreject here
445                                 do
446                                 {
447                                         CHECK(d0_blind_id_generate_private_key(ctx, bits));
448                                 }
449                                 while(fastreject(ctx, d0_blind_id_fingerprint64_public_key));
450                         }
451                         alarm(0);
452                         signal(SIGALRM, NULL);
453                         CHECK(d0_blind_id_generate_private_id_modulus(ctx));
454                         lumps[0] = lumps_w0;
455                         lumpsize[0] = sizeof(lumps_w0);
456                         lumps[1] = lumps_w1;
457                         lumpsize[1] = sizeof(lumps_w1);
458                         CHECK(d0_blind_id_write_private_key(ctx, lumps_w0, &lumpsize[0]));
459                         CHECK(d0_blind_id_write_private_id_modulus(ctx, lumps_w1, &lumpsize[1]));
460                         lumps2file(outfile, FOURCC_D0SK, lumps, lumpsize, 2, 1);
461                         break;
462                 case 0x42:
463                         //   private key file -> public key file (incl modulus)
464                         lumps[0] = lumps_w0;
465                         lumpsize[0] = sizeof(lumps_w0);
466                         lumps[1] = lumps_w1;
467                         lumpsize[1] = sizeof(lumps_w1);
468                         CHECK(d0_blind_id_write_public_key(ctx, lumps_w0, &lumpsize[0]));
469                         CHECK(d0_blind_id_write_private_id_modulus(ctx, lumps_w1, &lumpsize[1]));
470                         lumps2file(outfile, FOURCC_D0PK, lumps, lumpsize, 2, 0);
471                         break;
472                 case 0x41:
473                         //   public key file -> unsigned private ID file
474                         generated = 0;
475                         generated_offset = 0;
476                         seconds = 0;
477                         signal(SIGALRM, print_generated);
478                         alarm(1);
479                         guessfactor = 1; // no fastreject here
480                         do
481                         {
482                                 CHECK(d0_blind_id_generate_private_id_start(ctx));
483                         }
484                         while(fastreject(ctx, d0_blind_id_fingerprint64_public_id));
485                         alarm(0);
486                         signal(SIGALRM, 0);
487                         lumps[0] = lumps_w0;
488                         lumpsize[0] = sizeof(lumps_w0);
489                         CHECK(d0_blind_id_write_private_id(ctx, lumps_w0, &lumpsize[0]));
490                         lumps2file(outfile, FOURCC_D0SI, lumps, lumpsize, 1, 1);
491                         break;
492                 case 0xC9:
493                         //   public key file, unsigned private ID file -> ID request file and camouflage file
494                         lumps[0] = lumps_w0;
495                         lumpsize[0] = sizeof(lumps_w0);
496                         CHECK(d0_blind_id_generate_private_id_request(ctx, lumps_w0, &lumpsize[0]));
497                         lumps2file(outfile, FOURCC_D0IQ, lumps, lumpsize, 1, 0);
498                         lumpsize[0] = sizeof(lumps_w0);
499                         CHECK(d0_blind_id_write_private_id_request_camouflage(ctx, lumps_w0, &lumpsize[0]));
500                         lumps2file(outfile2, FOURCC_D0IC, lumps, lumpsize, 1, 1);
501                         break;
502                 case 0x52:
503                         //   private key file, ID request file -> ID response file
504                         lumps2file(outfile, FOURCC_D0IR, lumps+1, lumpsize+1, 1, 0);
505                         break;
506                 case 0x169:
507                         //   public key file, ID response file, private ID file -> signed private ID file
508                         lumps[0] = lumps_w0;
509                         lumpsize[0] = sizeof(lumps_w0);
510                         CHECK(d0_blind_id_write_private_id(ctx, lumps_w0, &lumpsize[0]));
511                         lumps2file(outfile, FOURCC_D0SI, lumps, lumpsize, 1, 1);
512                         break;
513                 case 0x4A:
514                         //   private key file, private ID file -> signed private ID file
515                         {
516                                 char buf[65536]; size_t bufsize;
517                                 char buf2[65536]; size_t buf2size;
518                                 D0_BOOL status;
519                                 d0_blind_id_t *ctx2 = d0_blind_id_new();
520                                 CHECK(d0_blind_id_copy(ctx2, ctx));
521                                 bufsize = sizeof(buf);
522                                 CHECK(d0_blind_id_authenticate_with_private_id_start(ctx, 1, 1, "hello world", 11, buf, &bufsize));
523                                 buf2size = sizeof(buf2);
524                                 CHECK(d0_blind_id_authenticate_with_private_id_challenge(ctx2, 1, 1, buf, bufsize, buf2, &buf2size, &status));
525                                 bufsize = sizeof(buf);
526                                 CHECK(d0_blind_id_authenticate_with_private_id_response(ctx, buf2, buf2size, buf, &bufsize));
527                                 buf2size = sizeof(buf2);
528                                 CHECK(d0_blind_id_authenticate_with_private_id_verify(ctx2, buf, bufsize, buf2, &buf2size, &status));
529                                 CHECK(status == 0);
530                                 CHECK(d0_blind_id_authenticate_with_private_id_generate_missing_signature(ctx2));
531                                 lumps[0] = lumps_w0;
532                                 lumpsize[0] = sizeof(lumps_w0);
533                                 CHECK(d0_blind_id_write_private_id(ctx2, lumps_w0, &lumpsize[0]));
534                                 lumps2file(outfile, FOURCC_D0SI, lumps, lumpsize, 1, 1);
535                         }
536                         break;
537                 case 0x48:
538                         //   private ID file -> public ID file
539                         lumps[0] = lumps_w0;
540                         lumpsize[0] = sizeof(lumps_w0);
541                         CHECK(d0_blind_id_write_public_id(ctx, lumps_w0, &lumpsize[0]));
542                         lumps2file(outfile, FOURCC_D0PI, lumps, lumpsize, 1, 0);
543                         break;
544                 case 0x01:
545                 case 0x02:
546                         //   public/private key file -> fingerprint
547                         CHECK(d0_blind_id_fingerprint64_public_key(ctx, fp64, &fp64size));
548                         printf("%.*s\n", (int)fp64size, fp64);
549                         break;
550                 case 0x05:
551                 case 0x09:
552                         //   public/private ID file -> fingerprint
553                         CHECK(d0_blind_id_fingerprint64_public_id(ctx, fp64, &fp64size));
554                         printf("%.*s\n", (int)fp64size, fp64);
555                         break;
556 /*
557                 case 0x09:
558                         //   public key, private ID file -> test whether key is properly signed
559                         {
560                                 char buf[65536]; size_t bufsize;
561                                 char buf2[65536]; size_t buf2size;
562                                 D0_BOOL status;
563                                 d0_blind_id_t *ctx2 = d0_blind_id_new();
564                                 CHECK(d0_blind_id_copy(ctx2, ctx));
565                                 bufsize = sizeof(buf);
566                                 CHECK(d0_blind_id_authenticate_with_private_id_start(ctx, 1, 1, "hello world", 11, buf, &bufsize));
567                                 buf2size = sizeof(buf2);
568                                 CHECK(d0_blind_id_authenticate_with_private_id_challenge(ctx2, 1, 1, buf, bufsize, buf2, &buf2size, &status));
569                                 bufsize = sizeof(buf);
570                                 CHECK(d0_blind_id_authenticate_with_private_id_response(ctx, buf2, buf2size, buf, &bufsize));
571                                 buf2size = sizeof(buf2);
572                                 CHECK(d0_blind_id_authenticate_with_private_id_verify(ctx2, buf, bufsize, buf2, &buf2size, &status));
573                                 if(status)
574                                         printf("OK\n");
575                                 else
576                                         printf("EPIC FAIL\n");
577                         }
578                         break;
579 */
580                 case 0x209:
581                         // protocol client
582                         {
583                                 char hexbuf[131073];
584                                 const char hex[] = "0123456789abcdef";
585                                 char buf[65536]; size_t bufsize;
586                                 char buf2[65536]; size_t buf2size;
587                                 bufsize = sizeof(buf);
588                                 CHECK(d0_blind_id_authenticate_with_private_id_start(ctx, 1, 1, "hello world", 11, buf, &bufsize));
589                                 for(i = 0; i < (int)bufsize; ++i)
590                                         sprintf(&hexbuf[2*i], "%02x", (unsigned char)buf[i]);
591                                 printf("%s\n", hexbuf);
592                                 fgets(hexbuf, sizeof(hexbuf), stdin);
593                                 buf2size = strlen(hexbuf) / 2;
594                                 for(i = 0; i < (int)buf2size; ++i)
595                                         buf2[i] = ((strchr(hex, hexbuf[2*i]) - hex) << 4) | (strchr(hex, hexbuf[2*i+1]) - hex);
596                                 bufsize = sizeof(buf);
597                                 CHECK(d0_blind_id_authenticate_with_private_id_response(ctx, buf2, buf2size, buf, &bufsize));
598                                 for(i = 0; i < (int)bufsize; ++i)
599                                         sprintf(&hexbuf[2*i], "%02x", (unsigned char)buf[i]);
600                                 printf("%s\n", hexbuf);
601                         }
602                         break;
603                 case 0x201:
604                         // protocol server
605                         {
606                                 char hexbuf[131073];
607                                 const char hex[] = "0123456789abcdef";
608                                 char buf[65536]; size_t bufsize;
609                                 char buf2[65536]; size_t buf2size;
610                                 D0_BOOL status;
611                                 fgets(hexbuf, sizeof(hexbuf), stdin);
612                                 buf2size = strlen(hexbuf) / 2;
613                                 for(i = 0; i < (int)buf2size; ++i)
614                                         buf2[i] = ((strchr(hex, hexbuf[2*i]) - hex) << 4) | (strchr(hex, hexbuf[2*i+1]) - hex);
615                                 bufsize = sizeof(buf);
616                                 CHECK(d0_blind_id_authenticate_with_private_id_challenge(ctx, 1, 1, buf2, buf2size, buf, &bufsize, &status));
617                                 for(i = 0; i < (int)bufsize; ++i)
618                                         sprintf(&hexbuf[2*i], "%02x", (unsigned char)buf[i]);
619                                 printf("%s\n", hexbuf);
620                                 fgets(hexbuf, sizeof(hexbuf), stdin);
621                                 buf2size = strlen(hexbuf) / 2;
622                                 for(i = 0; i < (int)buf2size; ++i)
623                                         buf2[i] = ((strchr(hex, hexbuf[2*i]) - hex) << 4) | (strchr(hex, hexbuf[2*i+1]) - hex);
624                                 bufsize = sizeof(buf);
625                                 CHECK(d0_blind_id_authenticate_with_private_id_verify(ctx, buf2, buf2size, buf, &bufsize, &status));
626                                 printf("verify status: %d\n", status);
627
628                                 CHECK(d0_blind_id_fingerprint64_public_id(ctx, fp64, &fp64size));
629                                 printf("%.*s\n", (int)fp64size, fp64);
630                         }
631                         break;
632                 default:
633                         USAGE(*argv);
634                         exit(1);
635                         break;
636         }
637         d0_blind_id_SHUTDOWN();
638         return 0;
639 }