keydb_keyd.c

   1 /*
   2  * keydb_keyd.c - Routines to talk to keyd backend.
   3  *
   4  * Copyright 2002-2004,2011 Jonathan McDowell <noodles@earth.li>
   5  *
   6  * This program is free software: you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the Free
   8  * Software Foundation; version 2 of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program; if not, write to the Free Software Foundation, Inc., 51
  17  * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <sys/socket.h>
  26 #include <sys/types.h>
  27 #include <sys/un.h>
  28 #include <unistd.h>
  29
  30 #include "charfuncs.h"
  31 #include "keyd.h"
  32 #include "keydb.h"
  33 #include "keyid.h"
  34 #include "keystructs.h"
  35 #include "log.h"
  36 #include "mem.h"
  37 #include "onak-conf.h"
  38 #include "parsekey.h"
  39
  40 /**
  41  *      starttrans - Start a transaction.
  42  *
  43  *      Start a transaction. Intended to be used if we're about to perform many
  44  *      operations on the database to help speed it all up, or if we want
  45  *      something to only succeed if all relevant operations are successful.
  46  */
  47 static bool keyd_starttrans(struct onak_dbctx *dbctx)
  48 {
  49         return true;
  50 }
  51
  52 /**
  53  *      endtrans - End a transaction.
  54  *
  55  *      Ends a transaction.
  56  */
  57 static void keyd_endtrans(struct onak_dbctx *dbctx)
  58 {
  59         return;
  60 }
  61
  62 static bool keyd_send_cmd(int fd, enum keyd_ops _cmd)
  63 {
  64         uint32_t cmd = _cmd;
  65         ssize_t bytes;
  66
  67         bytes = write(fd, &cmd, sizeof(cmd));
  68         if (bytes != sizeof(cmd)) {
  69                 return false;
  70         }
  71
  72         bytes = read(fd, &cmd, sizeof(cmd));
  73         if (bytes != sizeof(cmd)) {
  74                 return false;
  75         }
  76
  77         if (cmd != KEYD_REPLY_OK) {
  78                 return false;
  79         }
  80
  81         return true;
  82 }
  83
  84 /**
  85  *      fetch_key - Given a keyid fetch the key from storage.
  86  *      @keyid: The keyid to fetch.
  87  *      @publickey: A pointer to a structure to return the key in.
  88  *      @intrans: If we're already in a transaction.
  89  *
  90  *      This function returns a public key from whatever storage mechanism we
  91  *      are using.
  92  *
  93  *      TODO: What about keyid collisions? Should we use fingerprint instead?
  94  */
  95 static int keyd_fetch_key_id(struct onak_dbctx *dbctx,
  96                 uint64_t keyid,
  97                 struct openpgp_publickey **publickey,
  98                 bool intrans)
  99 {
 100         int keyd_fd = (intptr_t) dbctx->priv;
 101         struct buffer_ctx           keybuf;
 102         struct openpgp_packet_list *packets = NULL;
 103         ssize_t                     bytes = 0;
 104         ssize_t                     count = 0;
 105
 106         if (keyd_send_cmd(keyd_fd, KEYD_CMD_GET_ID)) {
 107                 write(keyd_fd, &keyid, sizeof(keyid));
 108                 keybuf.offset = 0;
 109                 read(keyd_fd, &keybuf.size, sizeof(keybuf.size));
 110                 if (keybuf.size > 0) {
 111                         keybuf.buffer = malloc(keybuf.size);
 112                         bytes = count = 0;
 113                         logthing(LOGTHING_TRACE,
 114                                         "Getting %d bytes of key data.",
 115                                         keybuf.size);
 116                         while (bytes >= 0 && count < keybuf.size) {
 117                                 bytes = read(keyd_fd, &keybuf.buffer[count],
 118                                                 keybuf.size - count);
 119                                 logthing(LOGTHING_TRACE,
 120                                                 "Read %d bytes.", bytes);
 121                                 count += bytes;
 122                         }
 123                         read_openpgp_stream(buffer_fetchchar, &keybuf,
 124                                         &packets, 0);
 125                         parse_keys(packets, publickey);
 126                         free_packet_list(packets);
 127                         packets = NULL;
 128                         free(keybuf.buffer);
 129                         keybuf.buffer = NULL;
 130                         keybuf.size = 0;
 131                 }
 132         }
 133
 134         return (count > 0) ? 1 : 0;
 135 }
 136
 137 static int keyd_fetch_key_fp(struct onak_dbctx *dbctx,
 138                 struct openpgp_fingerprint *fingerprint,
 139                 struct openpgp_publickey **publickey,
 140                 bool intrans)
 141 {
 142         int keyd_fd = (intptr_t) dbctx->priv;
 143         struct buffer_ctx           keybuf;
 144         struct openpgp_packet_list *packets = NULL;
 145         ssize_t                     bytes = 0;
 146         ssize_t                     count = 0;
 147         uint8_t                     size;
 148
 149         if (fingerprint->length > MAX_FINGERPRINT_LEN) {
 150                 return 0;
 151         }
 152
 153         if (keyd_send_cmd(keyd_fd, KEYD_CMD_GET_FP)) {
 154                 size = fingerprint->length;
 155                 write(keyd_fd, &size, sizeof(size));
 156                 write(keyd_fd, fingerprint->fp, size);
 157                 keybuf.offset = 0;
 158                 read(keyd_fd, &keybuf.size, sizeof(keybuf.size));
 159                 if (keybuf.size > 0) {
 160                         keybuf.buffer = malloc(keybuf.size);
 161                         bytes = count = 0;
 162                         logthing(LOGTHING_TRACE,
 163                                         "Getting %d bytes of key data.",
 164                                         keybuf.size);
 165                         while (bytes >= 0 && count < keybuf.size) {
 166                                 bytes = read(keyd_fd, &keybuf.buffer[count],
 167                                                 keybuf.size - count);
 168                                 logthing(LOGTHING_TRACE,
 169                                                 "Read %d bytes.", bytes);
 170                                 count += bytes;
 171                         }
 172                         read_openpgp_stream(buffer_fetchchar, &keybuf,
 173                                         &packets, 0);
 174                         parse_keys(packets, publickey);
 175                         free_packet_list(packets);
 176                         packets = NULL;
 177                         free(keybuf.buffer);
 178                         keybuf.buffer = NULL;
 179                         keybuf.size = 0;
 180                 }
 181         }
 182
 183         return (count > 0) ? 1 : 0;
 184 }
 185
 186 /**
 187 *       delete_key - Given a keyid delete the key from storage.
 188 *       @keyid: The keyid to delete.
 189 *       @intrans: If we're already in a transaction.
 190 *
 191 *       This function deletes a public key from whatever storage mechanism we
 192 *       are using. Returns 0 if the key existed.
 193 */
 194 static int keyd_delete_key(struct onak_dbctx *dbctx,
 195                 uint64_t keyid, bool intrans)
 196 {
 197         int keyd_fd = (intptr_t) dbctx->priv;
 198
 199         if (keyd_send_cmd(keyd_fd, KEYD_CMD_DELETE)) {
 200                 write(keyd_fd, &keyid, sizeof(keyid));
 201         }
 202
 203         return 0;
 204 }
 205
 206 /**
 207  *      store_key - Takes a key and stores it.
 208  *      @publickey: A pointer to the public key to store.
 209  *      @intrans: If we're already in a transaction.
 210  *      @update: If true the key exists and should be updated.
 211  *
 212  *      This function stores a public key in whatever storage mechanism we are
 213  *      using. intrans indicates if we're already in a transaction so don't
 214  *      need to start one. update indicates if the key already exists and is
 215  *      just being updated.
 216  *
 217  *      TODO: Do we store multiple keys of the same id? Or only one and replace
 218  *      it?
 219  */
 220 static int keyd_store_key(struct onak_dbctx *dbctx,
 221                 struct openpgp_publickey *publickey, bool intrans,
 222                 bool update)
 223 {
 224         int keyd_fd = (intptr_t) dbctx->priv;
 225         struct buffer_ctx           keybuf;
 226         struct openpgp_packet_list *packets = NULL;
 227         struct openpgp_packet_list *list_end = NULL;
 228         struct openpgp_publickey   *next = NULL;
 229         uint64_t                    keyid;
 230
 231         if (get_keyid(publickey, &keyid) != ONAK_E_OK) {
 232                 logthing(LOGTHING_ERROR, "Couldn't find key ID for key.");
 233                 return 0;
 234         }
 235
 236         if (update) {
 237                 keyd_delete_key(dbctx, keyid, false);
 238         }
 239
 240         if (keyd_send_cmd(keyd_fd, KEYD_CMD_STORE)) {
 241                 keybuf.offset = 0;
 242                 keybuf.size = 8192;
 243                 keybuf.buffer = malloc(keybuf.size);
 244
 245                 next = publickey->next;
 246                 publickey->next = NULL;
 247                 flatten_publickey(publickey,
 248                                 &packets,
 249                                 &list_end);
 250                 publickey->next = next;
 251
 252                 write_openpgp_stream(buffer_putchar, &keybuf, packets);
 253                 logthing(LOGTHING_TRACE, "Sending %d bytes.", keybuf.offset);
 254                 write(keyd_fd, &keybuf.offset, sizeof(keybuf.offset));
 255                 write(keyd_fd, keybuf.buffer, keybuf.offset);
 256
 257                 free_packet_list(packets);
 258                 packets = list_end = NULL;
 259                 free(keybuf.buffer);
 260                 keybuf.buffer = NULL;
 261                 keybuf.size = keybuf.offset = 0;
 262         }
 263
 264         return 0;
 265 }
 266
 267 /**
 268  *      fetch_key_text - Trys to find the keys that contain the supplied text.
 269  *      @search: The text to search for.
 270  *      @publickey: A pointer to a structure to return the key in.
 271  *
 272  *      This function searches for the supplied text and returns the keys that
 273  *      contain it.
 274  */
 275 static int keyd_fetch_key_text(struct onak_dbctx *dbctx,
 276                 const char *search,
 277                 struct openpgp_publickey **publickey)
 278 {
 279         int keyd_fd = (intptr_t) dbctx->priv;
 280         struct buffer_ctx           keybuf;
 281         struct openpgp_packet_list *packets = NULL;
 282         ssize_t                     bytes = 0;
 283         ssize_t                     count = 0;
 284
 285         if (keyd_send_cmd(keyd_fd, KEYD_CMD_GET_TEXT)) {
 286                 bytes = strlen(search);
 287                 write(keyd_fd, &bytes, sizeof(bytes));
 288                 write(keyd_fd, search, bytes);
 289                 keybuf.offset = 0;
 290                 read(keyd_fd, &keybuf.size, sizeof(keybuf.size));
 291                 if (keybuf.size > 0) {
 292                         keybuf.buffer = malloc(keybuf.size);
 293                         bytes = count = 0;
 294                         logthing(LOGTHING_TRACE,
 295                                         "Getting %d bytes of key data.",
 296                                         keybuf.size);
 297                         while (bytes >= 0 && count < keybuf.size) {
 298                                 bytes = read(keyd_fd, &keybuf.buffer[count],
 299                                                 keybuf.size - count);
 300                                 logthing(LOGTHING_TRACE,
 301                                                 "Read %d bytes.", bytes);
 302                                 count += bytes;
 303                         }
 304                         read_openpgp_stream(buffer_fetchchar, &keybuf,
 305                                         &packets, 0);
 306                         parse_keys(packets, publickey);
 307                         free_packet_list(packets);
 308                         packets = NULL;
 309                         free(keybuf.buffer);
 310                         keybuf.buffer = NULL;
 311                         keybuf.size = 0;
 312                 }
 313         }
 314
 315         return (count > 0) ? 1 : 0;
 316
 317         return 0;
 318 }
 319
 320 static int keyd_fetch_key_skshash(struct onak_dbctx *dbctx,
 321                 const struct skshash *hash,
 322                 struct openpgp_publickey **publickey)
 323 {
 324         int keyd_fd = (intptr_t) dbctx->priv;
 325         struct buffer_ctx           keybuf;
 326         struct openpgp_packet_list *packets = NULL;
 327         ssize_t                     bytes = 0;
 328         ssize_t                     count = 0;
 329
 330         if (keyd_send_cmd(keyd_fd, KEYD_CMD_GET_SKSHASH)) {
 331                 write(keyd_fd, hash->hash, sizeof(hash->hash));
 332                 keybuf.offset = 0;
 333                 read(keyd_fd, &keybuf.size, sizeof(keybuf.size));
 334                 if (keybuf.size > 0) {
 335                         keybuf.buffer = malloc(keybuf.size);
 336                         bytes = count = 0;
 337                         logthing(LOGTHING_TRACE,
 338                                         "Getting %d bytes of key data.",
 339                                         keybuf.size);
 340                         while (bytes >= 0 && count < keybuf.size) {
 341                                 bytes = read(keyd_fd, &keybuf.buffer[count],
 342                                                 keybuf.size - count);
 343                                 logthing(LOGTHING_TRACE,
 344                                                 "Read %d bytes.", bytes);
 345                                 count += bytes;
 346                         }
 347                         read_openpgp_stream(buffer_fetchchar, &keybuf,
 348                                         &packets, 0);
 349                         parse_keys(packets, publickey);
 350                         free_packet_list(packets);
 351                         packets = NULL;
 352                         free(keybuf.buffer);
 353                         keybuf.buffer = NULL;
 354                         keybuf.size = 0;
 355                 }
 356         }
 357
 358         return (count > 0) ? 1 : 0;
 359 }
 360
 361
 362 /**
 363  *      getfullkeyid - Maps a 32bit key id to a 64bit one.
 364  *      @keyid: The 32bit keyid.
 365  *
 366  *      This function maps a 32bit key id to the full 64bit one. It returns the
 367  *      full keyid. If the key isn't found a keyid of 0 is returned.
 368  */
 369 static uint64_t keyd_getfullkeyid(struct onak_dbctx *dbctx, uint64_t keyid)
 370 {
 371         int keyd_fd = (intptr_t) dbctx->priv;
 372         uint32_t cmd = KEYD_CMD_GETFULLKEYID;
 373
 374         if (keyd_send_cmd(keyd_fd, KEYD_CMD_GETFULLKEYID)) {
 375                 write(keyd_fd, &keyid, sizeof(keyid));
 376                 read(keyd_fd, &cmd, sizeof(cmd));
 377                 if (cmd != sizeof(keyid)) {
 378                         return 0;
 379                 }
 380                 read(keyd_fd, &keyid, sizeof(keyid));
 381         }
 382
 383         return keyid;
 384 }
 385
 386 /**
 387  *      iterate_keys - call a function once for each key in the db.
 388  *      @iterfunc: The function to call.
 389  *      @ctx: A context pointer
 390  *
 391  *      Calls iterfunc once for each key in the database. ctx is passed
 392  *      unaltered to iterfunc. This function is intended to aid database dumps
 393  *      and statistic calculations.
 394  *
 395  *      Returns the number of keys we iterated over.
 396  */
 397 static int keyd_iterate_keys(struct onak_dbctx *dbctx,
 398                 void (*iterfunc)(void *ctx,
 399                 struct openpgp_publickey *key), void *ctx)
 400 {
 401         int keyd_fd = (intptr_t) dbctx->priv;
 402         struct buffer_ctx           keybuf;
 403         struct openpgp_packet_list *packets = NULL;
 404         struct openpgp_publickey   *key = NULL;
 405         ssize_t                     bytes = 0;
 406         ssize_t                     count = 0;
 407         int                         numkeys = 0;
 408
 409         if (keyd_send_cmd(keyd_fd, KEYD_CMD_KEYITER)) {
 410                 keybuf.offset = 0;
 411                 read(keyd_fd, &keybuf.size, sizeof(keybuf.size));
 412                 while (keybuf.size > 0) {
 413                         keybuf.buffer = malloc(keybuf.size);
 414                         bytes = count = 0;
 415                         logthing(LOGTHING_TRACE,
 416                                         "Getting %d bytes of key data.",
 417                                         keybuf.size);
 418                         while (bytes >= 0 && count < keybuf.size) {
 419                                 bytes = read(keyd_fd, &keybuf.buffer[count],
 420                                                 keybuf.size - count);
 421                                 logthing(LOGTHING_TRACE,
 422                                                 "Read %d bytes.", bytes);
 423                                 count += bytes;
 424                         }
 425                         read_openpgp_stream(buffer_fetchchar, &keybuf,
 426                                         &packets, 0);
 427                         parse_keys(packets, &key);
 428
 429                         if (iterfunc != NULL && key != NULL) {
 430                                 iterfunc(ctx, key);
 431                         }
 432
 433                         free_publickey(key);
 434                         key = NULL;
 435                         free_packet_list(packets);
 436                         packets = NULL;
 437                         free(keybuf.buffer);
 438                         keybuf.buffer = NULL;
 439                         keybuf.size = keybuf.offset = 0;
 440
 441                         numkeys++;
 442
 443                         read(keyd_fd, &keybuf.size, sizeof(keybuf.size));
 444                 }
 445         }
 446
 447         return numkeys;
 448 }
 449
 450 #define NEED_KEYID2UID 1
 451 #define NEED_GETKEYSIGS 1
 452 #define NEED_UPDATEKEYS 1
 453 #include "keydb.c"
 454
 455 /**
 456  *      cleanupdb - De-initialize the key database.
 457  *
 458  *      This function should be called upon program exit to allow the DB to
 459  *      cleanup after itself.
 460  */
 461 static void keyd_cleanupdb(struct onak_dbctx *dbctx)
 462 {
 463         int keyd_fd = (intptr_t) dbctx->priv;
 464         uint32_t cmd = KEYD_CMD_CLOSE;
 465
 466         if (write(keyd_fd, &cmd, sizeof(cmd)) != sizeof(cmd)) {
 467                 logthing(LOGTHING_CRITICAL,
 468                                 "Couldn't send close cmd: %s (%d)",
 469                                 strerror(errno),
 470                                 errno);
 471         }
 472
 473         if (read(keyd_fd, &cmd, sizeof(cmd)) != sizeof(cmd)) {
 474                 logthing(LOGTHING_CRITICAL,
 475                         "Couldn't read close cmd reply: %s (%d)",
 476                         strerror(errno),
 477                         errno);
 478         } else if (cmd != KEYD_REPLY_OK) {
 479                 logthing(LOGTHING_CRITICAL,
 480                         "Got bad reply to KEYD_CMD_CLOSE: %d", cmd);
 481         }
 482
 483         if (shutdown(keyd_fd, SHUT_RDWR) < 0) {
 484                 logthing(LOGTHING_NOTICE, "Error shutting down socket: %d",
 485                                 errno);
 486         }
 487         if (close(keyd_fd) < 0) {
 488                 logthing(LOGTHING_NOTICE, "Error closing down socket: %d",
 489                                 errno);
 490         }
 491
 492         free(dbctx);
 493
 494         return;
 495 }
 496
 497 /**
 498  *      initdb - Initialize the key database.
 499  *      @readonly: If we'll only be reading the DB, not writing to it.
 500  *
 501  *      This function should be called before any of the other functions in
 502  *      this file are called in order to allow the DB to be initialized ready
 503  *      for access.
 504  */
 505 struct onak_dbctx *keydb_keyd_init(struct onak_db_config *dbcfg, bool readonly)
 506 {
 507         struct sockaddr_un sock;
 508         uint32_t           cmd = KEYD_CMD_UNKNOWN;
 509         uint32_t           reply = KEYD_REPLY_UNKNOWN_CMD;
 510         ssize_t            count;
 511         int keyd_fd;
 512         struct onak_dbctx *dbctx;
 513
 514         dbctx = malloc(sizeof(*dbctx));
 515         if (dbctx == NULL) {
 516                 return NULL;
 517         }
 518         dbctx->config = dbcfg;
 519
 520         keyd_fd = socket(PF_UNIX, SOCK_STREAM, 0);
 521         if (keyd_fd < 0) {
 522                 logthing(LOGTHING_CRITICAL,
 523                                 "Couldn't open socket: %s (%d)",
 524                                 strerror(errno),
 525                                 errno);
 526                 exit(EXIT_FAILURE);
 527         }
 528
 529         sock.sun_family = AF_UNIX;
 530         snprintf(sock.sun_path, sizeof(sock.sun_path) - 1, "%s/%s",
 531                         config.sock_dir,
 532                         KEYD_SOCKET);
 533         if (connect(keyd_fd, (struct sockaddr *) &sock, sizeof(sock)) < 0) {
 534                 logthing(LOGTHING_CRITICAL,
 535                                 "Couldn't connect to socket %s: %s (%d)",
 536                                 sock.sun_path,
 537                                 strerror(errno),
 538                                 errno);
 539                 exit(EXIT_FAILURE);
 540         }
 541
 542         cmd = KEYD_CMD_VERSION;
 543         if (write(keyd_fd, &cmd, sizeof(cmd)) != sizeof(cmd)) {
 544                 logthing(LOGTHING_CRITICAL,
 545                                 "Couldn't write version cmd: %s (%d)",
 546                                 strerror(errno),
 547                                 errno);
 548         } else {
 549                 count = read(keyd_fd, &reply, sizeof(reply));
 550                 if (count == sizeof(reply) && reply == KEYD_REPLY_OK) {
 551                         count = read(keyd_fd, &reply, sizeof(reply));
 552                         if (count != sizeof(reply) || reply != sizeof(reply)) {
 553                                 logthing(LOGTHING_CRITICAL,
 554                                         "Error! Unexpected keyd version "
 555                                         "length: %d != %d",
 556                                         reply, sizeof(reply));
 557                                 exit(EXIT_FAILURE);
 558                         }
 559
 560                         count = read(keyd_fd, &reply, sizeof(reply));
 561                         if (count != sizeof(reply)) {
 562                                 logthing(LOGTHING_CRITICAL,
 563                                         "Error! Unexpected keyd version "
 564                                         "length: %d != %d",
 565                                         count, sizeof(reply));
 566                                 exit(EXIT_FAILURE);
 567                         }
 568                         logthing(LOGTHING_DEBUG,
 569                                         "keyd protocol version %d",
 570                                         reply);
 571                         if (reply != keyd_version) {
 572                                 logthing(LOGTHING_CRITICAL,
 573                                         "Error! keyd protocol version "
 574                                         "mismatch. (us = %d, it = %d)",
 575                                                 keyd_version, reply);
 576                         }
 577                 }
 578         }
 579
 580         dbctx->priv                     = (void *) (intptr_t) keyd_fd;
 581         dbctx->cleanupdb                = keyd_cleanupdb;
 582         dbctx->starttrans               = keyd_starttrans;
 583         dbctx->endtrans                 = keyd_endtrans;
 584         dbctx->fetch_key_id             = keyd_fetch_key_id;
 585         dbctx->fetch_key_fp             = keyd_fetch_key_fp;
 586         dbctx->fetch_key_text           = keyd_fetch_key_text;
 587         dbctx->fetch_key_skshash        = keyd_fetch_key_skshash;
 588         dbctx->store_key                = keyd_store_key;
 589         dbctx->update_keys              = generic_update_keys;
 590         dbctx->delete_key               = keyd_delete_key;
 591         dbctx->getkeysigs               = generic_getkeysigs;
 592         dbctx->cached_getkeysigs        = generic_cached_getkeysigs;
 593         dbctx->keyid2uid                = generic_keyid2uid;
 594         dbctx->getfullkeyid             = keyd_getfullkeyid;
 595         dbctx->iterate_keys             = keyd_iterate_keys;
 596
 597         return dbctx;
 598 }