onak.c

   1 /*
   2  * onak.c - An OpenPGP keyserver.
   3  *
   4  * This is the main swiss army knife binary.
   5  *
   6  * Copyright 2002 Jonathan McDowell <noodles@earth.li>
   7  *
   8  * This program is free software: you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the Free
  10  * Software Foundation; version 2 of the License.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program.  If not, see <https://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <fcntl.h>
  22 #include <getopt.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29
  30 #include "build-config.h"
  31
  32 #include "armor.h"
  33 #include "charfuncs.h"
  34 #include "cleankey.h"
  35 #include "cleanup.h"
  36 #include "keydb.h"
  37 #include "keyid.h"
  38 #include "keyindex.h"
  39 #include "keystructs.h"
  40 #include "log.h"
  41 #include "mem.h"
  42 #include "merge.h"
  43 #include "onak-conf.h"
  44 #include "parsekey.h"
  45 #include "photoid.h"
  46
  47 void find_keys(struct onak_dbctx *dbctx,
  48                 char *search, uint64_t keyid,
  49                 struct openpgp_fingerprint *fingerprint,
  50                 bool ishex, bool isfp, bool dispfp, bool skshash,
  51                 bool exact, bool verbose)
  52 {
  53         struct openpgp_publickey *publickey = NULL;
  54         int count = 0;
  55
  56         if (ishex) {
  57                 count = dbctx->fetch_key_id(dbctx, keyid, &publickey,
  58                                 false);
  59         } else if (isfp) {
  60                 count = dbctx->fetch_key_fp(dbctx, fingerprint,
  61                                 &publickey, false);
  62         } else {
  63                 count = dbctx->fetch_key_text(dbctx, search, &publickey);
  64         }
  65         if (publickey != NULL) {
  66                 key_index(dbctx, publickey, verbose, dispfp, skshash,
  67                         false);
  68                 free_publickey(publickey);
  69         } else if (count == 0) {
  70                 puts("Key not found.");
  71         } else {
  72                 printf("Found %d keys, but maximum number to return is %d.\n",
  73                                 count,
  74                                 config.maxkeys);
  75                 puts("Try again with a more specific search.");
  76         }
  77 }
  78
  79 /**
  80  * @brief Context for the keyserver dumping function
  81  */
  82 struct dump_ctx {
  83         /** Keys we've dumped so far to this file */
  84         int count;
  85         /** Maximum keys to dump per file */
  86         int maxcount;
  87         /** File descriptor for the current dump file */
  88         int fd;
  89         /** Number of the current dump file */
  90         int filenum;
  91         /** Base filename to use for dump files */
  92         char *filebase;
  93 };
  94
  95 void dump_func(void *ctx, struct openpgp_publickey *key)
  96 {
  97         struct openpgp_packet_list *packets = NULL;
  98         struct openpgp_packet_list *list_end = NULL;
  99         struct dump_ctx *state;
 100         char filename[1024];
 101
 102         state = (struct dump_ctx *) ctx;
 103
 104         if (state->fd == -1 || state->count++ > state->maxcount) {
 105                 if (state->fd != -1) {
 106                         close(state->fd);
 107                         state->fd = -1;
 108                 }
 109                 snprintf(filename, 1023, state->filebase, state->filenum);
 110                 state->fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0640);
 111                 state->filenum++;
 112                 state->count = 0;
 113         }
 114         flatten_publickey(key, &packets, &list_end);
 115         write_openpgp_stream(file_putchar, &state->fd, packets);
 116         free_packet_list(packets);
 117         packets = list_end = NULL;
 118
 119         return;
 120 }
 121
 122 static uint8_t hex2bin(char c)
 123 {
 124         if (c >= '0' && c <= '9') {
 125                 return (c - '0');
 126         } else if (c >= 'a' && c <= 'f') {
 127                 return (c - 'a' + 10);
 128         } else if (c >= 'A' && c <= 'F') {
 129                 return (c - 'A' + 10);
 130         }
 131
 132         return 255;
 133 }
 134
 135 void usage(void) {
 136         puts("onak " ONAK_VERSION " - an OpenPGP keyserver.\n");
 137         puts("Usage:\n");
 138         puts("\tonak [options] <command> <parameters>\n");
 139         puts("\tCommands:\n");
 140         puts("\tadd      - read armored OpenPGP keys from stdin and add to the"
 141                 " keyserver");
 142         puts("\tclean    - read armored OpenPGP keys from stdin, run the"
 143                 " cleaning\n\t             routines against them and dump to"
 144                 " stdout");
 145         puts("\tdelete   - delete a given key from the keyserver");
 146         puts("\tdump     - dump all the keys from the keyserver to a file or"
 147                 " files\n\t           starting keydump*");
 148         puts("\tget      - retrieves the key requested from the keyserver");
 149         puts("\tgetphoto - retrieves the first photoid on the given key and"
 150                 " dumps to\n\t           stdout");
 151         puts("\tindex    - search for a key and list it");
 152         puts("\treindex  - retrieve and re-store a key in the backend db");
 153         puts("\tvindex   - search for a key and list it and its signatures");
 154 }
 155
 156 int main(int argc, char *argv[])
 157 {
 158         struct openpgp_packet_list      *packets = NULL;
 159         struct openpgp_packet_list      *list_end = NULL;
 160         struct openpgp_publickey        *keys = NULL;
 161         char                            *configfile = NULL;
 162         int                              rc = EXIT_SUCCESS;
 163         int                              result = 0;
 164         char                            *search = NULL;
 165         char                            *end = NULL;
 166         uint64_t                         keyid = 0;
 167         int                              i;
 168         bool                             ishex = false;
 169         bool                             isfp = false;
 170         bool                             update = false;
 171         bool                             binary = false;
 172         bool                             dispfp = false;
 173         bool                             skshash = false;
 174         int                              optchar;
 175         struct dump_ctx                  dumpstate;
 176         struct skshash                   hash;
 177         struct onak_dbctx               *dbctx;
 178         struct openpgp_fingerprint       fingerprint;
 179
 180         while ((optchar = getopt(argc, argv, "bc:fsuv")) != -1 ) {
 181                 switch (optchar) {
 182                 case 'b':
 183                         binary = true;
 184                         break;
 185                 case 'c':
 186                         configfile = strdup(optarg);
 187                         break;
 188                 case 'f':
 189                         dispfp = true;
 190                         break;
 191                 case 's':
 192                         skshash = true;
 193                         break;
 194                 case 'u':
 195                         update = true;
 196                         break;
 197                 case 'v':
 198                         setlogthreshold(LOGTHING_INFO);
 199                         break;
 200                 }
 201         }
 202
 203         readconfig(configfile);
 204         initlogthing("onak", config.logfile);
 205         catchsignals();
 206
 207         if ((argc - optind) < 1) {
 208                 usage();
 209         } else if (!strcmp("dump", argv[optind])) {
 210                 dbctx = config.dbinit(config.backend, true);
 211                 dumpstate.count = dumpstate.filenum = 0;
 212                 dumpstate.maxcount = 100000;
 213                 dumpstate.fd = -1;
 214                 dumpstate.filebase = "keydump.%d.pgp";
 215                 dbctx->iterate_keys(dbctx, dump_func, &dumpstate);
 216                 if (dumpstate.fd != -1) {
 217                         close(dumpstate.fd);
 218                         dumpstate.fd = -1;
 219                 }
 220                 dbctx->cleanupdb(dbctx);
 221         } else if (!strcmp("add", argv[optind])) {
 222                 if (binary) {
 223                         result = read_openpgp_stream(stdin_getchar, NULL,
 224                                  &packets, 0);
 225                         logthing(LOGTHING_INFO,
 226                                         "read_openpgp_stream: %d", result);
 227                 } else {
 228                         dearmor_openpgp_stream(stdin_getchar, NULL, &packets);
 229                 }
 230                 if (packets != NULL) {
 231                         result = parse_keys(packets, &keys);
 232                         free_packet_list(packets);
 233                         packets = NULL;
 234                         logthing(LOGTHING_INFO, "Finished reading %d keys.",
 235                                         result);
 236
 237                         result = cleankeys(&keys, config.clean_policies);
 238                         logthing(LOGTHING_INFO, "%d keys cleaned.",
 239                                         result);
 240
 241                         dbctx = config.dbinit(config.backend, false);
 242                         logthing(LOGTHING_NOTICE, "Got %d new keys.",
 243                                         dbctx->update_keys(dbctx, &keys,
 244                                         false));
 245                         if (keys != NULL && update) {
 246                                 flatten_publickey(keys,
 247                                         &packets,
 248                                         &list_end);
 249                                 if (binary) {
 250                                         write_openpgp_stream(stdout_putchar,
 251                                                         NULL,
 252                                                         packets);
 253                                 } else {
 254                                         armor_openpgp_stream(stdout_putchar,
 255                                                 NULL,
 256                                                 packets);
 257                                 }
 258                                 free_packet_list(packets);
 259                                 packets = NULL;
 260                         }
 261                         dbctx->cleanupdb(dbctx);
 262                 } else {
 263                         rc = 1;
 264                         logthing(LOGTHING_NOTICE, "No keys read.");
 265                 }
 266
 267                 if (keys != NULL) {
 268                         free_publickey(keys);
 269                         keys = NULL;
 270                 } else {
 271                         rc = 1;
 272                         logthing(LOGTHING_NOTICE, "No changes.");
 273                 }
 274         } else if (!strcmp("clean", argv[optind])) {
 275                 if (binary) {
 276                         result = read_openpgp_stream(stdin_getchar, NULL,
 277                                  &packets, 0);
 278                         logthing(LOGTHING_INFO,
 279                                         "read_openpgp_stream: %d", result);
 280                 } else {
 281                         dearmor_openpgp_stream(stdin_getchar, NULL, &packets);
 282                 }
 283
 284                 if (packets != NULL) {
 285                         result = parse_keys(packets, &keys);
 286                         free_packet_list(packets);
 287                         packets = NULL;
 288                         logthing(LOGTHING_INFO, "Finished reading %d keys.",
 289                                         result);
 290
 291                         if (keys != NULL) {
 292                                 result = cleankeys(&keys,
 293                                                 config.clean_policies);
 294                                 logthing(LOGTHING_INFO, "%d keys cleaned.",
 295                                                 result);
 296
 297                                 flatten_publickey(keys,
 298                                         &packets,
 299                                         &list_end);
 300
 301                                 if (binary) {
 302                                         write_openpgp_stream(stdout_putchar,
 303                                                         NULL,
 304                                                         packets);
 305                                 } else {
 306                                         armor_openpgp_stream(stdout_putchar,
 307                                                 NULL,
 308                                                 packets);
 309                                 }
 310                                 free_packet_list(packets);
 311                                 packets = NULL;
 312                         }
 313                 } else {
 314                         rc = 1;
 315                         logthing(LOGTHING_NOTICE, "No keys read.");
 316                 }
 317
 318                 if (keys != NULL) {
 319                         free_publickey(keys);
 320                         keys = NULL;
 321                 }
 322         } else if (!strcmp("dumpconfig", argv[optind])) {
 323                 if ((argc - optind) == 2) {
 324                         writeconfig(argv[optind + 1]);
 325                 } else {
 326                         /* Dump config to stdout */
 327                         writeconfig(NULL);
 328                 }
 329         } else if ((argc - optind) == 2) {
 330                 search = argv[optind+1];
 331                 if (search != NULL && strlen(search) == 42 &&
 332                                 search[0] == '0' && search[1] == 'x') {
 333                         fingerprint.length = MAX_FINGERPRINT_LEN;
 334                         for (i = 0; i < MAX_FINGERPRINT_LEN; i++) {
 335                                 fingerprint.fp[i] =
 336                                         (hex2bin(search[2 + i * 2]) << 4) +
 337                                                 hex2bin(search[3 + i * 2]);
 338                         }
 339                         isfp = true;
 340                 } else if (search != NULL) {
 341                         keyid = strtouq(search, &end, 16);
 342                         if (*search != 0 &&
 343                                         end != NULL &&
 344                                         *end == 0) {
 345                                 ishex = true;
 346                         }
 347                 }
 348                 dbctx = config.dbinit(config.backend, false);
 349                 if (!strcmp("index", argv[optind])) {
 350                         find_keys(dbctx, search, keyid, &fingerprint, ishex,
 351                                         isfp, dispfp, skshash,
 352                                         false, false);
 353                 } else if (!strcmp("vindex", argv[optind])) {
 354                         find_keys(dbctx, search, keyid, &fingerprint, ishex,
 355                                         isfp, dispfp, skshash,
 356                                         false, true);
 357                 } else if (!strcmp("getphoto", argv[optind])) {
 358                         if (!ishex) {
 359                                 puts("Can't get a key on uid text."
 360                                         " You must supply a keyid.");
 361                         } else if (dbctx->fetch_key_id(dbctx, keyid, &keys,
 362                                         false)) {
 363                                 unsigned char *photo = NULL;
 364                                 size_t         length = 0;
 365
 366                                 if (getphoto(keys, 0, &photo,
 367                                                 &length) == ONAK_E_OK) {
 368                                         fwrite(photo,
 369                                                 1,
 370                                                 length,
 371                                                 stdout);
 372                                 }
 373                                 free_publickey(keys);
 374                                 keys = NULL;
 375                         } else {
 376                                 puts("Key not found");
 377                         }
 378                 } else if (!strcmp("delete", argv[optind])) {
 379                         dbctx->delete_key(dbctx,
 380                                         dbctx->getfullkeyid(dbctx, keyid),
 381                                         false);
 382                 } else if (!strcmp("get", argv[optind])) {
 383                         if (!(ishex || isfp)) {
 384                                 puts("Can't get a key on uid text."
 385                                         " You must supply a keyid / "
 386                                         "fingerprint.");
 387                         } else if ((isfp &&
 388                                         dbctx->fetch_key_fp(dbctx,
 389                                                 &fingerprint,
 390                                                 &keys, false)) ||
 391                                         (ishex &&
 392                                         dbctx->fetch_key_id(dbctx, keyid,
 393                                                 &keys, false))) {
 394                                 logthing(LOGTHING_INFO, "Got key.");
 395                                 flatten_publickey(keys,
 396                                                 &packets,
 397                                                 &list_end);
 398                                 free_publickey(keys);
 399                                 if (binary) {
 400                                         write_openpgp_stream(stdout_putchar,
 401                                                 NULL,
 402                                                 packets);
 403                                 } else {
 404                                         armor_openpgp_stream(stdout_putchar,
 405                                                 NULL,
 406                                                 packets);
 407                                 }
 408                                 free_packet_list(packets);
 409                                 packets = NULL;
 410                         } else {
 411                                 puts("Key not found");
 412                         }
 413                 } else if (!strcmp("hget", argv[optind])) {
 414                         if (!parse_skshash(search, &hash)) {
 415                                 puts("Couldn't parse sks hash.");
 416                         } else if (dbctx->fetch_key_skshash(dbctx, &hash,
 417                                         &keys)) {
 418                                 logthing(LOGTHING_INFO, "Got key.");
 419                                 flatten_publickey(keys,
 420                                                 &packets,
 421                                                 &list_end);
 422                                 free_publickey(keys);
 423                                 if (binary) {
 424                                         write_openpgp_stream(stdout_putchar,
 425                                                 NULL,
 426                                                 packets);
 427                                 } else {
 428                                         armor_openpgp_stream(stdout_putchar,
 429                                                 NULL,
 430                                                 packets);
 431                                 }
 432                                 free_packet_list(packets);
 433                                 packets = NULL;
 434                         } else {
 435                                 puts("Key not found");
 436                         }
 437                 } else if (!strcmp("reindex", argv[optind])) {
 438                         dbctx->starttrans(dbctx);
 439                         if (dbctx->fetch_key_id(dbctx, keyid, &keys, true)) {
 440                                 dbctx->delete_key(dbctx, keyid, true);
 441                                 cleankeys(&keys, config.clean_policies);
 442                                 dbctx->store_key(dbctx, keys, true, false);
 443                         } else {
 444                                 puts("Key not found");
 445                         }
 446                         dbctx->endtrans(dbctx);
 447                 }
 448                 dbctx->cleanupdb(dbctx);
 449         } else {
 450                 usage();
 451         }
 452
 453         cleanuplogthing();
 454         cleanupconfig();
 455         free(configfile);
 456
 457         return rc;
 458 }