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