parsekey.c

   1 /*
   2  * parsekey.c - Routines to parse an OpenPGP key.
   3  *
   4  * Jonathan McDowell <noodles@earth.li>
   5  *
   6  * Copyright 2002 Project Purple
   7  *
   8  * $Id: parsekey.c,v 1.12 2003/09/30 17:40:41 noodles Exp $
   9  */
  10
  11 #include <assert.h>
  12 #include <stdbool.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16
  17 #include "keyid.h"
  18 #include "keystructs.h"
  19 #include "ll.h"
  20 #include "log.h"
  21 #include "mem.h"
  22 #include "parsekey.h"
  23
  24 /**
  25  *      add_key - Takes a key and adds it to the keyserver.
  26  *      @key: The public key to add.
  27  *
  28  *      This function takes a public key and adds it to the keyserver.
  29  *      It first of all sees if we already have the key locally. If we do then
  30  *      we retrieve it and merge the two keys. We then store the resulting key
  31  *      (or just the original we received if we don't already have it). We then
  32  *      send out the appropriate updates to our keyserver peers.
  33  */
  34 int add_key(struct openpgp_publickey *key) {
  35         return 0;
  36 }
  37
  38 /**
  39  *      parse_keys - Process a stream of packets for public keys + sigs.
  40  *      @packets: The packet list to parse.
  41  *      @keys: The returned list of public keys.
  42  *
  43  *      This function takes an list of OpenPGP packets and attempts to parse it
  44  *      into a list of public keys with signatures and subkeys.
  45  *
  46  *      Returns a count of how many keys we parsed.
  47  */
  48 int parse_keys(struct openpgp_packet_list *packets,
  49                 struct openpgp_publickey **keys)
  50 {
  51         struct openpgp_publickey *curkey = NULL;
  52         int count;
  53
  54         count = 0;
  55
  56         /*
  57          * If keys already has some keys in it then set curkey to the last one
  58          * so we add to the end of the list.
  59          */
  60         for (curkey = *keys; curkey != NULL && curkey->next != NULL;
  61                         curkey = curkey->next) ;
  62
  63         while (packets != NULL) {
  64                 switch (packets->packet->tag) {
  65                 case 2:
  66                         /*
  67                          * It's a signature packet. Add it to either the public
  68                          * key (it should be a revocation), to the current UID
  69                          * or the current subkey.
  70                          */
  71                         assert(curkey != NULL);
  72                         if (curkey->subkeys != NULL) {
  73                                 ADD_PACKET_TO_LIST_END(curkey->last_subkey,
  74                                         sig,
  75                                         packet_dup(packets->packet));
  76                         } else if (curkey->uids != NULL) {
  77                                 ADD_PACKET_TO_LIST_END(curkey->last_uid,
  78                                         sig,
  79                                         packet_dup(packets->packet));
  80                         } else {
  81                                 ADD_PACKET_TO_LIST_END(curkey,
  82                                         revocation,
  83                                         packet_dup(packets->packet));
  84                         }
  85                         break;
  86                 case 6:
  87                         /*
  88                          * It's a public key packet, so start a new key in our
  89                          * list.
  90                          */
  91                         if (curkey != NULL) {
  92                                 curkey->next = malloc(sizeof (*curkey));
  93                                 curkey = curkey->next;
  94                         } else {
  95                                 *keys = curkey =
  96                                         malloc(sizeof (*curkey));
  97                         }
  98                         memset(curkey, 0, sizeof(*curkey));
  99                         curkey->publickey = packet_dup(packets->packet);
 100                         count++;
 101                         break;
 102                 case 13:
 103                 case 17:
 104                         /*
 105                          * It's a UID packet (or a photo id, which is similar).
 106                          */
 107                         assert(curkey != NULL);
 108                         assert(curkey->subkeys == NULL);
 109                         ADD_PACKET_TO_LIST_END(curkey,
 110                                 uid,
 111                                 packet_dup(packets->packet));
 112                         break;
 113                 case 14:
 114                         /*
 115                          * It's a subkey packet.
 116                          */
 117                         assert(curkey != NULL);
 118                         ADD_PACKET_TO_LIST_END(curkey,
 119                                 subkey,
 120                                 packet_dup(packets->packet));
 121                         break;
 122                 case 12:
 123                 case 61:
 124                         /*
 125                          * One of:
 126                          *
 127                          * Trust packet. Ignore.
 128                          * Comment packet. Ignore.
 129                          */
 130                         break;
 131                 default:
 132                         logthing(LOGTHING_ERROR,
 133                                         "Unsupported packet type: %d",
 134                                         packets->packet->tag);
 135                 }
 136                 packets = packets->next;
 137         }
 138
 139         return count;
 140 }
 141
 142 /**
 143  *      debug_packet - Print debug info about a packet
 144  *      @packet: The packet to display.
 145  *
 146  *      This function takes an OpenPGP packet and displays some information
 147  *      about it to stdout. Useful for debugging purposes or curiousity about
 148  *      an OpenPGP packet stream.
 149  */
 150 int debug_packet(struct openpgp_packet *packet)
 151 {
 152         printf("\tNew format: %d, Tag: %d, Length: %d\n",
 153                         packet->newformat,
 154                         packet->tag,
 155                         packet->length);
 156
 157         return 0;
 158 }
 159
 160 /**
 161  *      read_openpgp_stream - Reads a stream of OpenPGP packets.
 162  *      @getchar_func: The function to get the next character from the stream.
 163  *      @ctx: A pointer to the context structure for getchar_func.
 164  *      @packets: The outputted list of packets.
 165  *
 166  *      This function uses getchar_func to read characters from an OpenPGP
 167  *      packet stream and reads the packets into a linked list of packets
 168  *      ready for parsing as a public key or whatever.
 169  */
 170 int read_openpgp_stream(int (*getchar_func)(void *ctx, size_t count,
 171                                 unsigned char *c),
 172                                 void *ctx,
 173                                 struct openpgp_packet_list **packets)
 174 {
 175         unsigned char                    curchar = 0;
 176         unsigned long                    count = 0;
 177         struct openpgp_packet_list      *curpacket = NULL;
 178         int                              rc = 0;
 179         bool                             inpacket = false;
 180
 181         assert(packets != NULL);
 182         curpacket = *packets;
 183         if (curpacket != NULL) {
 184                 while (curpacket->next != NULL) {
 185                         curpacket = curpacket->next;
 186                 }
 187         }
 188
 189         while (!rc && !getchar_func(ctx, 1, &curchar)) {
 190                 if (!inpacket && (curchar & 0x80)) {
 191                         /*
 192                          * New packet. Record the fact we're in a packet and
 193                          * allocate memory for it.
 194                          */
 195                         inpacket = true;
 196                         count = 0;
 197                         if (curpacket != NULL) {
 198                                 curpacket->next = malloc(sizeof (*curpacket));
 199                                 curpacket = curpacket->next;
 200                         } else {
 201                                 *packets = curpacket =
 202                                         malloc(sizeof (*curpacket));
 203                         }
 204                         memset(curpacket, 0, sizeof(*curpacket));
 205                         curpacket->packet =
 206                                 malloc(sizeof (*curpacket->packet));
 207                         memset(curpacket->packet, 0,
 208                                         sizeof(*curpacket->packet));
 209
 210                         curpacket->packet->newformat = (curchar & 0x40);
 211
 212                         /*
 213                          * TODO: Better error checking on getchar_func.
 214                          */
 215                         if (curpacket->packet->newformat) {
 216                                 curpacket->packet->tag = (curchar & 0x3F);
 217                                 rc = getchar_func(ctx, 1, &curchar);
 218                                 curpacket->packet->length = curchar;
 219                                 if (curpacket->packet->length > 191 &&
 220                                         curpacket->packet->length < 224) {
 221                                         rc = getchar_func(ctx, 1, &curchar);
 222                                         curpacket->packet->length -= 192;
 223                                         curpacket->packet->length <<= 8;
 224                                         curpacket->packet->length += curchar;
 225                                         curpacket->packet->length += 192;
 226                                 } else if (curpacket->packet->length > 223 &&
 227                                         curpacket->packet->length < 255) {
 228                                         logthing(LOGTHING_NOTICE,
 229                                                 "Partial length;"
 230                                                 " not supported.\n");
 231                                 } else if (curpacket->packet->length == 255) {
 232                                         /*
 233                                          * 5 byte length; ie 255 followed by 3
 234                                          * bytes of MSB length.
 235                                          */
 236                                         rc = getchar_func(ctx, 1, &curchar);
 237                                         curpacket->packet->length = curchar;
 238                                         curpacket->packet->length <<= 8;
 239                                         rc = getchar_func(ctx, 1, &curchar);
 240                                         curpacket->packet->length = curchar;
 241                                         curpacket->packet->length <<= 8;
 242                                         rc = getchar_func(ctx, 1, &curchar);
 243                                         curpacket->packet->length = curchar;
 244                                         curpacket->packet->length <<= 8;
 245                                         rc = getchar_func(ctx, 1, &curchar);
 246                                         curpacket->packet->length = curchar;
 247                                 }
 248                         } else {
 249                                 curpacket->packet->tag = (curchar & 0x3C) >> 2;
 250                                 switch (curchar & 3) {
 251                                 case 0:
 252                                         rc = getchar_func(ctx, 1, &curchar);
 253                                         curpacket->packet->length = curchar;
 254                                         break;
 255                                 case 1:
 256                                         rc = getchar_func(ctx, 1, &curchar);
 257                                         curpacket->packet->length = curchar;
 258                                         curpacket->packet->length <<= 8;
 259                                         rc = getchar_func(ctx, 1, &curchar);
 260                                         curpacket->packet->length += curchar;
 261                                         break;
 262                                 case 2:
 263                                         rc = getchar_func(ctx, 1, &curchar);
 264                                         curpacket->packet->length =
 265                                                 (curchar << 24);
 266                                         rc = getchar_func(ctx, 1, &curchar);
 267                                         curpacket->packet->length +=
 268                                                 (curchar << 16);
 269                                         rc = getchar_func(ctx, 1, &curchar);
 270                                         curpacket->packet->length +=
 271                                                 (curchar << 8);
 272                                         rc = getchar_func(ctx, 1, &curchar);
 273                                         curpacket->packet->length += curchar;
 274                                         break;
 275                                 case 3:
 276                                         logthing(LOGTHING_ERROR,
 277                                                 "Unsupported length type 3.");
 278                                         curpacket->packet->length = 0;
 279                                         curpacket->packet->data = NULL;
 280                                         rc = -1;
 281                                         break;
 282                                 }
 283                         }
 284
 285                         if (rc == 0) {
 286                                 curpacket->packet->data =
 287                                         malloc(curpacket->packet->length *
 288                                         sizeof(unsigned char));
 289                                 if (curpacket->packet->data == NULL) {
 290                                         logthing(LOGTHING_ERROR,
 291                                                 "Can't allocate memory for "
 292                                                 "packet!");
 293                                         rc = -1;
 294                                 } else {
 295                                         rc = getchar_func(ctx,
 296                                                 curpacket->packet->length,
 297                                                 curpacket->packet->data);
 298                                 }
 299                         }
 300                         inpacket = false;
 301                 } else {
 302                         logthing(LOGTHING_ERROR, "Unexpected character: 0x%X",
 303                                 curchar);
 304                 }
 305         }
 306
 307         return (rc);
 308 }
 309
 310 /**
 311  *      write_openpgp_stream - Reads a stream of OpenPGP packets.
 312  *      @putchar_func: The function to put the next character to the stream.
 313  *      @ctx: A pointer to the context structure for putchar_func.
 314  *      @packets: The list of packets.
 315  *
 316  *      This function uses putchar_func to write characters to an OpenPGP
 317  *      packet stream from a linked list of packets.
 318  */
 319 int write_openpgp_stream(int (*putchar_func)(void *ctx, size_t count,
 320                                                 unsigned char *c),
 321                                 void *ctx,
 322                                 struct openpgp_packet_list *packets)
 323 {
 324         unsigned char   curchar = 0;
 325
 326         while (packets != NULL) {
 327                 curchar = 0x80;
 328                 if (packets->packet->newformat) {
 329                         curchar |= 0x40;
 330                         curchar |= packets->packet->tag;
 331                         putchar_func(ctx, 1, &curchar);
 332
 333                         if (packets->packet->length < 192) {
 334                                 curchar = packets->packet->length;
 335                                 putchar_func(ctx, 1, &curchar);
 336                         } else if (packets->packet->length > 191 &&
 337                                 packets->packet->length < 8383) {
 338                                 curchar = (((packets->packet->length - 192) &
 339                                          0xFF00) >> 8) + 192;
 340                                 putchar_func(ctx, 1, &curchar);
 341
 342                                 curchar = (packets->packet->length - 192) &
 343                                          0xFF;
 344                                 putchar_func(ctx, 1, &curchar);
 345                         } else {
 346                                 logthing(LOGTHING_ERROR,
 347                                         "Unsupported new format length.");
 348                         }
 349                 } else {
 350                         curchar |= (packets->packet->tag << 2);
 351                         if (packets->packet->length < 256) {
 352                                 putchar_func(ctx, 1, &curchar);
 353                                 curchar = packets->packet->length;
 354                                 putchar_func(ctx, 1, &curchar);
 355                         } else if (packets->packet->length < 0x10000) {
 356                                 curchar |= 1;
 357                                 putchar_func(ctx, 1, &curchar);
 358                                 curchar = packets->packet->length >> 8;
 359                                 putchar_func(ctx, 1, &curchar);
 360                                 curchar = packets->packet->length & 0xFF;
 361                                 putchar_func(ctx, 1, &curchar);
 362                         } else {
 363                                 curchar |= 2;
 364                                 putchar_func(ctx, 1, &curchar);
 365                                 curchar = packets->packet->length >> 24;
 366                                 putchar_func(ctx, 1, &curchar);
 367                                 curchar = (packets->packet->length >> 16) & 0xFF;
 368                                 putchar_func(ctx, 1, &curchar);
 369                                 curchar = (packets->packet->length >> 8) & 0xFF;
 370                                 putchar_func(ctx, 1, &curchar);
 371                                 curchar = packets->packet->length & 0xFF;
 372                                 putchar_func(ctx, 1, &curchar);
 373                         }
 374                 }
 375
 376                 putchar_func(ctx, packets->packet->length,
 377                                 packets->packet->data);
 378                 packets = packets->next;
 379         }
 380         return 0;
 381 }
 382
 383 /**
 384  *      flatten_publickey - Convert a publickey to an OpenPGP packet list.
 385  *      @key: The public key.
 386  *      @packets: The outputted packet list.
 387  *
 388  *      This function converts public key structure to a linked list of OpenPGP
 389  *      packets ready for outputing or storage.
 390  */
 391 int flatten_publickey(struct openpgp_publickey *key,
 392                         struct openpgp_packet_list **packets,
 393                         struct openpgp_packet_list **list_end)
 394 {
 395         struct openpgp_signedpacket_list        *tmpsignedlist = NULL;
 396         struct openpgp_packet_list              *tmplist = NULL;
 397
 398         while (key != NULL) {
 399                 /*
 400                  * First write the public key packet out.
 401                  */
 402                 ADD_PACKET_TO_LIST((*list_end), packet_dup(key->publickey));
 403                 if (*packets == NULL) {
 404                         *packets = *list_end;
 405                 }
 406
 407                 /*
 408                  * Now do any revocation signatures on the main key.
 409                  */
 410                 for (tmplist = key->revocations; tmplist != NULL;
 411                                 tmplist = tmplist->next) {
 412                         ADD_PACKET_TO_LIST((*list_end),
 413                                         packet_dup(tmplist->packet));
 414                 }
 415
 416                 /*
 417                  * Output any UIDs along with their signatures.
 418                  */
 419                 for (tmpsignedlist = key->uids; tmpsignedlist != NULL;
 420                                 tmpsignedlist = tmpsignedlist->next) {
 421
 422                         ADD_PACKET_TO_LIST((*list_end),
 423                                 packet_dup(tmpsignedlist->packet));
 424                         for (tmplist = tmpsignedlist->sigs; tmplist != NULL;
 425                                         tmplist = tmplist->next) {
 426                                 ADD_PACKET_TO_LIST((*list_end),
 427                                         packet_dup(tmplist->packet));
 428                         }
 429                 }
 430
 431                 /*
 432                  * Output any subkeys along with their signatures.
 433                  */
 434                 for (tmpsignedlist = key->subkeys; tmpsignedlist != NULL;
 435                                 tmpsignedlist = tmpsignedlist->next) {
 436
 437                         ADD_PACKET_TO_LIST((*list_end),
 438                                 packet_dup(tmpsignedlist->packet));
 439                         for (tmplist = tmpsignedlist->sigs; tmplist != NULL;
 440                                         tmplist = tmplist->next) {
 441                                 ADD_PACKET_TO_LIST((*list_end),
 442                                         packet_dup(tmplist->packet));
 443                         }
 444                 }
 445                 key = key->next;
 446         }
 447         return 0;
 448 }