usign-exec.c

   1 /*
   2  * wrapper functions around the usign executable
   3  * Copyright (C) 2018 Daniel Golle <daniel@makrotopia.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 3
   7  * as published by the Free Software Foundation
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include <stdbool.h>
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <unistd.h>
  19 #include <sys/wait.h>
  20
  21 #include "usign.h"
  22
  23 #ifdef UCERT_HOST_BUILD
  24 #define USIGN_EXEC "usign"
  25 #else
  26 #define USIGN_EXEC "/usr/bin/usign"
  27 #endif
  28
  29 /*
  30  * check for revoker deadlink in pubkeydir
  31  * return true if a revoker exists, false otherwise
  32  */
  33 int _usign_key_is_revoked(const char *fingerprint, const char *pubkeydir) {
  34         char tml[64] = {0};
  35         char rfname[256] = {0};
  36
  37         snprintf(rfname, sizeof(rfname)-1, "%s/%s", pubkeydir, fingerprint);
  38         if (readlink(rfname, tml, sizeof(tml)) > 0 &&
  39             !strcmp(tml, ".revoked.")) {
  40                 return true;
  41         };
  42
  43         return false;
  44 }
  45
  46 #ifdef UCERT_FULL
  47 /*
  48  * call usign -S ...
  49  * return WEXITSTATUS or -1 if fork fails
  50  */
  51 int usign_s(const char *msgfile, const char *seckeyfile, const char *sigfile, bool quiet) {
  52         pid_t pid;
  53         int status;
  54         const char *usign_argv[16] = {0};
  55         unsigned int usign_argc = 0;
  56
  57         usign_argv[usign_argc++] = USIGN_EXEC;
  58         usign_argv[usign_argc++] = "-S";
  59         usign_argv[usign_argc++] = "-m";
  60         usign_argv[usign_argc++] = msgfile;
  61         usign_argv[usign_argc++] = "-s";
  62         usign_argv[usign_argc++] = seckeyfile;
  63         usign_argv[usign_argc++] = "-x";
  64         usign_argv[usign_argc++] = sigfile;
  65
  66         if (quiet)
  67                 usign_argv[usign_argc++] = "-q";
  68
  69         pid = fork();
  70         switch (pid) {
  71         case -1:
  72                 return -1;
  73
  74         case 0:
  75                 execvp(usign_argv[0], (char *const *)usign_argv);
  76                 if (!quiet)
  77                         perror("Failed to execute usign");
  78                 _exit(1);
  79
  80         default:
  81                 waitpid(pid, &status, 0);
  82                 return WEXITSTATUS(status);
  83         }
  84
  85         return -1;
  86 }
  87 #else
  88 int usign_s(const char *msgfile, const char *seckeyfile, const char *sigfile, bool quiet) {
  89         return -1;
  90 };
  91 #endif
  92
  93 /*
  94  * call usign -F ... and set fingerprint returned
  95  * return WEXITSTATUS or -1 if fork fails
  96  */
  97 static int usign_f(char fingerprint[17], const char *pubkeyfile, const char *seckeyfile, const char *sigfile, bool quiet) {
  98         int fds[2];
  99         pid_t pid;
 100         int status;
 101         const char *usign_argv[16] = {0};
 102         unsigned int usign_argc = 0;
 103
 104         if (pipe(fds))
 105                 return -1;
 106
 107         usign_argv[usign_argc++] = USIGN_EXEC;
 108         usign_argv[usign_argc++] = "-F";
 109
 110         if (pubkeyfile) {
 111                 usign_argv[usign_argc++] = "-p";
 112                 usign_argv[usign_argc++] = pubkeyfile;
 113         }
 114
 115         if (seckeyfile) {
 116                 usign_argv[usign_argc++] = "-s";
 117                 usign_argv[usign_argc++] = seckeyfile;
 118         }
 119
 120         if (sigfile) {
 121                 usign_argv[usign_argc++] = "-x";
 122                 usign_argv[usign_argc++] = sigfile;
 123         }
 124
 125         pid = fork();
 126         switch (pid) {
 127         case -1:
 128                 return -1;
 129
 130         case 0:
 131                 dup2(fds[1], 1);
 132
 133                 close(fds[0]);
 134                 close(fds[1]);
 135
 136                 execvp(usign_argv[0], (char *const *)usign_argv);
 137                 if (!quiet)
 138                         perror("Failed to execute usign");
 139                 _exit(1);
 140
 141         default:
 142                 waitpid(pid, &status, 0);
 143                 status = WEXITSTATUS(status);
 144                 if (fingerprint && !WEXITSTATUS(status)) {
 145                         ssize_t r;
 146                         memset(fingerprint, 0, 17);
 147                         r = read(fds[0], fingerprint, 17);
 148                         if (r < 16)
 149                                 status = -1;
 150
 151                         fingerprint[16] = '\0';
 152
 153                 }
 154                 close(fds[0]);
 155                 close(fds[1]);
 156                 return status;
 157         }
 158
 159         return -1;
 160 }
 161
 162 /*
 163  * call usign -F -p ...
 164  */
 165 int usign_f_pubkey(char fingerprint[17], const char *pubkeyfile, bool quiet) {
 166         return usign_f(fingerprint, pubkeyfile, NULL, NULL, quiet);
 167 }
 168
 169 /*
 170  * call usign -F -s ...
 171  */
 172 int usign_f_seckey(char fingerprint[17], const char *seckeyfile, bool quiet) {
 173         return usign_f(fingerprint, NULL, seckeyfile, NULL, quiet);
 174 }
 175
 176 /*
 177  * call usign -F -x ...
 178  */
 179 int usign_f_sig(char fingerprint[17], const char *sigfile, bool quiet) {
 180         return usign_f(fingerprint, NULL, NULL, sigfile, quiet);
 181 }
 182
 183
 184 /*
 185  * call usign -V ...
 186  * return WEXITSTATUS or -1 if fork fails
 187  */
 188 int usign_v(const char *msgfile, const char *pubkeyfile,
 189             const char *pubkeydir, const char *sigfile, bool quiet) {
 190         pid_t pid;
 191         int status;
 192         const char *usign_argv[16] = {0};
 193         unsigned int usign_argc = 0;
 194         char fingerprint[17];
 195
 196         if (usign_f_sig(fingerprint, sigfile, quiet)) {
 197                 if (!quiet)
 198                         fprintf(stderr, "cannot get signing key fingerprint\n");
 199                 return 1;
 200         }
 201
 202         if (pubkeydir && _usign_key_is_revoked(fingerprint, pubkeydir)) {
 203                 if (!quiet)
 204                         fprintf(stderr, "key %s has been revoked!\n", fingerprint);
 205                 return 1;
 206         }
 207         usign_argv[usign_argc++] = USIGN_EXEC;
 208         usign_argv[usign_argc++] = "-V";
 209         usign_argv[usign_argc++] = "-m";
 210         usign_argv[usign_argc++] = msgfile;
 211
 212         if (quiet)
 213                 usign_argv[usign_argc++] = "-q";
 214
 215         if (pubkeyfile) {
 216                 usign_argv[usign_argc++] = "-p";
 217                 usign_argv[usign_argc++] = pubkeyfile;
 218         }
 219
 220         if (pubkeydir) {
 221                 usign_argv[usign_argc++] = "-P";
 222                 usign_argv[usign_argc++] = pubkeydir;
 223         }
 224
 225         if (sigfile) {
 226                 usign_argv[usign_argc++] = "-x";
 227                 usign_argv[usign_argc++] = sigfile;
 228         }
 229
 230         pid = fork();
 231         switch (pid) {
 232         case -1:
 233                 return -1;
 234
 235         case 0:
 236                 execvp(usign_argv[0], (char *const *)usign_argv);
 237                 if (!quiet)
 238                         perror("Failed to execute usign");
 239                 _exit(1);
 240
 241         default:
 242                 waitpid(pid, &status, 0);
 243                 return WEXITSTATUS(status);
 244         }
 245
 246         return -1;
 247 }