1*ae4dfda2Skn /* $OpenBSD: signify.c,v 1.136 2022/08/26 00:24:56 kn Exp $ */
24215a5deStedu /*
34215a5deStedu * Copyright (c) 2013 Ted Unangst <tedu@openbsd.org>
44215a5deStedu *
54215a5deStedu * Permission to use, copy, modify, and distribute this software for any
64215a5deStedu * purpose with or without fee is hereby granted, provided that the above
74215a5deStedu * copyright notice and this permission notice appear in all copies.
84215a5deStedu *
94215a5deStedu * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
104215a5deStedu * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
114215a5deStedu * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
124215a5deStedu * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
134215a5deStedu * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
144215a5deStedu * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
154215a5deStedu * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
164215a5deStedu */
174215a5deStedu #include <sys/stat.h>
184215a5deStedu
194215a5deStedu #include <netinet/in.h>
204215a5deStedu #include <resolv.h>
214215a5deStedu
22f30a54aaStedu #include <limits.h>
234215a5deStedu #include <stdint.h>
244215a5deStedu #include <fcntl.h>
254215a5deStedu #include <string.h>
264215a5deStedu #include <stdio.h>
27ebde6afdStedu #include <stdlib.h>
285e4b5029Stedu #include <stddef.h>
295e4b5029Stedu #include <ohash.h>
304215a5deStedu #include <err.h>
314215a5deStedu #include <unistd.h>
324215a5deStedu #include <readpassphrase.h>
334215a5deStedu #include <util.h>
344215a5deStedu #include <sha2.h>
354215a5deStedu
364215a5deStedu #include "crypto_api.h"
373ccd7401Sespie #include "signify.h"
384215a5deStedu
394215a5deStedu #define SIGBYTES crypto_sign_ed25519_BYTES
404215a5deStedu #define SECRETBYTES crypto_sign_ed25519_SECRETKEYBYTES
414215a5deStedu #define PUBLICBYTES crypto_sign_ed25519_PUBLICKEYBYTES
424215a5deStedu
434215a5deStedu #define PKALG "Ed"
444215a5deStedu #define KDFALG "BK"
45534dbeadStedu #define KEYNUMLEN 8
461c9c770cStedu
471c9c770cStedu #define COMMENTHDR "untrusted comment: "
481453d2a0Stedu #define COMMENTHDRLEN 19
491453d2a0Stedu #define COMMENTMAXLEN 1024
500f212b48Stedu #define VERIFYWITH "verify with "
514215a5deStedu
524215a5deStedu struct enckey {
534215a5deStedu uint8_t pkalg[2];
544215a5deStedu uint8_t kdfalg[2];
554215a5deStedu uint32_t kdfrounds;
564215a5deStedu uint8_t salt[16];
574215a5deStedu uint8_t checksum[8];
58534dbeadStedu uint8_t keynum[KEYNUMLEN];
594215a5deStedu uint8_t seckey[SECRETBYTES];
604215a5deStedu };
614215a5deStedu
624215a5deStedu struct pubkey {
634215a5deStedu uint8_t pkalg[2];
64534dbeadStedu uint8_t keynum[KEYNUMLEN];
654215a5deStedu uint8_t pubkey[PUBLICBYTES];
664215a5deStedu };
674215a5deStedu
684215a5deStedu struct sig {
694215a5deStedu uint8_t pkalg[2];
70534dbeadStedu uint8_t keynum[KEYNUMLEN];
714215a5deStedu uint8_t sig[SIGBYTES];
724215a5deStedu };
734215a5deStedu
748155533aStedu static void __dead
usage(const char * error)75f2adbe28Stedu usage(const char *error)
764215a5deStedu {
77f2adbe28Stedu if (error)
78f2adbe28Stedu fprintf(stderr, "%s\n", error);
7942efb9f2Sespie fprintf(stderr, "usage:"
8035e4c3d2Sespie #ifndef VERIFYONLY
8145efba1eStb "\t%1$s -C [-q] [-p pubkey] [-t keytype] -x sigfile [file ...]\n"
82f2adbe28Stedu "\t%1$s -G [-n] [-c comment] -p pubkey -s seckey\n"
83c610539bStedu "\t%1$s -S [-enz] [-x sigfile] -s seckey -m message\n"
8435e4c3d2Sespie #endif
85915581b0Sespie "\t%1$s -V [-eqz] [-p pubkey] [-t keytype] [-x sigfile] -m message\n",
863301e1c6Stedu getprogname());
874215a5deStedu exit(1);
884215a5deStedu }
894215a5deStedu
903ccd7401Sespie int
xopen(const char * fname,int oflags,mode_t mode)918e162516Sderaadt xopen(const char *fname, int oflags, mode_t mode)
924215a5deStedu {
93ead0b14bStedu struct stat sb;
944215a5deStedu int fd;
954215a5deStedu
96f2adbe28Stedu if (strcmp(fname, "-") == 0) {
978e162516Sderaadt if ((oflags & O_WRONLY))
98f2adbe28Stedu fd = dup(STDOUT_FILENO);
99f2adbe28Stedu else
100f2adbe28Stedu fd = dup(STDIN_FILENO);
101f2adbe28Stedu if (fd == -1)
102f2adbe28Stedu err(1, "dup failed");
103f2adbe28Stedu } else {
1048e162516Sderaadt fd = open(fname, oflags, mode);
1054215a5deStedu if (fd == -1)
106f2adbe28Stedu err(1, "can't open %s for %s", fname,
1078e162516Sderaadt (oflags & O_WRONLY) ? "writing" : "reading");
108f2adbe28Stedu }
109ead0b14bStedu if (fstat(fd, &sb) == -1 || S_ISDIR(sb.st_mode))
1105d586c2bStedu errx(1, "not a valid file: %s", fname);
1114215a5deStedu return fd;
1124215a5deStedu }
1134215a5deStedu
1143ccd7401Sespie void *
xmalloc(size_t len)1154215a5deStedu xmalloc(size_t len)
1164215a5deStedu {
1174215a5deStedu void *p;
1184215a5deStedu
119dba2cf70Stedu if (!(p = malloc(len)))
1204215a5deStedu err(1, "malloc %zu", len);
1214215a5deStedu return p;
1224215a5deStedu }
1234215a5deStedu
12427f66874Stedu static size_t
parseb64file(const char * filename,char * b64,void * buf,size_t buflen,char * comment)1250ce08f52Stedu parseb64file(const char *filename, char *b64, void *buf, size_t buflen,
1261453d2a0Stedu char *comment)
12727f66874Stedu {
12827f66874Stedu char *commentend, *b64end;
12927f66874Stedu
13027f66874Stedu commentend = strchr(b64, '\n');
13127f66874Stedu if (!commentend || commentend - b64 <= COMMENTHDRLEN ||
1327d7c2057Stedu memcmp(b64, COMMENTHDR, COMMENTHDRLEN) != 0)
13327f66874Stedu errx(1, "invalid comment in %s; must start with '%s'",
13427f66874Stedu filename, COMMENTHDR);
135d502e9a0Stedu *commentend = '\0';
136ce3e40b1Sderaadt if (comment) {
137ce3e40b1Sderaadt if (strlcpy(comment, b64 + COMMENTHDRLEN,
138ce3e40b1Sderaadt COMMENTMAXLEN) >= COMMENTMAXLEN)
13941b393a4Stedu errx(1, "comment too long");
140ce3e40b1Sderaadt }
141dba2cf70Stedu if (!(b64end = strchr(commentend + 1, '\n')))
1422c706440Stedu errx(1, "missing new line after base64 in %s", filename);
143d502e9a0Stedu *b64end = '\0';
144e67d6036Stedu if (b64_pton(commentend + 1, buf, buflen) != buflen)
145f87dcb1dStedu errx(1, "unable to parse %s", filename);
1467d7c2057Stedu if (memcmp(buf, PKALG, 2) != 0)
14727f66874Stedu errx(1, "unsupported file %s", filename);
1485294c223Sespie *commentend = '\n';
1495294c223Sespie *b64end = '\n';
15027f66874Stedu return b64end - b64 + 1;
15127f66874Stedu }
15227f66874Stedu
1534215a5deStedu static void
readb64file(const char * filename,void * buf,size_t buflen,char * comment)1540ce08f52Stedu readb64file(const char *filename, void *buf, size_t buflen, char *comment)
1554215a5deStedu {
1564215a5deStedu char b64[2048];
157f030c3d3Stedu int rv, fd;
1584215a5deStedu
1594215a5deStedu fd = xopen(filename, O_RDONLY | O_NOFOLLOW, 0);
160dba2cf70Stedu if ((rv = read(fd, b64, sizeof(b64) - 1)) == -1)
161d59d433dSespie err(1, "read from %s", filename);
162d502e9a0Stedu b64[rv] = '\0';
1630ce08f52Stedu parseb64file(filename, b64, buf, buflen, comment);
164c1ca80caStedu explicit_bzero(b64, sizeof(b64));
1654215a5deStedu close(fd);
1664215a5deStedu }
1674215a5deStedu
168eee7f9deStedu static uint8_t *
readmsg(const char * filename,unsigned long long * msglenp)1694215a5deStedu readmsg(const char *filename, unsigned long long *msglenp)
1704215a5deStedu {
171a30f80dbStedu unsigned long long msglen = 0;
172a30f80dbStedu uint8_t *msg = NULL;
1734215a5deStedu struct stat sb;
174a30f80dbStedu ssize_t x, space;
1754215a5deStedu int fd;
176ff9a6787Stedu const unsigned long long maxmsgsize = 1UL << 30;
1774215a5deStedu
1784215a5deStedu fd = xopen(filename, O_RDONLY | O_NOFOLLOW, 0);
179a30f80dbStedu if (fstat(fd, &sb) == 0 && S_ISREG(sb.st_mode)) {
180ff9a6787Stedu if (sb.st_size > maxmsgsize)
181a30f80dbStedu errx(1, "msg too large in %s", filename);
182a30f80dbStedu space = sb.st_size + 1;
183a30f80dbStedu } else {
184d6c685c1Stedu space = 64 * 1024 - 1;
185a30f80dbStedu }
186a30f80dbStedu
1879083d0fcStedu msg = xmalloc(space + 1);
188a30f80dbStedu while (1) {
189a30f80dbStedu if (space == 0) {
190ff9a6787Stedu if (msglen * 2 > maxmsgsize)
1919083d0fcStedu errx(1, "msg too large in %s", filename);
1929083d0fcStedu space = msglen;
193a30f80dbStedu if (!(msg = realloc(msg, msglen + space + 1)))
19464e2033cStedu err(1, "realloc");
195a30f80dbStedu }
196a30f80dbStedu if ((x = read(fd, msg + msglen, space)) == -1)
197a30f80dbStedu err(1, "read from %s", filename);
198a30f80dbStedu if (x == 0)
199a30f80dbStedu break;
200a30f80dbStedu space -= x;
201a30f80dbStedu msglen += x;
202a30f80dbStedu }
203a30f80dbStedu
204d502e9a0Stedu msg[msglen] = '\0';
2054215a5deStedu close(fd);
2064215a5deStedu
2074215a5deStedu *msglenp = msglen;
2084215a5deStedu return msg;
2094215a5deStedu }
2104215a5deStedu
2113ccd7401Sespie void
writeall(int fd,const void * buf,size_t buflen,const char * filename)2120ce08f52Stedu writeall(int fd, const void *buf, size_t buflen, const char *filename)
2134215a5deStedu {
2147dec58f2Stedu ssize_t x;
2157dec58f2Stedu
2160ce08f52Stedu while (buflen != 0) {
217dba2cf70Stedu if ((x = write(fd, buf, buflen)) == -1)
218d59d433dSespie err(1, "write to %s", filename);
2190ce08f52Stedu buflen -= x;
220bcd4d29fSespie buf = (char *)buf + x;
221bcd4d29fSespie }
222d59d433dSespie }
2234215a5deStedu
2246ffce13fSderaadt #ifndef VERIFYONLY
2259b252276Stedu static char *
createheader(const char * comment,const void * buf,size_t buflen)2269b252276Stedu createheader(const char *comment, const void *buf, size_t buflen)
2274215a5deStedu {
2289b252276Stedu char *header;
2294215a5deStedu char b64[1024];
2309b252276Stedu
2319b252276Stedu if (b64_ntop(buf, buflen, b64, sizeof(b64)) == -1)
2329b252276Stedu errx(1, "base64 encode failed");
2339b252276Stedu if (asprintf(&header, "%s%s\n%s\n", COMMENTHDR, comment, b64) == -1)
2349b252276Stedu err(1, "asprintf failed");
2359b252276Stedu explicit_bzero(b64, sizeof(b64));
2369b252276Stedu return header;
2379b252276Stedu }
2389b252276Stedu
2399b252276Stedu static void
writekeyfile(const char * filename,const char * comment,const void * buf,size_t buflen,int oflags,mode_t mode)2409b252276Stedu writekeyfile(const char *filename, const char *comment, const void *buf,
2419b252276Stedu size_t buflen, int oflags, mode_t mode)
2429b252276Stedu {
2439b252276Stedu char *header;
2449b252276Stedu int fd;
2454215a5deStedu
2468e162516Sderaadt fd = xopen(filename, O_CREAT|oflags|O_NOFOLLOW|O_WRONLY, mode);
2479b252276Stedu header = createheader(comment, buf, buflen);
248d59d433dSespie writeall(fd, header, strlen(header), filename);
2497c51e329Sderaadt freezero(header, strlen(header));
2504215a5deStedu close(fd);
2514215a5deStedu }
2524215a5deStedu
2534215a5deStedu static void
kdf(uint8_t * salt,size_t saltlen,int rounds,int allowstdin,int confirm,uint8_t * key,size_t keylen)254fdf669dbStedu kdf(uint8_t *salt, size_t saltlen, int rounds, int allowstdin, int confirm,
2554333161aStedu uint8_t *key, size_t keylen)
2564215a5deStedu {
2574215a5deStedu char pass[1024];
2582adf8afcStedu int rppflags = RPP_ECHO_OFF;
2593873fb89Stedu const char *errstr = NULL;
2604215a5deStedu
2614215a5deStedu if (rounds == 0) {
2624215a5deStedu memset(key, 0, keylen);
2634215a5deStedu return;
2644215a5deStedu }
2654215a5deStedu
2664333161aStedu if (allowstdin && !isatty(STDIN_FILENO))
2672adf8afcStedu rppflags |= RPP_STDIN;
2682adf8afcStedu if (!readpassphrase("passphrase: ", pass, sizeof(pass), rppflags))
26958ac87a3Stedu errx(1, "unable to read passphrase");
2700e5a52c1Stedu if (strlen(pass) == 0)
2710e5a52c1Stedu errx(1, "please provide a password");
272fdf669dbStedu if (confirm && !(rppflags & RPP_STDIN)) {
273fdf669dbStedu char pass2[1024];
274fdf669dbStedu if (!readpassphrase("confirm passphrase: ", pass2,
275fdf669dbStedu sizeof(pass2), rppflags))
2763873fb89Stedu errstr = "unable to read passphrase";
2773873fb89Stedu if (!errstr && strcmp(pass, pass2) != 0)
2783873fb89Stedu errstr = "passwords don't match";
279fdf669dbStedu explicit_bzero(pass2, sizeof(pass2));
280fdf669dbStedu }
2813873fb89Stedu if (!errstr && bcrypt_pbkdf(pass, strlen(pass), salt, saltlen, key,
2824215a5deStedu keylen, rounds) == -1)
2833873fb89Stedu errstr = "bcrypt pbkdf";
284c1ca80caStedu explicit_bzero(pass, sizeof(pass));
2853873fb89Stedu if (errstr)
2863873fb89Stedu errx(1, "%s", errstr);
2874215a5deStedu }
2884215a5deStedu
2894215a5deStedu static void
signmsg(uint8_t * seckey,uint8_t * msg,unsigned long long msglen,uint8_t * sig)2904215a5deStedu signmsg(uint8_t *seckey, uint8_t *msg, unsigned long long msglen,
2914215a5deStedu uint8_t *sig)
2924215a5deStedu {
2934215a5deStedu unsigned long long siglen;
2944215a5deStedu uint8_t *sigbuf;
2954215a5deStedu
2964215a5deStedu sigbuf = xmalloc(msglen + SIGBYTES);
2974215a5deStedu crypto_sign_ed25519(sigbuf, &siglen, msg, msglen, seckey);
2984215a5deStedu memcpy(sig, sigbuf, SIGBYTES);
2994215a5deStedu free(sigbuf);
3004215a5deStedu }
3014215a5deStedu
3024215a5deStedu static void
generate(const char * pubkeyfile,const char * seckeyfile,int rounds,const char * comment)303bd7b638bStedu generate(const char *pubkeyfile, const char *seckeyfile, int rounds,
304bd7b638bStedu const char *comment)
3054215a5deStedu {
3064215a5deStedu uint8_t digest[SHA512_DIGEST_LENGTH];
3074215a5deStedu struct pubkey pubkey;
3084215a5deStedu struct enckey enckey;
3094215a5deStedu uint8_t xorkey[sizeof(enckey.seckey)];
310534dbeadStedu uint8_t keynum[KEYNUMLEN];
311bd7b638bStedu char commentbuf[COMMENTMAXLEN];
3124215a5deStedu SHA2_CTX ctx;
313b3fe1a3aStedu int i, nr;
3144215a5deStedu
3154215a5deStedu crypto_sign_ed25519_keypair(pubkey.pubkey, enckey.seckey);
316534dbeadStedu arc4random_buf(keynum, sizeof(keynum));
3174215a5deStedu
3184215a5deStedu SHA512Init(&ctx);
3194215a5deStedu SHA512Update(&ctx, enckey.seckey, sizeof(enckey.seckey));
3204215a5deStedu SHA512Final(digest, &ctx);
3214215a5deStedu
3224215a5deStedu memcpy(enckey.pkalg, PKALG, 2);
3234215a5deStedu memcpy(enckey.kdfalg, KDFALG, 2);
3244215a5deStedu enckey.kdfrounds = htonl(rounds);
325534dbeadStedu memcpy(enckey.keynum, keynum, KEYNUMLEN);
3264215a5deStedu arc4random_buf(enckey.salt, sizeof(enckey.salt));
327fdf669dbStedu kdf(enckey.salt, sizeof(enckey.salt), rounds, 1, 1, xorkey, sizeof(xorkey));
3284215a5deStedu memcpy(enckey.checksum, digest, sizeof(enckey.checksum));
3294215a5deStedu for (i = 0; i < sizeof(enckey.seckey); i++)
3304215a5deStedu enckey.seckey[i] ^= xorkey[i];
331c1ca80caStedu explicit_bzero(digest, sizeof(digest));
332c1ca80caStedu explicit_bzero(xorkey, sizeof(xorkey));
3334215a5deStedu
334924f56e4Stedu nr = snprintf(commentbuf, sizeof(commentbuf), "%s secret key", comment);
335515e489cSderaadt if (nr < 0 || nr >= sizeof(commentbuf))
33641b393a4Stedu errx(1, "comment too long");
3379b252276Stedu writekeyfile(seckeyfile, commentbuf, &enckey,
3389b252276Stedu sizeof(enckey), O_EXCL, 0600);
339c1ca80caStedu explicit_bzero(&enckey, sizeof(enckey));
3404215a5deStedu
3414215a5deStedu memcpy(pubkey.pkalg, PKALG, 2);
342534dbeadStedu memcpy(pubkey.keynum, keynum, KEYNUMLEN);
343924f56e4Stedu nr = snprintf(commentbuf, sizeof(commentbuf), "%s public key", comment);
344515e489cSderaadt if (nr < 0 || nr >= sizeof(commentbuf))
34541b393a4Stedu errx(1, "comment too long");
3469b252276Stedu writekeyfile(pubkeyfile, commentbuf, &pubkey,
3479b252276Stedu sizeof(pubkey), O_EXCL, 0666);
3489b252276Stedu }
3499b252276Stedu
3503a4a9206Sespie static const char *
check_keyname_compliance(const char * pubkeyfile,const char * seckeyfile)351763e1148Stedu check_keyname_compliance(const char *pubkeyfile, const char *seckeyfile)
352763e1148Stedu {
3533a4a9206Sespie const char *pos;
354c5c473cbStedu size_t len;
355763e1148Stedu
3563a4a9206Sespie /* basename may or may not modify input */
3573a4a9206Sespie pos = strrchr(seckeyfile, '/');
3583a4a9206Sespie if (pos != NULL)
3593a4a9206Sespie seckeyfile = pos + 1;
3603a4a9206Sespie
3613a4a9206Sespie len = strlen(seckeyfile);
362763e1148Stedu if (len < 5) /* ?.key */
363763e1148Stedu goto bad;
3643a4a9206Sespie if (strcmp(seckeyfile + len - 4, ".sec") != 0)
3653a4a9206Sespie goto bad;
3663a4a9206Sespie if (pubkeyfile != NULL) {
3673a4a9206Sespie pos = strrchr(pubkeyfile, '/');
3683a4a9206Sespie if (pos != NULL)
3693a4a9206Sespie pubkeyfile = pos + 1;
3703a4a9206Sespie
3713a4a9206Sespie if (strlen(pubkeyfile) != len)
3723a4a9206Sespie goto bad;
3733a4a9206Sespie if (strcmp(pubkeyfile + len - 4, ".pub") != 0)
374763e1148Stedu goto bad;
375763e1148Stedu if (strncmp(pubkeyfile, seckeyfile, len - 4) != 0)
376763e1148Stedu goto bad;
3773a4a9206Sespie }
378763e1148Stedu
3793a4a9206Sespie return seckeyfile;
380763e1148Stedu bad:
381763e1148Stedu errx(1, "please use naming scheme of keyname.pub and keyname.sec");
382763e1148Stedu }
383763e1148Stedu
3843ccd7401Sespie uint8_t *
createsig(const char * seckeyfile,const char * msgfile,uint8_t * msg,unsigned long long msglen)385ff9e4f8aStedu createsig(const char *seckeyfile, const char *msgfile, uint8_t *msg,
386ff9e4f8aStedu unsigned long long msglen)
3874215a5deStedu {
3884215a5deStedu struct enckey enckey;
389ff9e4f8aStedu uint8_t xorkey[sizeof(enckey.seckey)];
390ff9e4f8aStedu struct sig sig;
3919b252276Stedu char *sighdr;
392ff9e4f8aStedu uint8_t digest[SHA512_DIGEST_LENGTH];
393ff9e4f8aStedu int i, nr, rounds;
394ff9e4f8aStedu SHA2_CTX ctx;
3959b252276Stedu char comment[COMMENTMAXLEN], sigcomment[COMMENTMAXLEN];
3964215a5deStedu
3971453d2a0Stedu readb64file(seckeyfile, &enckey, sizeof(enckey), comment);
3984215a5deStedu
3993a4a9206Sespie if (strcmp(seckeyfile, "-") == 0) {
400924f56e4Stedu nr = snprintf(sigcomment, sizeof(sigcomment),
401924f56e4Stedu "signature from %s", comment);
4023a4a9206Sespie } else {
4033a4a9206Sespie const char *keyname = check_keyname_compliance(NULL,
4043a4a9206Sespie seckeyfile);
4053a4a9206Sespie nr = snprintf(sigcomment, sizeof(sigcomment),
4063a4a9206Sespie VERIFYWITH "%.*s.pub", (int)strlen(keyname) - 4, keyname);
4073a4a9206Sespie }
408515e489cSderaadt if (nr < 0 || nr >= sizeof(sigcomment))
40941b393a4Stedu errx(1, "comment too long");
4109b252276Stedu
411ff9e4f8aStedu if (memcmp(enckey.kdfalg, KDFALG, 2) != 0)
412ff9e4f8aStedu errx(1, "unsupported KDF");
413ff9e4f8aStedu rounds = ntohl(enckey.kdfrounds);
414ff9e4f8aStedu kdf(enckey.salt, sizeof(enckey.salt), rounds, strcmp(msgfile, "-") != 0,
415ff9e4f8aStedu 0, xorkey, sizeof(xorkey));
416ff9e4f8aStedu for (i = 0; i < sizeof(enckey.seckey); i++)
417ff9e4f8aStedu enckey.seckey[i] ^= xorkey[i];
418ff9e4f8aStedu explicit_bzero(xorkey, sizeof(xorkey));
419ff9e4f8aStedu SHA512Init(&ctx);
420ff9e4f8aStedu SHA512Update(&ctx, enckey.seckey, sizeof(enckey.seckey));
421ff9e4f8aStedu SHA512Final(digest, &ctx);
422ff9e4f8aStedu if (memcmp(enckey.checksum, digest, sizeof(enckey.checksum)) != 0)
423ff9e4f8aStedu errx(1, "incorrect passphrase");
424ff9e4f8aStedu explicit_bzero(digest, sizeof(digest));
425ff9e4f8aStedu
426ff9e4f8aStedu signmsg(enckey.seckey, msg, msglen, sig.sig);
427ff9e4f8aStedu memcpy(sig.keynum, enckey.keynum, KEYNUMLEN);
428ff9e4f8aStedu explicit_bzero(&enckey, sizeof(enckey));
429ff9e4f8aStedu
430ff9e4f8aStedu memcpy(sig.pkalg, PKALG, 2);
431ff9e4f8aStedu
432ff9e4f8aStedu sighdr = createheader(sigcomment, &sig, sizeof(sig));
433ff9e4f8aStedu return sighdr;
434ff9e4f8aStedu }
435ff9e4f8aStedu
436ff9e4f8aStedu static void
sign(const char * seckeyfile,const char * msgfile,const char * sigfile,int embedded)437ff9e4f8aStedu sign(const char *seckeyfile, const char *msgfile, const char *sigfile,
438ff9e4f8aStedu int embedded)
439ff9e4f8aStedu {
440ff9e4f8aStedu uint8_t *msg;
441ff9e4f8aStedu char *sighdr;
442ff9e4f8aStedu int fd;
443ff9e4f8aStedu unsigned long long msglen;
444ff9e4f8aStedu
4459b252276Stedu msg = readmsg(msgfile, &msglen);
4469b252276Stedu
447ff9e4f8aStedu sighdr = createsig(seckeyfile, msgfile, msg, msglen);
4489b252276Stedu
4499b252276Stedu fd = xopen(sigfile, O_CREAT|O_TRUNC|O_NOFOLLOW|O_WRONLY, 0666);
4509b252276Stedu writeall(fd, sighdr, strlen(sighdr), sigfile);
4519b252276Stedu free(sighdr);
45227f66874Stedu if (embedded)
4539b252276Stedu writeall(fd, msg, msglen, sigfile);
4549b252276Stedu close(fd);
4554215a5deStedu
4564215a5deStedu free(msg);
4574215a5deStedu }
458665ab7d9Stedu #endif
4594215a5deStedu
4604215a5deStedu static void
verifymsg(struct pubkey * pubkey,uint8_t * msg,unsigned long long msglen,struct sig * sig,int quiet)46148336e31Stedu verifymsg(struct pubkey *pubkey, uint8_t *msg, unsigned long long msglen,
46248336e31Stedu struct sig *sig, int quiet)
4631c9c770cStedu {
4641c9c770cStedu uint8_t *sigbuf, *dummybuf;
4651c9c770cStedu unsigned long long siglen, dummylen;
4661c9c770cStedu
467534dbeadStedu if (memcmp(pubkey->keynum, sig->keynum, KEYNUMLEN) != 0)
46848336e31Stedu errx(1, "verification failed: checked against wrong key");
46948336e31Stedu
4701c9c770cStedu siglen = SIGBYTES + msglen;
4711c9c770cStedu sigbuf = xmalloc(siglen);
4721c9c770cStedu dummybuf = xmalloc(siglen);
47348336e31Stedu memcpy(sigbuf, sig->sig, SIGBYTES);
4741c9c770cStedu memcpy(sigbuf + SIGBYTES, msg, msglen);
4751c9c770cStedu if (crypto_sign_ed25519_open(dummybuf, &dummylen, sigbuf, siglen,
47648336e31Stedu pubkey->pubkey) == -1)
4771c9c770cStedu errx(1, "signature verification failed");
47858559f60Stedu if (!quiet)
47958559f60Stedu printf("Signature Verified\n");
4801c9c770cStedu free(sigbuf);
4811c9c770cStedu free(dummybuf);
4821c9c770cStedu }
4831c9c770cStedu
48418d71116Sespie static void
check_keytype(const char * pubkeyfile,const char * keytype)48518d71116Sespie check_keytype(const char *pubkeyfile, const char *keytype)
48618d71116Sespie {
487a481ce23Stedu const char *p;
488a481ce23Stedu size_t typelen;
48947dc9001Stedu
490a481ce23Stedu if (!(p = strrchr(pubkeyfile, '-')))
491a481ce23Stedu goto bad;
492a481ce23Stedu p++;
493a481ce23Stedu typelen = strlen(keytype);
494a481ce23Stedu if (strncmp(p, keytype, typelen) != 0)
495a481ce23Stedu goto bad;
496a481ce23Stedu if (strcmp(p + typelen, ".pub") != 0)
497a481ce23Stedu goto bad;
498a481ce23Stedu return;
49918d71116Sespie
500a481ce23Stedu bad:
501a481ce23Stedu errx(1, "incorrect keytype: %s is not %s", pubkeyfile, keytype);
50218d71116Sespie }
50318d71116Sespie
5041c9c770cStedu static void
readpubkey(const char * pubkeyfile,struct pubkey * pubkey,const char * sigcomment,const char * keytype)50526d9395eStedu readpubkey(const char *pubkeyfile, struct pubkey *pubkey,
50618d71116Sespie const char *sigcomment, const char *keytype)
5074215a5deStedu {
508e4c55632Stedu const char *safepath = "/etc/signify";
5090274047dSderaadt char keypath[PATH_MAX];
51027f66874Stedu
5110f212b48Stedu if (!pubkeyfile) {
5121118246cStedu pubkeyfile = strstr(sigcomment, VERIFYWITH);
513e4c55632Stedu if (pubkeyfile && strchr(pubkeyfile, '/') == NULL) {
5140f212b48Stedu pubkeyfile += strlen(VERIFYWITH);
51518d71116Sespie if (keytype)
51618d71116Sespie check_keytype(pubkeyfile, keytype);
517e4c55632Stedu if (snprintf(keypath, sizeof(keypath), "%s/%s",
518e4c55632Stedu safepath, pubkeyfile) >= sizeof(keypath))
519e4c55632Stedu errx(1, "name too long %s", pubkeyfile);
52097524a13Stedu pubkeyfile = keypath;
521b0b02d10Stedu } else
5225d586c2bStedu usage("must specify pubkey");
5230f212b48Stedu }
52497524a13Stedu readb64file(pubkeyfile, pubkey, sizeof(*pubkey), NULL);
52526d9395eStedu }
52626d9395eStedu
52726d9395eStedu static void
verifysimple(const char * pubkeyfile,const char * msgfile,const char * sigfile,int quiet,const char * keytype)52826d9395eStedu verifysimple(const char *pubkeyfile, const char *msgfile, const char *sigfile,
52918d71116Sespie int quiet, const char *keytype)
53026d9395eStedu {
53126d9395eStedu char sigcomment[COMMENTMAXLEN];
53226d9395eStedu struct sig sig;
53326d9395eStedu struct pubkey pubkey;
53426d9395eStedu unsigned long long msglen;
53526d9395eStedu uint8_t *msg;
53626d9395eStedu
53726d9395eStedu msg = readmsg(msgfile, &msglen);
53826d9395eStedu
53926d9395eStedu readb64file(sigfile, &sig, sizeof(sig), sigcomment);
54018d71116Sespie readpubkey(pubkeyfile, &pubkey, sigcomment, keytype);
5414215a5deStedu
54248336e31Stedu verifymsg(&pubkey, msg, msglen, &sig, quiet);
543ffebbc61Stedu
544ffebbc61Stedu free(msg);
545ffebbc61Stedu }
546ffebbc61Stedu
547ffebbc61Stedu static uint8_t *
verifyembedded(const char * pubkeyfile,const char * sigfile,int quiet,unsigned long long * msglenp,const char * keytype)548ffebbc61Stedu verifyembedded(const char *pubkeyfile, const char *sigfile,
54918d71116Sespie int quiet, unsigned long long *msglenp, const char *keytype)
550ffebbc61Stedu {
55126d9395eStedu char sigcomment[COMMENTMAXLEN];
552ffebbc61Stedu struct sig sig;
553ffebbc61Stedu struct pubkey pubkey;
554ffebbc61Stedu unsigned long long msglen, siglen;
555ffebbc61Stedu uint8_t *msg;
556ffebbc61Stedu
557ffebbc61Stedu msg = readmsg(sigfile, &msglen);
558ffebbc61Stedu
55926d9395eStedu siglen = parseb64file(sigfile, msg, &sig, sizeof(sig), sigcomment);
56018d71116Sespie readpubkey(pubkeyfile, &pubkey, sigcomment, keytype);
56126d9395eStedu
562ffebbc61Stedu msglen -= siglen;
563ffebbc61Stedu memmove(msg, msg + siglen, msglen);
564ffebbc61Stedu msg[msglen] = 0;
565ffebbc61Stedu
566ffebbc61Stedu verifymsg(&pubkey, msg, msglen, &sig, quiet);
567ffebbc61Stedu
568ffebbc61Stedu *msglenp = msglen;
569ffebbc61Stedu return msg;
570ffebbc61Stedu }
571ffebbc61Stedu
572ffebbc61Stedu static void
verify(const char * pubkeyfile,const char * msgfile,const char * sigfile,int embedded,int quiet,const char * keytype)573ffebbc61Stedu verify(const char *pubkeyfile, const char *msgfile, const char *sigfile,
57418d71116Sespie int embedded, int quiet, const char *keytype)
575ffebbc61Stedu {
576ffebbc61Stedu unsigned long long msglen;
577ffebbc61Stedu uint8_t *msg;
578ffebbc61Stedu int fd;
579ffebbc61Stedu
58027f66874Stedu if (embedded) {
58118d71116Sespie msg = verifyembedded(pubkeyfile, sigfile, quiet, &msglen,
58218d71116Sespie keytype);
5839831e76dStedu fd = xopen(msgfile, O_CREAT|O_TRUNC|O_NOFOLLOW|O_WRONLY, 0666);
58427f66874Stedu writeall(fd, msg, msglen, msgfile);
58587e034adSespie free(msg);
58627f66874Stedu close(fd);
587ffebbc61Stedu } else {
58818d71116Sespie verifysimple(pubkeyfile, msgfile, sigfile, quiet, keytype);
58927f66874Stedu }
5904215a5deStedu }
5914215a5deStedu
59258559f60Stedu #ifndef VERIFYONLY
593ce955b95Stedu #define HASHBUFSIZE 224
59458559f60Stedu struct checksum {
595f30a54aaStedu char file[PATH_MAX];
596ce955b95Stedu char hash[HASHBUFSIZE];
597032a32d9Stedu char algo[32];
59858559f60Stedu };
59958559f60Stedu
600e96025a1Sespie static void *
ecalloc(size_t s1,size_t s2,void * data)601e96025a1Sespie ecalloc(size_t s1, size_t s2, void *data)
602e96025a1Sespie {
603db6a8127Stedu void *p;
604db6a8127Stedu
605dba2cf70Stedu if (!(p = calloc(s1, s2)))
606e96025a1Sespie err(1, "calloc");
607e96025a1Sespie return p;
608e96025a1Sespie }
609e96025a1Sespie
61058559f60Stedu static void
efree(void * p,void * data)611e96025a1Sespie efree(void *p, void *data)
612e96025a1Sespie {
613e96025a1Sespie free(p);
614e96025a1Sespie }
615e96025a1Sespie
616e96025a1Sespie static void
recodehash(char * hash,size_t len)617e96025a1Sespie recodehash(char *hash, size_t len)
6180050332bStedu {
619ce955b95Stedu uint8_t data[HASHBUFSIZE / 2];
6200050332bStedu int i, rv;
6210050332bStedu
622e96025a1Sespie if (strlen(hash) == len)
6230050332bStedu return;
6240050332bStedu if ((rv = b64_pton(hash, data, sizeof(data))) == -1)
6250050332bStedu errx(1, "invalid base64 encoding");
6260050332bStedu for (i = 0; i < rv; i++)
627ce955b95Stedu snprintf(hash + i * 2, HASHBUFSIZE - i * 2, "%2.2x", data[i]);
6280050332bStedu }
6290050332bStedu
630e96025a1Sespie static int
verifychecksum(struct checksum * c,int quiet)631e96025a1Sespie verifychecksum(struct checksum *c, int quiet)
63258559f60Stedu {
633e96025a1Sespie char buf[HASHBUFSIZE];
634db6a8127Stedu
63558559f60Stedu if (strcmp(c->algo, "SHA256") == 0) {
636e96025a1Sespie recodehash(c->hash, SHA256_DIGEST_STRING_LENGTH-1);
637e96025a1Sespie if (!SHA256File(c->file, buf))
638e96025a1Sespie return 0;
63958559f60Stedu } else if (strcmp(c->algo, "SHA512") == 0) {
640e96025a1Sespie recodehash(c->hash, SHA512_DIGEST_STRING_LENGTH-1);
641e96025a1Sespie if (!SHA512File(c->file, buf))
642e96025a1Sespie return 0;
64358559f60Stedu } else {
64458559f60Stedu errx(1, "can't handle algorithm %s", c->algo);
64558559f60Stedu }
646b39b450dStedu if (strcmp(c->hash, buf) != 0)
647e96025a1Sespie return 0;
64858559f60Stedu if (!quiet)
64958559f60Stedu printf("%s: OK\n", c->file);
650e96025a1Sespie return 1;
65158559f60Stedu }
652e96025a1Sespie
653e96025a1Sespie static void
verifychecksums(char * msg,int argc,char ** argv,int quiet)654e96025a1Sespie verifychecksums(char *msg, int argc, char **argv, int quiet)
655e96025a1Sespie {
656e96025a1Sespie struct ohash_info info = { 0, NULL, ecalloc, efree, NULL };
657e96025a1Sespie struct ohash myh;
658e96025a1Sespie struct checksum c;
659a5b6fcd7Stedu char *e, *line, *endline;
660db6a8127Stedu int hasfailed = 0;
661db6a8127Stedu int i, rv;
662e96025a1Sespie unsigned int slot;
663e96025a1Sespie
664e96025a1Sespie ohash_init(&myh, 6, &info);
665a5b6fcd7Stedu if (argc) {
666e96025a1Sespie for (i = 0; i < argc; i++) {
667e96025a1Sespie slot = ohash_qlookup(&myh, argv[i]);
668e96025a1Sespie e = ohash_find(&myh, slot);
669e96025a1Sespie if (e == NULL)
670e96025a1Sespie ohash_insert(&myh, slot, argv[i]);
671e96025a1Sespie }
672e96025a1Sespie }
673e96025a1Sespie
674e96025a1Sespie line = msg;
675e96025a1Sespie while (line && *line) {
676e96025a1Sespie if ((endline = strchr(line, '\n')))
677e96025a1Sespie *endline++ = '\0';
678a8e2d00fStedu #if PATH_MAX < 1024 || HASHBUFSIZE < 224
679a8e2d00fStedu #error sizes are wrong
680a8e2d00fStedu #endif
6813111eefdStedu rv = sscanf(line, "%31s (%1023[^)]) = %223s",
682e96025a1Sespie c.algo, c.file, c.hash);
6833111eefdStedu if (rv != 3)
684e96025a1Sespie errx(1, "unable to parse checksum line %s", line);
685e96025a1Sespie line = endline;
686e96025a1Sespie if (argc) {
687e96025a1Sespie slot = ohash_qlookup(&myh, c.file);
688e96025a1Sespie e = ohash_find(&myh, slot);
689e96025a1Sespie if (e != NULL) {
690db6a8127Stedu if (verifychecksum(&c, quiet) != 0)
691e96025a1Sespie ohash_remove(&myh, slot);
692e96025a1Sespie }
693e96025a1Sespie } else {
694db6a8127Stedu if (verifychecksum(&c, quiet) == 0) {
695a5b6fcd7Stedu slot = ohash_qlookup(&myh, c.file);
696a5b6fcd7Stedu e = ohash_find(&myh, slot);
697a5b6fcd7Stedu if (e == NULL) {
698a5b6fcd7Stedu if (!(e = strdup(c.file)))
699a5b6fcd7Stedu err(1, "strdup");
700a5b6fcd7Stedu ohash_insert(&myh, slot, e);
701a5b6fcd7Stedu }
70258559f60Stedu }
70358559f60Stedu }
704e96025a1Sespie }
705e96025a1Sespie
706a5b6fcd7Stedu for (e = ohash_first(&myh, &slot); e != NULL; e = ohash_next(&myh, &slot)) {
707a5b6fcd7Stedu fprintf(stderr, "%s: FAIL\n", e);
708e96025a1Sespie hasfailed = 1;
709a5b6fcd7Stedu if (argc == 0)
710a5b6fcd7Stedu free(e);
711e96025a1Sespie }
712e96025a1Sespie ohash_delete(&myh);
7138972cca3Stedu if (hasfailed)
71458559f60Stedu exit(1);
71558559f60Stedu }
71658559f60Stedu
71758559f60Stedu static void
check(const char * pubkeyfile,const char * sigfile,const char * keytype,int quiet,int argc,char ** argv)71845efba1eStb check(const char *pubkeyfile, const char *sigfile, const char *keytype,
71945efba1eStb int quiet, int argc, char **argv)
72058559f60Stedu {
721ffebbc61Stedu unsigned long long msglen;
72258559f60Stedu uint8_t *msg;
72358559f60Stedu
72445efba1eStb msg = verifyembedded(pubkeyfile, sigfile, quiet, &msglen, keytype);
725a40f4206Stedu verifychecksums((char *)msg, argc, argv, quiet);
72658559f60Stedu
727ffebbc61Stedu free(msg);
72858559f60Stedu }
7293ccd7401Sespie
7303ccd7401Sespie void *
verifyzdata(uint8_t * zdata,unsigned long long zdatalen,const char * filename,const char * pubkeyfile,const char * keytype)7313ccd7401Sespie verifyzdata(uint8_t *zdata, unsigned long long zdatalen,
7323ccd7401Sespie const char *filename, const char *pubkeyfile, const char *keytype)
7333ccd7401Sespie {
7343ccd7401Sespie struct sig sig;
7353ccd7401Sespie char sigcomment[COMMENTMAXLEN];
7363ccd7401Sespie unsigned long long siglen;
7373ccd7401Sespie struct pubkey pubkey;
7383ccd7401Sespie
7393ccd7401Sespie if (zdatalen < sizeof(sig))
7403ccd7401Sespie errx(1, "signature too short in %s", filename);
7413ccd7401Sespie siglen = parseb64file(filename, zdata, &sig, sizeof(sig),
7423ccd7401Sespie sigcomment);
7433ccd7401Sespie readpubkey(pubkeyfile, &pubkey, sigcomment, keytype);
7443ccd7401Sespie zdata += siglen;
7453ccd7401Sespie zdatalen -= siglen;
7463ccd7401Sespie verifymsg(&pubkey, zdata, zdatalen, &sig, 1);
7473ccd7401Sespie return zdata;
7483ccd7401Sespie }
74958559f60Stedu #endif
75058559f60Stedu
7514215a5deStedu int
main(int argc,char ** argv)7524215a5deStedu main(int argc, char **argv)
7534215a5deStedu {
754*ae4dfda2Skn const char *pubkeyfile = NULL, *msgfile = NULL, *sigfile = NULL;
755f30a54aaStedu char sigfilebuf[PATH_MAX];
75618d71116Sespie char *keytype = NULL;
757*ae4dfda2Skn #ifndef VERIFYONLY
758*ae4dfda2Skn const char *seckeyfile = NULL, *comment = "signify";
759c610539bStedu int none = 0;
760*ae4dfda2Skn #endif
761*ae4dfda2Skn int ch;
76227f66874Stedu int embedded = 0;
76358559f60Stedu int quiet = 0;
7643ccd7401Sespie int gzip = 0;
765a6bade58Stedu enum {
766a6bade58Stedu NONE,
76758559f60Stedu CHECK,
768a6bade58Stedu GENERATE,
769a6bade58Stedu SIGN,
770a6bade58Stedu VERIFY
771a6bade58Stedu } verb = NONE;
772a6bade58Stedu
7730bd1216cSderaadt if (pledge("stdio rpath wpath cpath tty", NULL) == -1)
7740bd1216cSderaadt err(1, "pledge");
7754215a5deStedu
7763ccd7401Sespie while ((ch = getopt(argc, argv, "CGSVzc:em:np:qs:t:x:")) != -1) {
7774215a5deStedu switch (ch) {
778665ab7d9Stedu #ifndef VERIFYONLY
77958559f60Stedu case 'C':
78058559f60Stedu if (verb)
78158559f60Stedu usage(NULL);
78258559f60Stedu verb = CHECK;
78358559f60Stedu break;
784a6bade58Stedu case 'G':
785a6bade58Stedu if (verb)
786f2adbe28Stedu usage(NULL);
787a6bade58Stedu verb = GENERATE;
7884215a5deStedu break;
7894215a5deStedu case 'S':
790a6bade58Stedu if (verb)
791f2adbe28Stedu usage(NULL);
792a6bade58Stedu verb = SIGN;
7934215a5deStedu break;
794*ae4dfda2Skn case 'c':
795*ae4dfda2Skn comment = optarg;
796*ae4dfda2Skn break;
797*ae4dfda2Skn case 'n':
798*ae4dfda2Skn none = 1;
799*ae4dfda2Skn break;
800*ae4dfda2Skn case 's':
801*ae4dfda2Skn seckeyfile = optarg;
802*ae4dfda2Skn break;
8033ccd7401Sespie case 'z':
8043ccd7401Sespie gzip = 1;
8053ccd7401Sespie break;
806665ab7d9Stedu #endif
8074215a5deStedu case 'V':
808a6bade58Stedu if (verb)
809f2adbe28Stedu usage(NULL);
810a6bade58Stedu verb = VERIFY;
811a6bade58Stedu break;
81227f66874Stedu case 'e':
81327f66874Stedu embedded = 1;
81427f66874Stedu break;
815f2adbe28Stedu case 'm':
816f2adbe28Stedu msgfile = optarg;
817f2adbe28Stedu break;
818a6bade58Stedu case 'p':
819a6bade58Stedu pubkeyfile = optarg;
820a6bade58Stedu break;
82158559f60Stedu case 'q':
82258559f60Stedu quiet = 1;
82358559f60Stedu break;
82418d71116Sespie case 't':
82518d71116Sespie keytype = optarg;
82618d71116Sespie break;
827f2adbe28Stedu case 'x':
828f2adbe28Stedu sigfile = optarg;
829f2adbe28Stedu break;
8304215a5deStedu default:
831f2adbe28Stedu usage(NULL);
8324215a5deStedu break;
8334215a5deStedu }
8344215a5deStedu }
835bcc39c47Stedu argc -= optind;
83642efb9f2Sespie argv += optind;
83742efb9f2Sespie
838da1d8f10Stedu if (embedded && gzip)
839da1d8f10Stedu errx(1, "can't combine -e and -z options");
840da1d8f10Stedu
84175f1004aSbluhm if (setvbuf(stdout, NULL, _IOLBF, 0) != 0)
84275f1004aSbluhm err(1, "setvbuf");
84375f1004aSbluhm
84458559f60Stedu #ifndef VERIFYONLY
84558559f60Stedu if (verb == CHECK) {
846de861b93Stedu if (pledge("stdio rpath", NULL) == -1)
847de861b93Stedu err(1, "pledge");
8489fbe12ffStedu if (!sigfile)
8499fbe12ffStedu usage("must specify sigfile");
85045efba1eStb check(pubkeyfile, sigfile, keytype, quiet, argc, argv);
85158559f60Stedu return 0;
85258559f60Stedu }
85358559f60Stedu #endif
85458559f60Stedu
855f2adbe28Stedu if (argc != 0)
856f2adbe28Stedu usage(NULL);
857f2adbe28Stedu
8589127dd95Stedu if (!sigfile && msgfile) {
859b3fe1a3aStedu int nr;
860f2adbe28Stedu if (strcmp(msgfile, "-") == 0)
8615d586c2bStedu usage("must specify sigfile with - message");
862924f56e4Stedu nr = snprintf(sigfilebuf, sizeof(sigfilebuf),
863924f56e4Stedu "%s.sig", msgfile);
864515e489cSderaadt if (nr < 0 || nr >= sizeof(sigfilebuf))
8654215a5deStedu errx(1, "path too long");
8664215a5deStedu sigfile = sigfilebuf;
8674215a5deStedu }
8689127dd95Stedu
8699127dd95Stedu switch (verb) {
870665ab7d9Stedu #ifndef VERIFYONLY
8719127dd95Stedu case GENERATE:
872de861b93Stedu /* no pledge */
8739127dd95Stedu if (!pubkeyfile || !seckeyfile)
8745d586c2bStedu usage("must specify pubkey and seckey");
875763e1148Stedu check_keyname_compliance(pubkeyfile, seckeyfile);
876c610539bStedu generate(pubkeyfile, seckeyfile, none ? 0 : 42, comment);
8779127dd95Stedu break;
8789127dd95Stedu case SIGN:
879de861b93Stedu /* no pledge */
88009ecb553Stedu if (gzip) {
88112f6f7dbSespie if (!msgfile || !seckeyfile || !sigfile)
88212f6f7dbSespie usage("must specify message sigfile seckey");
883c610539bStedu zsign(seckeyfile, msgfile, sigfile, none);
88409ecb553Stedu } else {
8859127dd95Stedu if (!msgfile || !seckeyfile)
8865d586c2bStedu usage("must specify message and seckey");
88727f66874Stedu sign(seckeyfile, msgfile, sigfile, embedded);
8883ccd7401Sespie }
8899127dd95Stedu break;
890665ab7d9Stedu #endif
8919127dd95Stedu case VERIFY:
89209ecb553Stedu if ((embedded || gzip) &&
89309ecb553Stedu (msgfile && strcmp(msgfile, "-") != 0)) {
89409ecb553Stedu /* will need to create output file */
895de861b93Stedu if (pledge("stdio rpath wpath cpath", NULL) == -1)
896de861b93Stedu err(1, "pledge");
897de861b93Stedu } else {
898de861b93Stedu if (pledge("stdio rpath", NULL) == -1)
899de861b93Stedu err(1, "pledge");
900de861b93Stedu }
90109ecb553Stedu if (gzip) {
9023ccd7401Sespie zverify(pubkeyfile, msgfile, sigfile, keytype);
90309ecb553Stedu } else {
9040f212b48Stedu if (!msgfile)
9055d586c2bStedu usage("must specify message");
9063ccd7401Sespie verify(pubkeyfile, msgfile, sigfile, embedded,
9073ccd7401Sespie quiet, keytype);
9083ccd7401Sespie }
9099127dd95Stedu break;
9109127dd95Stedu default:
911de861b93Stedu if (pledge("stdio", NULL) == -1)
912de861b93Stedu err(1, "pledge");
9139127dd95Stedu usage(NULL);
9149127dd95Stedu break;
91542efb9f2Sespie }
91642efb9f2Sespie
9174215a5deStedu return 0;
9184215a5deStedu }
919