chiark - git - mdw - catacomb/blob - key/pixie-common.c

   1 /* -*-c-*-
   2  *
   3  * Common code for Pixie client and server (Unix-specific)
   4  *
   5  * (c) 1999 Straylight/Edgeware
   6  */
   7
   8 /*----- Licensing notice --------------------------------------------------*
   9  *
  10  * This file is part of Catacomb.
  11  *
  12  * Catacomb is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU Library General Public License as
  14  * published by the Free Software Foundation; either version 2 of the
  15  * License, or (at your option) any later version.
  16  *
  17  * Catacomb is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU Library General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Library General Public
  23  * License along with Catacomb; if not, write to the Free
  24  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  25  * MA 02111-1307, USA.
  26  */
  27
  28 /*----- Header files ------------------------------------------------------*/
  29
  30 #include <errno.h>
  31 #include <stddef.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 #include <sys/types.h>
  37 #include <unistd.h>
  38 #include <fcntl.h>
  39 #include <termios.h>
  40 #include <pwd.h>
  41
  42 #include <sys/socket.h>
  43 #include <sys/un.h>
  44
  45 #include <mLib/alloc.h>
  46 #include <mLib/dstr.h>
  47 #include <mLib/macros.h>
  48 #include <mLib/str.h>
  49
  50 #include "pixie.h"
  51
  52 /*----- Main code ---------------------------------------------------------*/
  53
  54 /* --- @pixie_address@ --- *
  55  *
  56  * Arguments:   @const char *sock@ = pointer to socket name
  57  *              @size_t *psz@ = where to write the address size
  58  *
  59  * Returns:     Pointer to filled-in Unix-domain socket address.
  60  *
  61  * Use:         Returns a Unix-domain socket address to use to find the
  62  *              passphrase pixie.
  63  */
  64
  65 struct sockaddr_un *pixie_address(const char *sock, size_t *psz)
  66 {
  67   dstr d = DSTR_INIT;
  68
  69   /* --- Get the default socket path if none specified --- */
  70
  71   if (!sock)
  72     sock = getenv("CATACOMB_PIXIE_SOCKET");
  73   if (!sock)
  74     sock = "%h/.catacomb/pixie";
  75
  76   /* --- Substitute interesting sequences in the path --- */
  77
  78   {
  79     const char *q, *qq;
  80
  81     q = sock;
  82     for (;;) {
  83       qq = strchr(q, '%');
  84       if (!qq || !qq[1]) {
  85         DPUTS(&d, q);
  86         break;
  87       }
  88       DPUTM(&d, q, qq - q);
  89       q = qq + 1;
  90       switch (*q) {
  91         case 'u':
  92           qq = getenv("USER");
  93           if (!qq)
  94             qq = getenv("LOGNAME");
  95           if (!qq) {
  96             struct passwd *pw = getpwuid(getuid());
  97             if (pw)
  98               qq = pw->pw_name;
  99             else
 100               qq = "<unknown>";
 101           }
 102           DPUTS(&d, qq);
 103           break;
 104         case 'h':
 105           qq = getenv("HOME");
 106           if (!qq) {
 107             struct passwd *pw = getpwuid(getuid());
 108             if (pw)
 109               qq = pw->pw_dir;
 110             else
 111               qq = "<unknown>";
 112           }
 113           DPUTS(&d, qq);
 114           break;
 115         default:
 116           DPUTC(&d, '%');
 117           DPUTC(&d, *q);
 118           break;
 119       }
 120       q++;
 121     }
 122     DPUTZ(&d);
 123   }
 124
 125   /* --- Allocate and initialize the socket address --- */
 126
 127   {
 128     struct sockaddr_un *sun;
 129     size_t bsz = offsetof(struct sockaddr_un, sun_path);
 130     *psz = bsz + d.len + 1;
 131     sun = xmalloc(bsz + d.len + 1);
 132     memset(sun, 0, bsz);
 133     sun->sun_family = AF_UNIX;
 134     memcpy(sun->sun_path, d.buf, d.len + 1);
 135     dstr_destroy(&d);
 136     return (sun);
 137   }
 138 }
 139
 140 /* --- @pixie_fdline@ --- *
 141  *
 142  * Arguments:   @int fd@ = file descriptor to read from
 143  *              @char *buf@ = pointer to buffer
 144  *              @size_t sz@ = size of buffer
 145  *
 146  * Returns:     ---
 147  *
 148  * Use:         Reads a line from a file descriptor.  The read is done one
 149  *              character at a time.  If the entire line won't fit, the end
 150  *              is truncated.  The line is null terminated.
 151  */
 152
 153 void pixie_fdline(int fd, char *buf, size_t sz)
 154 {
 155   char *p = buf;
 156   char *q = p + sz - 1;
 157
 158   for (;;) {
 159     char c;
 160     if (read(fd, &c, 1) < 1)
 161       break;
 162     if (c == '\n')
 163       break;
 164     if (p < q)
 165       *p++ = c;
 166   }
 167   *p = 0;
 168 }
 169
 170 /* --- @pixie_getpass@ --- *
 171  *
 172  * Arguments:   @const char *prompt@ = pointer to prompt string
 173  *              @char *buf@ = pointer to buffer
 174  *              @size_t sz@ = size of buffer
 175  *
 176  * Returns:     Zero if it worked OK, nonzero otherwise.
 177  *
 178  * Use:         Reads a passphrase from the terminal or some other requested
 179  *              source.
 180  */
 181
 182 int pixie_getpass(const char *prompt, char *buf, size_t sz)
 183 {
 184   const char *pfd = getenv("CATACOMB_PASSPHRASE_FD");
 185   struct termios ta;
 186   struct termios ota;
 187   char nl = '\n';
 188   int fd = 0;
 189
 190   /* --- See whether a terminal is what's wanted --- */
 191
 192   if (pfd) {
 193     fd = atoi(pfd);
 194     pixie_fdline(fd, buf, sz);
 195   } else {
 196     if ((fd = open("/dev/tty", O_RDWR)) < 0)
 197       goto fail_0;
 198     if (tcgetattr(fd, &ta) < 0)
 199       goto fail_1;
 200     ota = ta;
 201     ta.c_lflag &= ~(ECHO | ISIG);
 202     if (tcsetattr(fd, TCSAFLUSH, &ta)) goto fail_1;
 203     if (write(fd, prompt, strlen(prompt)) < 0) goto fail_2;
 204     pixie_fdline(fd, buf, sz);
 205     tcsetattr(fd, TCSAFLUSH, &ota);
 206     if (write(fd, &nl, 1) < 0) goto fail_1;
 207     close(fd);
 208   }
 209   return (0);
 210
 211   /* --- Tidy up if things went wrong --- */
 212
 213 fail_2:
 214   tcsetattr(fd, TCSAFLUSH, &ota);
 215 fail_1:
 216   close(fd);
 217 fail_0:
 218   return (-1);
 219 }
 220
 221 /* --- @pixie_open@ --- *
 222  *
 223  * Arguments:   @const char *sock@ = path to pixie socket
 224  *
 225  * Returns:     Less than zero if it failed, or file descriptor.
 226  *
 227  * Use:         Opens a connection to a passphrase pixie.
 228  */
 229
 230 int pixie_open(const char *sock)
 231 {
 232   struct sockaddr_un *sun;
 233   size_t sz;
 234   int fd;
 235
 236   /* --- Open the connection --- */
 237
 238   if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
 239     goto fail_0;
 240   sun = pixie_address(sock, &sz);
 241   if (connect(fd, (struct sockaddr *)sun, sz))
 242     goto fail_1;
 243   xfree(sun);
 244   return (fd);
 245
 246   /* --- Tidy up if things went wrong --- */
 247
 248 fail_1:
 249   xfree(sun);
 250   close(fd);
 251 fail_0:
 252   return (-1);
 253 }
 254
 255 /* --- @pixie_read@ --- *
 256  *
 257  * Arguments:   @int fd@ = connection to passphrase pixie
 258  *              @const char *tag@ = pointer to tag string
 259  *              @unsigned mode@ = reading mode
 260  *              @char *buf@ = pointer to destination buffer
 261  *              @size_t sz@ = size of the buffer
 262  *
 263  * Returns:     Zero if all went well, @-1@ if the read fails, @+1@ to
 264  *              request the passphrase from the user.
 265  *
 266  * Use:         Reads a passphrase from the pixie.
 267  */
 268
 269 int pixie_read(int fd, const char *tag, unsigned mode, char *buf, size_t sz)
 270 {
 271   dstr d = DSTR_INIT;
 272   char *p, *q;
 273
 274   /* --- Send the request --- */
 275
 276   dstr_putf(&d, "%s %s\n", mode == PMODE_READ ? "PASS" : "VERIFY", tag);
 277   if (write(fd, d.buf, d.len) < 0) return (-1);
 278   dstr_destroy(&d);
 279
 280   /* --- Sort out the result --- */
 281
 282 again:
 283   pixie_fdline(fd, buf, sz);
 284   p = buf;
 285   if ((q = str_getword(&p)) == 0)
 286     return (-1);
 287   if (STRCMP(q, ==, "INFO"))
 288     goto again;
 289   else if (STRCMP(q, ==, "MISSING"))
 290     return (+1);
 291   else if (STRCMP(q, !=, "OK"))
 292     return (-1);
 293
 294   /* --- Return the final answer --- */
 295
 296   if (p)
 297     memmove(buf, p, strlen(p) + 1);
 298   else
 299     *buf = 0;
 300   return (0);
 301 }
 302
 303 /* --- @pixie_set@ --- *
 304  *
 305  * Arguments:   @int fd@ = pixie file descriptor
 306  *              @const char *tag@ = pointer to tag string
 307  *              @const char *phrase@ = pointer to passphrase string
 308  *
 309  * Returns:     ---
 310  *
 311  * Use:         Sends a passphrase to the passphrase pixie.
 312  */
 313
 314 void pixie_set(int fd, const char *tag, const char *phrase)
 315 {
 316   dstr d = DSTR_INIT;
 317   char buf[16];
 318   size_t sz = strlen(phrase);
 319   char nl = '\n';
 320   char *p, *q;
 321
 322   /* --- Send the request --- *
 323    *
 324    * I didn't want to copy it out of the caller's buffer.  @writev@ may
 325    * produce a copy, too, so I didn't do that either.
 326    */
 327
 328   dstr_putf(&d, "SET %s -- ", tag);
 329   if (write(fd, d.buf, d.len) < 0 ||
 330       write(fd, phrase, sz) < 0 ||
 331       write(fd, &nl, 1) < 0)
 332     return;
 333   dstr_destroy(&d);
 334
 335   /* --- Pick up the pieces --- */
 336
 337 again:
 338   pixie_fdline(fd, buf, sizeof(buf));
 339   p = buf;
 340   if ((q = str_getword(&p)) != 0 && STRCMP(q, ==, "INFO"))
 341     goto again;
 342 }
 343
 344 /* --- @pixie_cancel@ --- *
 345  *
 346  * Arguments:   @int fd@ = pixie file descriptor
 347  *              @const char *tag@ = pointer to tag string
 348  *
 349  * Returns:     ---
 350  *
 351  * Use:         Cancels a passphrase if it turns out to be bogus.
 352  */
 353
 354 void pixie_cancel(int fd, const char *tag)
 355 {
 356   dstr d = DSTR_INIT;
 357   char buf[16];
 358   char *p, *q;
 359
 360   /* --- Send the request --- */
 361
 362   dstr_putf(&d, "FLUSH %s\n", tag);
 363   if (write(fd, d.buf, d.len) < 0) return;
 364   dstr_destroy(&d);
 365
 366   /* --- Sort out the result --- */
 367
 368 again:
 369   pixie_fdline(fd, buf, sizeof(buf));
 370   p = buf;
 371   if ((q = str_getword(&p)) != 0 && STRCMP(q, ==, "INFO"))
 372     goto again;
 373 }
 374
 375 /*----- That's all, folks -------------------------------------------------*/