]> pd.if.org Git - zpackage/blob - crypto/libeddsa/sign.c
ocb mode fixup
[zpackage] / crypto / libeddsa / sign.c
1 #define _POSIX_C_SOURCE 200809L
2
3 /* general zpm sign function */
4
5 /* read key, export key, import key, sign, export signature, import
6  * signature, verify signature
7  */
8
9 /* import and export is base64 encoded */
10
11 /* -v verify
12  * -s sign
13  * -g generate key
14  * -e extract public key
15  *
16  * -o output file
17  *
18  * -p read key from file
19  * -P read public key from argument to -P
20  * -S read secret key from argument
21  * -m message from argument
22  * -h message is hex encoded
23  */
24
25 /* chacha20 encryption: 256 bit key = 32 bytes */
26
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <ctype.h>
31 #include <unistd.h>
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <fcntl.h>
35 #include <sys/mman.h>
36 #include <time.h>
37
38 /* linux specific for getrandom */
39 #include <sys/random.h>
40
41 #include "eddsa.h"
42 #include "sha512.h"
43 #include "crypto/chacha.h"
44 #include "lib/blake2.h"
45
46 char *readpass(char *prompt);
47
48 #define VERIFY 1
49 #define SIGN 2
50 #define KEYGEN 3
51 #define EXTRACT 4
52 #define KEYSIGN 5
53 #define LIST 6
54 #define ENCRYPT 7
55 #define DECRYPT 8
56 #define SIGNKEY 9
57 #define IMPORT 10 
58
59 /* output flags */
60 #define RAW 0x1
61 #define HUMANREADABLE 0x2
62
63 #define SECRET_KEY 1
64 #define PUBLIC_KEY 2
65 #define SIGNATURE 3
66 #define UNKNOWN 4
67
68 #define VERSION 1
69
70 /* possible additional types:
71  * designated revoker
72  * revocation certificate
73  */
74
75 /* timestamps are 8 byte little endian integers of seconds since
76  * the epoch.  or unix time, or some such.  Times are a mess.
77  * Unix time is leap second unaware, and ambiguous during leap seconds.
78  * UTC requires a database of leap seconds for past time, and the
79  * specified second in the future possibly changes.
80  * TAI is good, but currently 37 seconds behind UTC, which is just weird
81  */
82
83 /* size of structs would have to be increased for 57/64 byte keys
84  * and key*2 size signatures
85  */
86
87 /* need 25 more bytes for ed448 */
88 struct secret_key {
89         char magic[4]; /* "ZPMS" */
90         uint8_t version; /* 0x01 */
91         uint8_t type; /* 0x01 */
92         uint8_t encryption; /* 0x01 == chacha */
93         uint8_t reserved1; /* MBZ */
94         char key[32]; /* private key data */
95         int64_t created; /* time in unix epoch seconds, little endian */
96         int64_t expires; /* time in unix epoch seconds, little endian, = is none, could do uint64max */
97         char salt[8]; /* password salt, nist wants 16, but we're not using nist approved hash algorithms anyway. */
98         char reserved2[64]; /* could put the pubkey here could have 16 bytes of IV for chacha to encrypt. */
99         char id[120]; /* 1 byte len, id bytes, zero bytes remainder */
100         char trailer[8]; /* room for a pointer */
101 };
102
103 struct public_key {
104         char magic[4]; /* "ZPMS" */
105         uint8_t version; /* 0x01 */
106         uint8_t type; /* 0x02 */
107         uint8_t reserved0; /* MBZ */
108         uint8_t reserved1; /* MBZ */
109         char key[32]; /* public key data */
110         int64_t created; /* time in unix epoch seconds, little endian */
111         int64_t expires; /* time in unix epoch seconds, little endian */
112         char reserved2[8]; /* MBZ */
113         char signature[64]; /* self sig data */
114         char id[120]; /* 1 byte len, id bytes, zero bytes remainder */
115         char trailer[8]; /* room for a pointer */
116 };
117
118 struct signature {
119         char magic[4]; /* "ZPMS" */
120         uint8_t version; /* 0x01 */
121         uint8_t type; /* 0x03 */
122         uint8_t reserved0; /* MBZ */ /* trust level? revokable? */
123         uint8_t reserved1; /* MBZ */
124         char key[32]; /* signing public key data?, can be zero */
125         int64_t signtime; /* time in unix epoch seconds, little endian */
126         int64_t expires; /* time in unix epoch seconds, little endian */
127         char reserved2[8]; /* MBZ */
128         char signature[64]; /* sig data */
129         char reserved3[120]; /* some indication of what you're signing ? */
130         /* 512 bits is 64 bytes, could put the hash of the data signed */
131         char trailer[8]; /* room for a pointer */
132 };
133
134 struct keysig {
135         char magic[4]; /* "ZPMS" */
136         uint8_t version; /* 0x01 */
137         uint8_t type;
138         uint8_t encryption; /* trust level for pk? revokable for sig? */
139         uint8_t reserved1; /* MBZ */
140         char key[32]; /* signing public key data?, can be zero */
141         /* should these be signed? */
142         int64_t created; /* time in unix epoch seconds */
143         int64_t expires; /* time in unix epoch seconds */
144         char salt[8]; /* reserved for pk and sig, could be IV for sig */
145         char signature[64]; /* sig data, reserved for sk */
146         char id[120]; /* signing hash for sig? otherwise reserved for sig */
147         /* 512 bits is 64 bytes, could put the hash of the data signed */
148         char trailer[8]; /* room for a pointer */
149 };
150
151 struct signing_context {
152         char *message;
153         size_t mlen;
154
155         char *keyfile, *keystring, *keyid, *keyprefix, *passphrase;
156         unsigned char passkey[32];
157 };
158
159 void putsle8(unsigned char *dst, int64_t inval) {
160         int i;
161         union { uint64_t out; int64_t in; } uv;
162         uint64_t val;
163
164         uv.in = inval;
165         val = uv.out;
166
167         for (i=0; i<8; i++) {
168                 dst[i] = val & 0xff;
169                 val >>= 8;
170         }
171 }
172
173 int64_t getsle8(unsigned char *dst) {
174         uint64_t val = 0;
175         int i;
176         union { int64_t out; uint64_t in; } uv;
177
178         for (i=0; i<8; i++) {
179                 val += (uint64_t)dst[i] << (8*i);
180         }
181
182         uv.in = val;
183
184         return uv.out;
185 }
186
187 void seckey_bytea(unsigned char *bytes, struct secret_key *sk) {
188         memset(bytes, 0, 256);
189         memcpy(bytes, "ZPMS", 4);
190         bytes[4] = sk->version;
191         bytes[5] = sk->type;
192         bytes[6] = sk->encryption;
193         /* 7 reserved */
194         memcpy(bytes + 8, sk->key, 32);
195         putsle8(bytes+40, sk->created);
196         putsle8(bytes+48, sk->expires);
197         /* @56 8 salt, not implemented */
198         /* memcpy(bytes + 64, sk->reserved2, 64); should probably put the pk */
199         memcpy(bytes + 128, sk->id, 120);
200         /* 8 reserved */
201 }
202
203 void bytea_seckey(struct secret_key *sk, unsigned char *bytes) {
204         memcpy(sk->magic, bytes, 4);
205         sk->version = bytes[4];
206         sk->type = bytes[5]; 
207         sk->encryption = bytes[6];
208         sk->reserved1 = 0;
209         memcpy(sk->key, bytes + 8, 32);
210         sk->created = getsle8(bytes+40);
211         sk->expires = getsle8(bytes+48);
212         memset(sk->salt, 0, 8); /* salt not implemented */
213         memset(sk->reserved2, 0, 64); /* salt not implemented */
214         memcpy(sk->id, bytes + 128, 120);
215         memset(sk->trailer, 0, 8);
216 }
217
218 int create_key(struct secret_key *sk, int generate) {
219         memcpy(sk->magic, "ZPMS", 4);
220         sk->version = VERSION;
221         sk->type = SECRET_KEY;
222         sk->encryption = 0;
223         sk->reserved1 = 0;
224
225         if (generate) {
226                 /* a private key is just 32 random bytes */
227                 getrandom(sk->key, sizeof sk->key, 0);
228         }
229
230         sk->created = time(NULL);
231         sk->expires = INT64_MAX;
232         memset(sk->salt, 0, 8);
233         memset(sk->reserved2, 0, 64);
234         memset(sk->id, 0, 120);
235         memset(sk->trailer, 0, 8);
236
237         ed25519_genpub(sk->reserved2, sk->key);
238         return 1;
239 }
240
241 /* hash password into 32 bytes for chacha encryption */
242 int collect_key(unsigned char *key, const char *pass) {
243         struct blake2b_state__ h;
244         if (!pass) {
245                 pass = readpass("Passphrase: ");
246         }
247
248         if (!pass) {
249                 return 0;
250         }
251
252         blake2b_init(&h, 32);
253         blake2b_update(&h, pass, strlen(pass));
254         blake2b_final(&h, key, 32);
255         return 1;
256 }
257
258 int encrypt_key(struct secret_key *sk, unsigned char *key) {
259         int i;
260
261         if (sk->encryption) {
262                 return 1;
263         }
264
265         /* TODO chacha encrypt sk->key */
266         for (i=0; i < 32; i++) {
267                 sk->key[i] ^= key[i];
268         }
269
270         sk->encryption = 1;
271         return 1;
272 }
273
274 int encrypt_sk(struct secret_key *sk, unsigned char *pass) {
275         unsigned char key[32];
276
277         if (sk->encryption == 1) {
278                 return 1;
279         }
280
281         collect_key(key, pass);
282         encrypt_key(sk, key);
283
284         memset(key, 0, 32);
285         memset(pass, 0, strlen(pass));
286
287         return 1;
288 }
289
290 int decrypt_sk(struct secret_key *sk, unsigned char *pass) {
291         unsigned char key[32];
292         int i;
293
294         if (sk->encryption == 0) {
295                 return 1;
296         }
297
298         collect_key(key, pass);
299
300         for (i=0; i < 32; i++) {
301                 sk->key[i] ^= key[i];
302         }
303
304         memset(key, 0, 32);
305         memset(pass, 0, strlen(pass));
306
307         sk->encryption = 0;
308
309         return 1;
310 }
311
312 int decrypt_key(struct secret_key *sk, unsigned char *key) {
313         int i;
314
315         if (sk->encryption == 0) {
316                 return 1;
317         }
318
319         /* TODO chacha decrypt sk->key */
320         for (i=0; i < 32; i++) {
321                 sk->key[i] ^= key[i];
322         }
323
324         sk->encryption = 0;
325         return 1;
326 }
327
328 void pubkey_init(struct public_key *pk) {
329         memcpy(pk->magic, "ZPMS", 4);
330         pk->version = VERSION;
331         pk->type = PUBLIC_KEY;
332         pk->reserved0 = 0;
333         pk->reserved1 = 0;
334         memset(pk->key, 0, sizeof pk->key);
335         pk->created = 0;
336         pk->expires = 0;
337         memset(pk->reserved2, 0, 8);
338         memset(pk->signature, 0, 64);
339         memset(pk->id, 0, 120);
340         memset(pk->trailer, 0, 8);
341 }
342
343 void pubkey_bytea(unsigned char *bytes, struct public_key *pk) {
344         memset(bytes, 0, 256);
345         memcpy(bytes, "ZPMS", 4);
346         bytes[4] = pk->version;
347         bytes[5] = pk->type;
348         /* 6 7 reserved */
349         memcpy(bytes + 8, pk->key, 32);
350         putsle8(bytes+40, pk->created);
351         putsle8(bytes+48, pk->expires);
352         /* @56 8 reserved */
353         memcpy(bytes + 64, pk->signature, 64);
354         memcpy(bytes + 128, pk->id, 120);
355         /* 8 reserved */
356 }
357
358 void bytea_pubkey(struct public_key *pk, unsigned char *bytes) {
359         memcpy(pk->magic, bytes, 4);
360         pk->version = bytes[4];
361         pk->type = bytes[5]; 
362         pk->reserved0 = 0;
363         pk->reserved1 = 0;
364         memcpy(pk->key, bytes + 8, 32);
365         pk->created = getsle8(bytes+40);
366         pk->expires = getsle8(bytes+48);
367         memset(pk->reserved2, 0, 8);
368         memcpy(pk->signature, bytes + 64, 64);
369         memcpy(pk->id, bytes + 128, 120);
370         memset(pk->trailer, 0, 8);
371 }
372
373 int derive_pubkey(struct public_key *pk, struct secret_key *sk) {
374         char bytes[256];
375
376         memcpy(pk->magic, "ZPMS", 4);
377         pk->version = VERSION;
378         pk->type = PUBLIC_KEY;
379         pk->reserved0 = 0;
380         pk->reserved1 = 0;
381         ed25519_genpub(pk->key, sk->key);
382         pk->created = sk->created;
383         pk->expires = sk->expires;
384         memset(pk->reserved2, 0, 8);
385         memset(pk->signature, 0, 64);
386         memset(pk->id, 0, 120);
387         strncpy(pk->id, sk->id, 119);
388         memset(pk->trailer, 0, 8);
389
390         /* serialize and sign */
391         pubkey_bytea(bytes, pk);
392         ed25519_sign(pk->signature, sk->key, pk->key, bytes, 256);
393
394         return 1;
395 }
396
397 void bytea_signature(struct signature *sig, unsigned char *bytes) {
398         memcpy(sig->magic, bytes, 4);
399         sig->version = bytes[4];
400         sig->type = bytes[5]; 
401         sig->reserved0 = 0;
402         sig->reserved1 = 0;
403         memcpy(sig->key, bytes + 8, 32);
404         sig->signtime = getsle8(bytes+40);
405         sig->expires = getsle8(bytes+48);
406         memset(sig->reserved2, 0, 8);
407         memcpy(sig->signature, bytes + 64, 64);
408         memcpy(sig->reserved3, bytes + 128, 120);
409         memset(sig->trailer, 0, 8);
410 }
411
412 void signature_bytea(unsigned char *bytes, struct signature *sig) {
413         memset(bytes, 0, 256);
414         memcpy(bytes, "ZPMS", 4);
415         bytes[4] = sig->version;
416         bytes[5] = sig->type;
417         /* 6 7 reserved */
418         memcpy(bytes + 8, sig->key, 32);
419         putsle8(bytes+40, sig->signtime);
420         putsle8(bytes+48, sig->expires);
421         /* @56 8 reserved */
422         memcpy(bytes + 64, sig->signature, 64);
423         /* 120 reserved */
424         /* 8 reserved */
425 }
426
427 union signobject {
428         struct signature sig;
429         struct public_key pk;
430         struct secret_key sk;
431         char bytes[256];
432 };
433
434 int object_type(union signobject *obj) {
435         return obj ? obj->sk.type : 0;
436 }
437
438 void sighash(unsigned char *dst, struct signature *sig, unsigned char *data,
439                 size_t len) {
440         unsigned char signtime[8], expires[8];
441         struct sha512 hash;
442
443         /* need to put these in as little endian */
444         putsle8(signtime, sig->signtime);
445         putsle8(expires, sig->expires);
446
447         sha512_init(&hash);
448         sha512_add(&hash, signtime, sizeof signtime);
449         sha512_add(&hash, expires, sizeof expires);
450         sha512_add(&hash, data, len);
451         sha512_final(&hash, dst);
452 }
453
454 void init_signature(struct signature *sig) {
455         memcpy(sig->magic, "ZPMS", 4);
456         sig->version = VERSION;
457         sig->type = SIGNATURE;
458         sig->reserved0 = 0;
459         sig->reserved1 = 0;
460         memset(sig->key, 0, sizeof sig->key);
461         sig->signtime = 0;
462         sig->expires = 0;
463         memset(sig->reserved2, 0, 8);
464         memset(sig->signature, 0, 64);
465         memset(sig->reserved3, 0, 120);
466         memset(sig->trailer, 0, 8);
467 }
468
469 int create_signature(struct signature *sig, struct secret_key *sk,
470                 int baresign, unsigned char *data, size_t len) {
471         unsigned char messagehash[64];
472
473         if (!sk || !data || !sig) {
474                 return 0;
475         }
476
477         memcpy(sig->magic, "ZPMS", 4);
478         sig->version = VERSION;
479         sig->type = SIGNATURE;
480         sig->reserved0 = 0;
481         sig->reserved1 = 0;
482         ed25519_genpub(sig->key, sk->key);
483 #if 0
484         sig->signtime = 0;
485         sig->expires = 0;
486 #endif
487         memset(sig->reserved2, 0, 8);
488         memset(sig->signature, 0, 64);
489         memset(sig->reserved3, 0, 120);
490         memset(sig->trailer, 0, 8);
491
492         if (!baresign) {
493                 sighash(messagehash, sig, data, len);
494                 data = messagehash;
495                 len = sizeof messagehash;
496         }
497
498         ed25519_sign(sig->signature, sk->key, sig->key, data, len);
499
500         return 1;
501 }
502
503 //#define MARK do { fprintf(stderr, "%s %s:%d\n", __FILE__, __func__, __LINE__); } while (0)
504
505 static char hexchars[] = "0123456789abcdefABCDEF";
506
507 static void hex(char *dst, uint8_t *src, size_t len) {
508         while (len--) {
509                 dst[0] = hexchars[(src[0]>>4)&0xf];
510                 dst[1] = hexchars[src[0]&0xf];
511                 dst+=2;
512                 src++;
513         }
514 }
515
516 /* always 512 bytes dst, 248 bytes src, last 8 bytes
517  * are ignored and set to zero, last 4 bytes not output
518  */
519 void serialize(uint8_t *dst, unsigned char *src) {
520         int i;
521         uint8_t byte, hi, lo;
522
523         for (i = 0; i < 248; i++) {
524                 byte = src[i];
525                 hi = byte >> 4;
526                 lo = byte & 0xf;
527                 if (i % 32 == 0 && i > 0) {
528                         *dst++ = '\n';
529                 }
530
531                 *dst++ = hexchars[hi];
532                 *dst++ = hexchars[lo];
533         }
534         for (; i < 252; i++) {
535                 *dst++ = '0';
536                 *dst++ = '0';
537         }
538         *dst++ = '\n';
539 }
540
541 int hexval(int digit) {
542         if (digit >= '0' && digit <= '9') {
543                 return digit - '0';
544         } else if (digit == 'A' || digit == 'a') {
545                 return 10;
546         } else if (digit == 'B' || digit == 'b') {
547                 return 11;
548         } else if (digit == 'C' || digit == 'c') {
549                 return 12;
550         } else if (digit == 'D' || digit == 'd') {
551                 return 13;
552         } else if (digit == 'E' || digit == 'e') {
553                 return 14;
554         } else if (digit == 'F' || digit == 'f') {
555                 return 15;
556         }
557
558         return 0;
559 }
560
561 /* convert at most dlen hex bytes from srclen, returns
562  * number of bytes read, src may contain zero bytes,
563  * so use strlen in the caller if needed
564  */ 
565 size_t hex2bin(uint8_t *dst, size_t dlen, char *src, size_t slen) {
566         size_t i, n = 0;
567         uint8_t val = 0;
568
569         for (i = 0; i < slen && n < dlen; i++) {
570                 if (!isxdigit(src[i])) {
571                         continue;
572                 }
573
574                 val = hexval(src[i++]) << 4;
575                 /* look for next hex digit */
576                 while (i < slen && !isxdigit(src[i])) {
577                         i++;
578                 }
579                 if (i == slen || !isxdigit(src[i])) {
580                         break; /* tests redundant, but make code clearer */
581                 }
582                 val += hexval(src[i]); /* low nibble */
583                 dst[n++] = val;
584         }
585
586         return n;
587 }
588
589 /* read in up to 248 bytes, set remaining to zero
590  * returns byte 5 if the bytes begin with "ZPMS" and 248 bytes were converted
591  * src must be at least 512 bytes
592  */
593 int deserialize(void *obj, uint8_t *src, size_t slen) {
594         int bytes, i, type;
595         char buf[256];
596
597         bytes = hex2bin(buf, 248, src, slen);
598
599         for (i = bytes; i < 256; i++) {
600                 buf[i] = 0;
601         }
602
603         if (bytes == 248 && memcmp(buf, "ZPMS", 4) == 0) {
604                 type = buf[5];
605         } else {
606                 return 0;
607         }
608
609         switch(type) {
610                 case SECRET_KEY:
611                         bytea_seckey(obj, buf);
612                         memset(buf, 0, sizeof buf);
613                         break;
614                 case PUBLIC_KEY:
615                         bytea_pubkey(obj, buf);
616                         break;
617                 case SIGNATURE:
618                         bytea_signature(obj, buf);
619                         break;
620                 default:
621                         type = UNKNOWN;
622                         break;
623         }
624
625         return type;
626 }
627
628 void *map(char *file, size_t *size) {
629         int fd, rv;
630         void *m;
631         struct stat st;
632
633         fd = open(file, O_RDONLY);
634         if (fd == -1) {
635                 return NULL;
636         }
637
638         rv = fstat(fd, &st);
639         if (rv == -1) {
640                 close(fd);
641                 return NULL;
642         }
643
644         m = mmap(0, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
645         if (m == MAP_FAILED) {
646                 return 0;
647         }
648
649         close(fd);
650         *size = st.st_size;
651         return m;
652 }
653
654 /* read 512 bytes from fd, returns -1 for error, 512 for full read,
655  * < 512 for end of file
656  */
657 ssize_t read512(int fd, void *dst) {
658         ssize_t bytes = 0;
659         ssize_t need = 512;
660         while (need) {
661                 bytes = read(fd, dst + 512 - need, need);
662                 if (bytes == -1) {
663                         return -1;
664                 }
665                 if (bytes == 0) {
666                         return 512 - need;
667                 }
668                 need -= bytes;
669         }
670         return 512;
671 }
672
673 int read_item(int fd, void *item) {
674         char buffer[512];
675         ssize_t bytes;
676         int type;
677
678         bytes = read512(fd, buffer);
679         if (bytes != 512) {
680                 return 0;
681         }
682         type = deserialize(item, buffer, sizeof buffer);
683         return type;
684 }
685
686 int write_secret_key(int fd, struct secret_key *sk, int outputflags) {
687         uint8_t skh[256];
688         char serialized[512];
689         size_t outlen;
690
691         if (outputflags & RAW) {
692                 hex(serialized, sk->key, 32);
693                 outlen = 64;
694         } else {
695                 seckey_bytea(skh, sk);
696                 serialize(serialized, skh);
697                 outlen = sizeof serialized;
698         }
699
700         write(fd, serialized, outlen);
701         /* clear memory */
702         memset(skh, 0, sizeof skh);
703         memset(serialized, 0, sizeof serialized);
704
705         return 1;
706 }
707
708 int write_public_key(int fd, struct public_key *pk, int outputflags) {
709         uint8_t skh[256];
710         char serialized[512];
711         size_t outlen;
712
713         if (outputflags & RAW) {
714                 hex(serialized, pk->key, 32);
715                 outlen = 64;
716         } else {
717                 pubkey_bytea(skh, pk);
718                 serialize(serialized, skh);
719                 outlen = sizeof serialized;
720         }
721
722         write(fd, serialized, outlen);
723         /* clear memory */
724         memset(skh, 0, sizeof skh);
725         memset(serialized, 0, sizeof serialized);
726
727         return 1;
728 }
729
730 int write_signature(int fd, struct signature *sig, int outputflags) {
731         uint8_t skh[256];
732         char serialized[512];
733         size_t outlen;
734
735         if (outputflags & RAW) {
736                 hex(serialized, sig->signature, 64);
737                 outlen = 128;
738         } else {
739                 signature_bytea(skh, sig);
740                 serialize(serialized, skh);
741                 outlen = sizeof serialized;
742         }
743
744         write(fd, serialized, outlen);
745         /* clear memory */
746         memset(skh, 0, sizeof skh);
747         memset(serialized, 0, sizeof serialized);
748
749         return 1;
750 }
751
752 int write_object(int fd, void *o, int outputflags) {
753         uint8_t bytes[256];
754         char serialized[512];
755         size_t outlen;
756         int type;
757         union signobject *obj = o;
758
759         type = ((struct secret_key *)obj)->type;
760
761         if (outputflags & RAW) {
762                 switch (type) {
763                         case 0x01: hex(serialized, obj->sk.key, 32);
764                                    outlen = 64;
765                                    break;
766                         case 0x02: hex(serialized, obj->pk.key, 32);
767                                    outlen = 64;
768                                    break;
769                         case 0x03: hex(serialized, obj->sig.signature, 64);
770                                    outlen = 128;
771                                    break;
772                         default:
773                                    return 0;
774                 }
775         } else {
776                 outlen = 512;
777                 switch (type) {
778                         case 0x01: seckey_bytea(bytes, &obj->sk); break;
779                         case 0x02: pubkey_bytea(bytes, &obj->pk); break;
780                         case 0x03: signature_bytea(bytes, &obj->sig); break;
781                         memset(bytes, 0, sizeof bytes);
782                         default: return 0;
783                 }
784                 serialize(serialized, bytes);
785         }
786
787         write(fd, serialized, outlen);
788         memset(serialized, 0, outlen);
789
790         return 1;
791 }
792
793 /* TODO work on strings, not file output */
794 void write_to_512(int fd, int output) {
795         char trailer[65];
796         memset(trailer, '-', 64);
797         trailer[64] = '\n';
798
799         while (output < 512) {
800                 int shortfall = 512 - output;
801                 if (shortfall >= 65) {
802                         write(fd, trailer, 65);
803                         output += 65;
804                         continue;
805                 }
806                 write(fd, trailer + (65-shortfall), shortfall);
807                 output += shortfall;
808         }
809 }
810
811 int dump_signature(int fd, struct signature *sig) {
812         char as_str[1024], key[64], sigstr[128];
813         int output;
814         int64_t curtime = time(0);
815
816         hex(key, sig->key, 32);
817         hex(sigstr, sig->signature, 64);
818
819         output = sprintf(as_str, "Type: %s\nSigned: %ld\n%s: %ld\nPublic Key: %s\nSignature:\n%.64s\n%.64s\n",
820                         "signature",
821                         sig->signtime,
822                         curtime > sig->expires ? "Expired" : "Expires",
823                         sig->expires, key,
824                         sigstr, sigstr+64);
825         write(fd, as_str, strlen(as_str));
826         write_to_512(fd, output);
827
828         return 1;
829 }
830
831 int dump_public_key(int fd, struct public_key *pk) {
832         char as_str[1024], key[64], sig[128];
833         int output;
834         int64_t curtime = time(0);
835
836         hex(key, pk->key, 32);
837         hex(sig, pk->signature, 64);
838
839         output = sprintf(as_str, "Type: %s\nId: \"%s\"\nCreated: %ld\n%s: %ld\nKey: %.64s\nSignature:\n%.64s\n%.64s\n",
840                         "public key",
841                         pk->id, pk->created,
842                         curtime > pk->expires ? "Expired" : "Expires",
843                         pk->expires, key,
844                         sig, sig+64);
845         write(fd, as_str, strlen(as_str));
846         write_to_512(fd, output);
847
848         return 1;
849 }
850
851 int dump_secret_key(int fd, struct secret_key *sk) {
852         char as_str[1024];
853         char key[64];
854         int output;
855         int64_t curtime = time(0);
856         char exprep[64];
857
858         hex(key, sk->key, 32);
859         if (sk->expires == INT64_MAX) {
860                 sprintf(exprep, "never");
861         } else {
862                 sprintf(exprep, "%ld", sk->expires);
863         }
864
865         output = sprintf(as_str, "Type: %s\nEncrypted: %s\nId: \"%s\"\nCreated: %ld\n%s: %s\nKey: %.64s\n",
866                         "secret key",
867                         sk->encryption ? "yes" : "no",
868                         sk->id, sk->created,
869                         curtime > sk->expires ? "Expired" : "Expires",
870                         exprep, key);
871         write(fd, as_str, strlen(as_str));
872         write_to_512(fd, output);
873
874         return 1;
875 }
876
877 int dump_object(int fd, void *obj) {
878         int rv;
879         switch (((struct secret_key *)obj)->type) {
880                 case 0x01: rv = dump_secret_key(fd, obj); break;
881                 case 0x02: rv = dump_public_key(fd, obj); break;
882                 case 0x03: rv = dump_signature(fd, obj); break;
883                 default: rv = 0; break;
884         }
885         return rv;
886 }
887
888 /* returns a malloced keyfile name.  no check is made to see if the
889  * file actually exists
890  */
891 char *find_keyfile(char *file) {
892         char *f = 0;
893
894         if (file) {
895                 f = strdup(file);
896         } else if (getenv("ZPM_KEYFILE")) {
897                 f = strdup(getenv("ZPM_KEYFILE"));
898         } else {
899                 char *home = getenv("HOME");
900                 if (home) {
901                         size_t need;
902                         need = snprintf(0, 0, "%s/.zpm/key", home);
903                         char *freefile = malloc(need + 1);
904                         if (freefile) {
905                                 snprintf(freefile, need+1, "%s/.zpm/key", home);
906                         }
907                         f = freefile;
908                 }
909         }
910
911         return f;
912 }
913
914 int obj_id_match(union signobject *obj, char *id) {
915         if (!obj || !id) {
916                 return 1;
917         }
918
919         switch(object_type(obj)) {
920                 case SECRET_KEY:
921                         return !strcmp(obj->sk.id, id);
922                         break;
923                 case PUBLIC_KEY:
924                         return !strcmp(obj->pk.id, id);
925                         break;
926                 default:
927                         return 1;
928                         break;
929         }
930
931         return 1;
932 }
933
934 int key_id_match(struct secret_key *sk, char *id) {
935         if (!sk && !id) {
936                 return 1;
937         }
938         /* TODO look for substring */
939         return !strcmp(sk->id, id);
940 }
941
942 /* try to populate a secret key structure.
943  * preference order:
944  * direct specified string, won't have any additional info added
945  * string from ZPM_KEY
946  * file, if id, try to match
947  * file from ZPM_KEYFILE
948  * file at ~/.zpm/key
949  * otherwise fail
950  * if direct from string, encrypted?  assume no.  need option then.
951  */
952
953 /* can probably just call read_item */
954 int read_object(int fd, union signobject *obj) {
955         char buf[512];
956         ssize_t bytes;
957         
958         bytes = read512(fd, buf);
959         if (bytes < 512) {
960                 return 0;
961         }
962
963         return deserialize(obj, buf, bytes);
964 }
965
966 int find_secret_key(struct secret_key *sk, char *id, char *file, char *direct) {
967         char *path = 0;
968         int fd, bytes;
969         size_t len;
970
971         if (direct || (direct = getenv("ZPM_KEY"))) {
972                 /* TODO check strlen == 64 */
973                 len = strlen(direct);
974                 if (len < 2 * sizeof sk->key) {
975                         return 2;
976                 }
977                 memset(sk->key, 0, sizeof sk->key);
978                 bytes = hex2bin(sk->key, sizeof sk->key, direct, len);
979                 if (bytes != sizeof sk->key) {
980                         return 0;
981                 }
982                 create_key(sk, 0);
983                 return 1;
984         } else if (file) {
985                 path = find_keyfile(file);
986                 if (!path) {
987                         return 0;
988                 }
989
990                 fd = open(path, O_RDONLY);
991                 free(path);
992                 if (fd == -1) {
993                         return 0;
994                 }
995
996                 int64_t curtime = time(0);
997                 int type;
998                 do {
999                         type = read_object(fd, (union signobject *)sk);
1000                         if (type != SECRET_KEY) {
1001                                 continue;
1002                         }
1003                         if (curtime > sk->expires) {
1004                                 continue;
1005                         }
1006                         if (!id || key_id_match(sk, id)) {
1007                                 close(fd);
1008                                 return 1;
1009                         }
1010                 } while (type != 0);
1011                 close(fd);
1012         }
1013
1014         return 0;
1015 }
1016
1017 int open_output(char *path) {
1018         int fd = 1;
1019
1020         if (path && strcmp(path, "-") != 0) {
1021                 fd = open(path, O_WRONLY|O_CREAT, 0600);
1022         }
1023
1024         return fd;
1025 }
1026
1027 void set_key_id(struct secret_key *sk, char *id) {
1028         memset(sk->id, 0, 120);
1029         if (id) {
1030                 strncpy(sk->id, id, 119);
1031         }
1032 }
1033
1034 void set_pub_id(struct public_key *sk, char *id) {
1035         memset(sk->id, 0, 120);
1036         if (id) {
1037                 strncpy(sk->id, id, 119);
1038         }
1039 }
1040
1041 int object_filter(union signobject *obj, int type, char *id, char *prefix) {
1042         int otype;
1043         size_t len;
1044
1045         otype = object_type(obj);
1046
1047         if (otype == 0) {
1048                 return 0;
1049         }
1050
1051         if (type && otype != type) {
1052                 return 0;
1053         }
1054
1055         if (otype != SECRET_KEY) {
1056                 return 0;
1057         }
1058
1059         if (id) {
1060                 /* TODO memmem */
1061                 if (!key_id_match(&obj->sk, id)) {
1062                         return 0;
1063                 }
1064         }
1065
1066         if (prefix) {
1067                 char buf[32];
1068                 len = strlen(prefix);
1069                 len = hex2bin(buf, sizeof buf, prefix, len);
1070                 if (memcmp(obj->sk.key, buf, len) != 0) {
1071                         return 0;
1072                 }
1073         }
1074
1075         return 1;
1076 }
1077
1078 /* read or construct a secret key */
1079 int find_key(struct secret_key *sk, struct signing_context *ctx) {
1080         char *keystring, *keyfile, *idstring, *keyprefix;
1081         size_t len;
1082
1083         keystring = ctx->keystring;
1084         keyfile = ctx->keyfile;
1085         idstring = ctx->keyid;
1086         keyprefix = ctx->keyprefix;
1087
1088         //fprintf(stderr, "looking for key, str = \"%s\", file = \"%s\", id = \"%s\", prefix = \"%s\"\n", keystring, keyfile, idstring, keyprefix);
1089
1090         if (keystring) {
1091                 len = strlen(keystring);
1092                 if (len < 64) {
1093                         return 0;
1094                 }
1095                 hex2bin(sk->key, sizeof sk->key, keystring, len);
1096                 create_key(sk, 0);
1097                 set_key_id(sk, idstring);
1098                 return 1;
1099         } else {
1100                 char *keyringfile = find_keyfile(keyfile);
1101                 if (!keyringfile) {
1102                         return 0;
1103                 }
1104                 int keyring = open(keyringfile, O_RDONLY);
1105                 union signobject obj;
1106                 int rv;
1107                 while ((rv = read_object(keyring, &obj))) {
1108                         if (rv != SECRET_KEY) {
1109                                 continue;
1110                         }
1111                         if (object_filter(&obj, SECRET_KEY, idstring, keyprefix)) {
1112                                 break;
1113                         }
1114                 }
1115                 close(keyring);
1116                 if (rv == 1) {
1117                         return 1;
1118                 }
1119         }
1120
1121         if (sk->encryption && ctx->passphrase) {
1122                 collect_key(ctx->passkey, ctx->passphrase);
1123                 decrypt_key(sk, ctx->passkey);
1124         }
1125
1126         return 0;
1127 }
1128
1129 /* flags: 1 = hex encoded, 2 = input is path */
1130 char *create_message(char *in, size_t *len, int flags) {
1131         char *msg = 0;
1132         if (in) {
1133                 if (flags == 2) {
1134                         msg = map(in, len);
1135                 } else if (flags == 1) {
1136                         *len = strlen(in);
1137                         msg = malloc(*len/2 + 2);
1138                         *len = hex2bin(msg, *len, in, *len);
1139                 } else {
1140                         *len = strlen(in);
1141                         msg = in;
1142                 }
1143         } else {
1144                 /* would need to read from stdin and buffer */
1145         }
1146
1147
1148         return msg;
1149 }
1150
1151 char *construct_message(char *ms, char *path, size_t *mlen, int flags) {
1152         char *msg = 0, *mapped = 0;
1153         *mlen = 0;
1154
1155         if (ms) {
1156                 *mlen = strlen(ms);
1157                 msg = ms;
1158         } else if (path) {
1159                 mapped = msg = map(path, mlen);
1160         }
1161
1162         if (flags) {
1163                 /* input is hex encoded */
1164                 char *new;
1165                 new = malloc(*mlen/2+1);
1166                 *mlen = hex2bin(new, *mlen/2+1, msg, *mlen);
1167                 msg = new;
1168         }
1169
1170         return msg;
1171 }
1172
1173         /* TODO should use mlock()ed memory for the secret key */
1174 #if 0
1175 #if _POSIX_ADVISORY_INFO > 0
1176         long pagesize = sysconf(_SC_PAGESIZE);
1177         int rv = posix_memalign(&sk, pagesize, sizeof *sk);
1178         if (rv) {
1179                 mlock(sk, sizeof sk);
1180                 /* not able to lock, use stack memory */
1181         } else {
1182                 /* not able to allocate, use stack memory */
1183         }
1184         /* TODO if the allocate or lock fails, try mlockall(),
1185          * if that fails, abort or perhaps continue if insecure mode */
1186         /* TODO also mlock buffers */
1187 #endif
1188 #endif
1189
1190 /* if flags == 0, then need to hash the message and the signature info
1191  * before verifying, otherwise, bare sign, so just verify
1192  */
1193 int verify(struct signature *sig, char *message, size_t mlen, int flags) {
1194         char hash[64];
1195
1196         if (flags == 0) {
1197                 sighash(hash, sig, message, mlen);
1198                 message = hash;
1199                 mlen = sizeof hash;
1200         }
1201
1202         return ed25519_verify(sig->signature, sig->key, message, mlen);
1203 }
1204
1205 int generate_key(struct secret_key *sk, char *keystring, char *idstring) {
1206         size_t len;
1207
1208         if (!sk) {
1209                 return 0;
1210         }
1211
1212         if (keystring) {
1213                 len = strlen(keystring);
1214                 if (len < 64) {
1215                         return 0;
1216                 }
1217                 hex2bin(sk->key, sizeof sk->key, keystring, len);
1218                 create_key(sk, 0);
1219         } else {
1220                 create_key(sk, 1);
1221         }
1222
1223         if (idstring) {
1224                 strncpy(sk->id, idstring, 119);
1225         }
1226
1227         return 1;
1228 }
1229
1230 int list_object(int fd, union signobject *obj) {
1231         if (fd >= 0 && obj) {
1232                 dump_object(fd, obj);
1233         }
1234         return 1;
1235 }
1236
1237 /* TODO can be just a find_key and take an arg */
1238 int find_public_key(struct public_key *pk, char *id, char *pstr, char *pfile) {
1239         char *path = 0, buf[32];
1240         int fd, bytes, type = 0;
1241         size_t len;
1242
1243         if (!pstr && !pfile) {
1244                 pstr = getenv("ZPM_PUBLIC_KEY");
1245         }
1246
1247         if (pstr) {
1248                 /* TODO check strlen == 64 */
1249                 len = strlen(pstr);
1250                 if (len >= 512) {
1251                         type = deserialize(pk, pstr, len);
1252                 } else if (len >= 64) {
1253                         bytes = hex2bin(buf, sizeof buf, pstr, len);
1254                         if (bytes == 32) {
1255                                 pubkey_init(pk);
1256                                 memcpy(pk->key, buf, 32);
1257                                 if (id) {
1258                                         set_pub_id(pk, id);
1259                                 }
1260                                 type = PUBLIC_KEY;
1261                         }
1262                 }
1263         } else if (pfile) {
1264                 path = find_keyfile(pfile);
1265                 if (!path) {
1266                         return 0;
1267                 }
1268
1269                 fd = open(path, O_RDONLY);
1270                 free(path);
1271                 if (fd == -1) {
1272                         return 0;
1273                 }
1274
1275                 int64_t curtime = time(0);
1276                 int type;
1277                 do {
1278                         type = read_object(fd, (union signobject *)pk);
1279                         if (type != PUBLIC_KEY) {
1280                                 continue;
1281                         }
1282                         if (curtime > pk->expires) {
1283                                 /* TODO warn? */
1284                                 continue;
1285                         }
1286                         if (!id || obj_id_match((union signobject *)pk, id)) {
1287                                 close(fd);
1288                                 return type;
1289                         }
1290                 } while (type != 0);
1291                 close(fd);
1292         }
1293
1294         return type;
1295 }
1296
1297 int find_signature(struct signature *sig, char *sigstring, char *sigfile) {
1298         size_t len;
1299         int type = 0;
1300         char *mapped = 0;
1301         char buf[64];
1302
1303         if (sigstring) {
1304                 len = strlen(sigstring);
1305                 if (len >= 512) {
1306                         type = deserialize(sig, sigstring, len);
1307                 } else if (len >= 128) {
1308                         len = hex2bin(buf, sizeof buf, sigstring, len);
1309                         if (len == 64) {
1310                                 init_signature(sig);
1311                                 memcpy(sig->signature, buf, 64);
1312                                 type = SIGNATURE;
1313                         }
1314                 }
1315         } else if (sigfile) {
1316                 mapped = map(sigfile, &len);
1317                 if (mapped && len >= 512) {
1318                         type = deserialize(sig, mapped, len);
1319                 }
1320         }
1321
1322         if (mapped) {
1323                 munmap(mapped, len);
1324         }
1325         return type;
1326 }
1327
1328 int object_match(union signobject *a, union signobject *b) {
1329         if (!a && !b) {
1330                 return 1;
1331         }
1332         if (!a || !b) {
1333                 return 0;
1334         }
1335
1336         if (object_type(a) != object_type(b)) {
1337                 return 0;
1338         }
1339
1340         if (object_type(a) == PUBLIC_KEY) {
1341                 return memcmp(a->pk.key, b->pk.key, 32) == 0;
1342         } else if (object_type(a) == SECRET_KEY) {
1343                 return memcmp(a->sk.key, b->sk.key, 32) == 0;
1344         } else if (object_type(a) == SIGNATURE) {
1345                 if (memcmp(a->sig.key, b->sig.key, 32) != 0) {
1346                         return 0;
1347                 }
1348                 return memcmp(a->sig.signature, b->sig.signature, 64) == 0;
1349         }
1350
1351         return 0;
1352 }
1353
1354 /* return true if we find something that matches obj */
1355 int find_object(int fd, union signobject *lookfor) {
1356         union signobject obj;
1357         while (read_object(fd, &obj) > 0) {
1358                 if (object_match(lookfor, &obj)) {
1359                         return 1;
1360                 }
1361         }
1362
1363         return 0;
1364 }
1365 #include <sys/time.h>
1366 #include <sys/resource.h>
1367
1368 int main(int ac, char *av[]) {
1369         /*
1370          * M = message, P = public key, K = secret key, S = signature
1371          * T = timestamp, E = expires, I = identity, H = message hash
1372          * C = ciphertext, W = password
1373          */
1374         struct signing_context ctx = { 0 };
1375
1376         unsigned char *message = 0;
1377         size_t mlen;
1378         char *messagefile = 0;
1379         char *messagestring = 0;
1380
1381         char *timestring = 0, *expirestring = 0;
1382         int64_t timestamp = 0, expires = INT64_MAX;
1383
1384         char *passphrase = 0;
1385         unsigned char passkey[32];
1386
1387         char *keyid = 0, *keyprefix = 0;
1388         struct secret_key sk = { 0 };
1389         char *keyfile = 0, *keystring = 0;
1390
1391         struct public_key pk = { 0 };
1392         char *pubfile = 0, *pubstring = 0;
1393
1394         struct signature sig = { 0 };
1395         char *sigfile = 0, *sigstring = 0;
1396
1397         char *encfile = 0, *encstring = 0;
1398         char *outfile = 0;
1399         int output = 1; /* file descriptor */
1400
1401         int option, argn;
1402         int mode = 0;
1403
1404         int hexencoded = 0, outputflags = 0;
1405         int debug = 0, quiet = 0, bareinput = 0;
1406         int outputmsghash = 0;
1407         int rv;
1408
1409 #if 0
1410 #if _POSIX_ADVISORY_INFO > 0
1411         fprintf(stderr, "locking memory\n");
1412         struct rlimit lim;
1413         getrlimit(RLIMIT_MEMLOCK, &lim);
1414         fprintf(stderr, "memlock limit %llu/%llu\n", lim.rlim_cur, lim.rlim_max);
1415         struct public_key *pkp;
1416         posix_memalign(&pkp, 
1417         rv = mlockall(MCL_CURRENT|MCL_FUTURE); /* can't happen, have to just
1418                                                   lock sk and maybe ctx */
1419         if (rv == -1) {
1420                 perror("unable to lock memory");
1421         }
1422 #endif
1423 #endif
1424
1425         while ((option = getopt(ac, av, "vsgelxyirdHo:hbT:E:n:w:m:N:k:K:p:P:f:F:c:C:")) != -1) {
1426                 switch (option) {
1427                         /* modes */
1428                         case 'v': mode = VERIFY; break;
1429                         case 's': mode = SIGN; break;
1430                         case 'g': mode = KEYGEN; break;
1431                         case 'e': mode = EXTRACT; break;
1432                         case 'l': mode = LIST; break;
1433                         case 'x': mode = ENCRYPT; break;
1434                         case 'y': mode = DECRYPT; break;
1435                         case 'i': mode = IMPORT; break;
1436                                   /* more modes:
1437                                    * remove pw, add pw, export, delete
1438                                    * need a manage mode to delete
1439                                    * or update keys
1440                                    */
1441 #if 0
1442                         /* trust level */
1443                         case 't': trust = strtoul(optarg, 0, 10); break;
1444 #endif
1445                                   /* outputs */
1446                         case 'r': outputflags |= RAW; break;
1447                         case 'd': debug++; break;
1448                         case 'H': outputmsghash = 1; break;
1449                         case 'o': outfile = optarg; break;
1450                         case 'q': quiet++; break;
1451
1452                                   /* inputs */
1453                         case 'h': hexencoded = 1; break;
1454                         case 'b': bareinput = 1; break;
1455                         case 'T': timestring = optarg; break; /* T */
1456                         case 'E': expirestring = optarg; break; /* E */
1457                         case 'n': keyid = optarg; break; /* I */
1458                         case 'w': passphrase = optarg; break; /* W */
1459                         case 'm': messagestring = optarg; break; /* M */
1460                         case 'N': keyprefix = optarg; break; /* K ish */
1461                         case 'k': keyfile = optarg; break; /* K */
1462                         case 'K': keystring = optarg; break; /* K */
1463                         case 'p': pubfile = optarg; break; /* P */
1464                         case 'P': pubstring = optarg; break; /* P */
1465                         case 'f': sigfile = optarg; break; /* S */
1466                         case 'F': sigstring = optarg; break; /* S */
1467                         case 'c': encfile = optarg; break; /* C */
1468                         case 'C': encstring = optarg; break; /* C */
1469
1470                         default:
1471                                   exit(EXIT_FAILURE);
1472                                   break;
1473                 }
1474         }
1475
1476         argn = optind;
1477
1478         /*
1479          * M = message, P = public key, K = secret key, S = signature
1480          * T = timestamp, E = expires, I = identity, H = message hash
1481          * C = ciphertext, W = password
1482          *
1483          * -sb bare data sign (M, K) -> S
1484          * -s full data sign ( (M,T,E) -> H, K) -> S
1485          * -s key sign ( (P,T,E) -> H, K) -> S
1486          * -e extract (K) -> P
1487          * -g generate (T, E, I) -> K (default to keyring append)
1488          * -g generate (K, T, E, I) -> K (default to keyring append)
1489          *    self sign ( (K->P,T,E,I) -> H, M) -> S
1490          * import (K/P/S) -> keyring file append, stdout daft, unless redir
1491          * show (K/P/S) -> output input
1492          * -l list keys (K/P/S) -> key list, get from -k
1493          * -v verify (M, S) -> boolean, via exit value, no output
1494          * -x encrypt (M, K, T, E, P...) -> C
1495          * -y decrypt (C, K) -> M
1496          * -H generate signing hash for message or key
1497          *
1498          * output style: serialized, -d human readable, -r raw
1499          * input style: serialized, -b bare, -h hexencoded
1500          *
1501          * possible inputs: M K T E P I S C
1502          * M -> from -m, non-option arg, stdin
1503          * K -> from -K, ZPM_KEY, -k, ZPM_KEYFILE, ~/.zpm/key
1504          * P -> from -P, -p
1505          * S -> from -F, -f, second arg?
1506          * C -> from -C, -c, non-option arg, stdin
1507          * T -> from -T, time(NULL)
1508          * E -> from -E, never/-1
1509          * I -> from -n, ZPM_KEYID, K, S, null
1510          * W -> from -w, ZPM_PASS, ~/.zpm/pass, terminal
1511          */
1512
1513         if (timestring) {
1514                 timestamp = strtoull(timestring, 0, 10);
1515         } else {
1516                 timestamp = time(NULL);
1517         }
1518
1519         if (expirestring) {
1520                 expires = strtoull(expirestring, 0, 10);
1521         }
1522
1523         ctx.keystring = keystring;
1524         ctx.keyfile = keyfile;
1525         ctx.keyid = keyid;
1526         ctx.keyprefix = keyprefix;
1527         ctx.passphrase = passphrase;
1528
1529         if (mode == KEYGEN) {
1530                 rv = generate_key(&sk, keystring, keyid);
1531                 if (!rv) {
1532                         exit(EXIT_FAILURE);
1533                 }
1534                 sk.created = timestamp;
1535                 sk.expires = expires;
1536         } else if (mode == SIGN) {
1537                 char *firstarg = av[argn];
1538                 rv = find_key(&sk, &ctx);
1539                 if (!rv) {
1540                         fprintf(stderr, "unable to find signing key\n");
1541                         exit(EXIT_FAILURE);
1542                 }
1543                 char *message = construct_message(messagestring, firstarg, &mlen, hexencoded);
1544                 // dump_secret_key(2, &sk);
1545                 sig.signtime = timestamp;
1546                 sig.expires = expires;
1547                 rv = create_signature(&sig, &sk, bareinput, message, mlen);
1548                 if (!rv) {
1549                         exit(EXIT_FAILURE);
1550                 }
1551                 // dump_signature(2, &sig);
1552         } else if (mode == SIGNKEY) {
1553                 find_key(&sk, &ctx);
1554                 find_public_key(&pk, keyid, pubstring, pubfile);
1555                 /* TODO construct a message out of a public key */
1556                 mlen = 0;
1557                 sig.signtime = timestamp;
1558                 sig.expires = expires;
1559                 rv = create_signature(&sig, &sk, 0, message, mlen);
1560                 if (!rv) {
1561                         exit(EXIT_FAILURE);
1562                 }
1563         } else if (mode == EXTRACT) {
1564                 rv = find_key(&sk, &ctx);
1565                 if (passphrase) {
1566                         decrypt_sk(&sk, passphrase);
1567                 }
1568                 if (!rv) {
1569                         exit(EXIT_FAILURE);
1570                 }
1571                 derive_pubkey(&pk, &sk);
1572         } else if (mode == VERIFY) {
1573                 rv = find_signature(&sig, sigstring, sigfile);
1574                 if (rv == SIGNATURE) {
1575                         /* if you've specified the public key in a verify op,
1576                          * you probably know what you're doing
1577                          */
1578                         if (pubstring || pubfile) {
1579                                 rv = find_public_key(&pk, keyid, pubstring, pubfile);
1580                                 if (rv == PUBLIC_KEY) {
1581                                         memcpy(sig.key, pk.key, 32);
1582                                 }
1583                         }
1584                         //dump_signature(2, &sig);
1585
1586                         message = construct_message(messagestring, av[argn], &mlen, hexencoded);
1587                         rv = verify(&sig, message, mlen, bareinput);
1588                 } else {
1589                         rv = 0;
1590                 }
1591         } else if (mode == LIST) {
1592                 union signobject obj;
1593                 char *keyringfile = find_keyfile(keyfile);
1594                 if (!keyringfile) {
1595                         fprintf(stderr, "can't find keyring file\n");
1596                         exit(1);
1597                 }
1598                 int keyring = open(keyringfile, O_RDWR|O_APPEND);
1599                 if (keyring == -1) {
1600                         fprintf(stderr, "can't open keyring file %s\n", keyringfile);
1601                         perror("");
1602                         exit(EXIT_FAILURE);
1603                 }
1604                 while ((rv = read_object(keyring, &obj))) {
1605                         list_object(output, &obj);
1606                 }
1607                 close(keyring);
1608         } else if (mode == IMPORT) {
1609                 int fd, i, rv;
1610                 union signobject obj;
1611                 char *keyringfile = find_keyfile(keyfile);
1612                 int keyring = open(keyringfile, O_RDWR|O_APPEND);
1613                 if (keyring == -1) {
1614                         fprintf(stderr, "%s ", keyringfile);
1615                         perror("");
1616                         exit(EXIT_FAILURE);
1617                 }
1618                 for (i = argn; i < ac; i++) {
1619                         fd = open(av[i], O_RDONLY);
1620                         if (fd == -1) {
1621                                 fprintf(stderr, "%s ", av[i]);
1622                                 perror("");
1623                                 rv = 0;
1624                                 close(keyring);
1625                                 exit(EXIT_FAILURE);
1626                         }
1627                         while ((rv = read_object(fd, &obj))) {
1628                                 fprintf(stderr, "importing type %d\n", object_type(&obj));
1629                                 /* TODO probably a more efficient way to do
1630                                  * this.  Perhaps read in the keyring to
1631                                  * memory. */
1632                                 lseek(keyring, 0, SEEK_SET);
1633                                 if (!find_object(keyring, &obj)) {
1634                                         write_object(keyring, &obj, outputflags);
1635                                 }
1636                         }
1637                         close(fd);
1638                 }
1639                 close(keyring);
1640         } else if (mode == ENCRYPT) {
1641                 fprintf(stderr, "encryption not supported\n");
1642                 exit(EXIT_FAILURE);
1643         } else if (mode == DECRYPT) {
1644                 fprintf(stderr, "decryption not supported\n");
1645                 exit(EXIT_FAILURE);
1646         }
1647
1648         /*
1649          * now, do the action
1650          */
1651
1652         if (mode == KEYGEN) {
1653                 if (!outfile) {
1654                         outfile = find_keyfile(keyfile);
1655                 }
1656                 if (outfile && strcmp(outfile, "-") != 0) {
1657                         output = open(outfile, O_RDWR|O_CREAT|O_APPEND, 0600);
1658                 }
1659                 /* TODO encrypt key */
1660                 if (passphrase) {
1661                         fprintf(stderr, "encrypting key\n");
1662                         collect_key(passkey, passphrase);
1663                         encrypt_key(&sk, passkey);
1664                         //memset(passphrase, 0, strlen(passphrase));
1665                         memset(passkey, 0, 32);
1666                 }
1667                 // dump_secret_key(2, &sk);
1668                 write_secret_key(output, &sk, outputflags);
1669         } else if (mode == SIGN || mode == SIGNKEY) {
1670                 if (outfile && strcmp(outfile, "-") != 0) {
1671                         output = open(outfile, O_RDWR|O_CREAT|O_APPEND, 0600);
1672                 }
1673                 //dump_signature(2, &sig);
1674                 write_signature(output, &sig, outputflags);
1675         } else if (mode == EXTRACT) {
1676                 if (outfile && strcmp(outfile, "-") != 0) {
1677                         output = open(outfile, O_RDWR|O_CREAT|O_APPEND, 0600);
1678                 }
1679                 // dump_public_key(2, &pk);
1680                 write_public_key(output, &pk, outputflags);
1681         } else if (mode == VERIFY) {
1682                 exit(rv ? 0 : 1);
1683         } else if (mode == LIST) {
1684                 /* handled above */
1685         } else if (mode == IMPORT) {
1686                 /* handled above */
1687         } else if (mode == ENCRYPT) {
1688                 fprintf(stderr, "encryption not supported\n");
1689                 exit(EXIT_FAILURE);
1690         } else if (mode == DECRYPT) {
1691                 fprintf(stderr, "decryption not supported\n");
1692                 exit(EXIT_FAILURE);
1693         }
1694
1695         if (message && messagefile) {
1696                 munmap(message, mlen);
1697         }
1698
1699         memset(sk.key, 0, sizeof sk.key);
1700         return 0;
1701 }