lib/opencdk/kbnode.c

   1 /* kbnode.c -  keyblock node utility functions
   2  * Copyright (C) 1998-2012 Free Software Foundation, Inc.
   3  *
   4  * Author: Timo Schulz
   5  *
   6  * This file is part of OpenCDK.
   7  *
   8  * The OpenCDK library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 3 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include "opencdk.h"
  31 #include "main.h"
  32 #include "packet.h"
  33
  34
  35 /**
  36  * cdk_kbnode_new:
  37  * @pkt: the packet to add
  38  *
  39  * Allocates a new key node and adds a packet.
  40  **/
  41 cdk_kbnode_t
  42 cdk_kbnode_new (cdk_packet_t pkt)
  43 {
  44   cdk_kbnode_t n;
  45
  46   n = cdk_calloc (1, sizeof *n);
  47   if (!n)
  48     return NULL;
  49   n->pkt = pkt;
  50   return n;
  51 }
  52
  53
  54 void
  55 _cdk_kbnode_clone (cdk_kbnode_t node)
  56 {
  57   /* Mark the node as clone which means that the packet
  58      will not be freed, just the node itself. */
  59   if (node)
  60     node->is_cloned = 1;
  61 }
  62
  63
  64 /**
  65  * cdk_kbnode_release:
  66  * @n: the key node
  67  *
  68  * Releases the memory of the node.
  69  **/
  70 void
  71 cdk_kbnode_release (cdk_kbnode_t node)
  72 {
  73   cdk_kbnode_t n2;
  74
  75   while (node)
  76     {
  77       n2 = node->next;
  78       if (!node->is_cloned)
  79         cdk_pkt_release (node->pkt);
  80       cdk_free (node);
  81       node = n2;
  82     }
  83 }
  84
  85
  86 /**
  87  * cdk_kbnode_delete:
  88  * @node: the key node
  89  *
  90  * Marks the given node as deleted.
  91  **/
  92 void
  93 cdk_kbnode_delete (cdk_kbnode_t node)
  94 {
  95   if (node)
  96     node->is_deleted = 1;
  97 }
  98
  99
 100 /* Append NODE to ROOT.  ROOT must exist! */
 101 void
 102 _cdk_kbnode_add (cdk_kbnode_t root, cdk_kbnode_t node)
 103 {
 104   cdk_kbnode_t n1;
 105
 106   for (n1 = root; n1->next; n1 = n1->next)
 107     ;
 108   n1->next = node;
 109 }
 110
 111
 112 /**
 113  * cdk_kbnode_insert:
 114  * @root: the root key node
 115  * @node: the node to add
 116  * @pkttype: packet type
 117  *
 118  * Inserts @node into the list after @root but before a packet which is not of
 119  * type @pkttype (only if @pkttype != 0).
 120  **/
 121 void
 122 cdk_kbnode_insert (cdk_kbnode_t root, cdk_kbnode_t node,
 123                    cdk_packet_type_t pkttype)
 124 {
 125   if (!pkttype)
 126     {
 127       node->next = root->next;
 128       root->next = node;
 129     }
 130   else
 131     {
 132       cdk_kbnode_t n1;
 133
 134       for (n1 = root; n1->next; n1 = n1->next)
 135         if (pkttype != n1->next->pkt->pkttype)
 136           {
 137             node->next = n1->next;
 138             n1->next = node;
 139             return;
 140           }
 141       /* No such packet, append */
 142       node->next = NULL;
 143       n1->next = node;
 144     }
 145 }
 146
 147
 148 /**
 149  * cdk_kbnode_find_prev:
 150  * @root: the root key node
 151  * @node: the key node
 152  * @pkttype: packet type
 153  *
 154  * Finds the previous node (if @pkttype = 0) or the previous node
 155  * with pkttype @pkttype in the list starting with @root of @node.
 156  **/
 157 cdk_kbnode_t
 158 cdk_kbnode_find_prev (cdk_kbnode_t root, cdk_kbnode_t node,
 159                       cdk_packet_type_t pkttype)
 160 {
 161   cdk_kbnode_t n1;
 162
 163   for (n1 = NULL; root && root != node; root = root->next)
 164     {
 165       if (!pkttype || root->pkt->pkttype == pkttype)
 166         n1 = root;
 167     }
 168   return n1;
 169 }
 170
 171
 172 /**
 173  * cdk_kbnode_find_next:
 174  * @node: the key node
 175  * @pkttype: packet type
 176  *
 177  * Ditto, but find the next packet.  The behaviour is trivial if
 178  * @pkttype is 0 but if it is specified, the next node with a packet
 179  * of this type is returned.  The function has some knowledge about
 180  * the valid ordering of packets: e.g. if the next signature packet
 181  * is requested, the function will not return one if it encounters
 182  * a user-id.
 183  **/
 184 cdk_kbnode_t
 185 cdk_kbnode_find_next (cdk_kbnode_t node, cdk_packet_type_t pkttype)
 186 {
 187   for (node = node->next; node; node = node->next)
 188     {
 189       if (!pkttype)
 190         return node;
 191       else if (pkttype == CDK_PKT_USER_ID &&
 192                (node->pkt->pkttype == CDK_PKT_PUBLIC_KEY ||
 193                 node->pkt->pkttype == CDK_PKT_SECRET_KEY))
 194         return NULL;
 195       else if (pkttype == CDK_PKT_SIGNATURE &&
 196                (node->pkt->pkttype == CDK_PKT_USER_ID ||
 197                 node->pkt->pkttype == CDK_PKT_PUBLIC_KEY ||
 198                 node->pkt->pkttype == CDK_PKT_SECRET_KEY))
 199         return NULL;
 200       else if (node->pkt->pkttype == pkttype)
 201         return node;
 202     }
 203   return NULL;
 204 }
 205
 206
 207 /**
 208  * cdk_kbnode_find:
 209  * @node: the key node
 210  * @pkttype: packet type
 211  *
 212  * Tries to find the next node with the packettype @pkttype.
 213  **/
 214 cdk_kbnode_t
 215 cdk_kbnode_find (cdk_kbnode_t node, cdk_packet_type_t pkttype)
 216 {
 217   for (; node; node = node->next)
 218     {
 219       if (node->pkt->pkttype == pkttype)
 220         return node;
 221     }
 222   return NULL;
 223 }
 224
 225
 226 /**
 227  * cdk_kbnode_find_packet:
 228  * @node: the key node
 229  * @pkttype: packet type
 230  *
 231  * Same as cdk_kbnode_find but it returns the packet instead of the node.
 232  **/
 233 cdk_packet_t
 234 cdk_kbnode_find_packet (cdk_kbnode_t node, cdk_packet_type_t pkttype)
 235 {
 236   cdk_kbnode_t res;
 237
 238   res = cdk_kbnode_find (node, pkttype);
 239   return res ? res->pkt : NULL;
 240 }
 241
 242
 243 /**
 244  * cdk_kbnode_walk:
 245  *
 246  * Walks through a list of kbnodes. This function returns
 247  * the next kbnode for each call; before using the function the first
 248  * time, the caller must set CONTEXT to NULL (This has simply the effect
 249  * to start with ROOT).
 250  */
 251 cdk_kbnode_t
 252 cdk_kbnode_walk (cdk_kbnode_t root, cdk_kbnode_t * ctx, int all)
 253 {
 254   cdk_kbnode_t n;
 255
 256   do
 257     {
 258       if (!*ctx)
 259         {
 260           *ctx = root;
 261           n = root;
 262         }
 263       else
 264         {
 265           n = (*ctx)->next;
 266           *ctx = n;
 267         }
 268     }
 269   while (!all && n && n->is_deleted);
 270   return n;
 271 }
 272
 273
 274 /**
 275  * cdk_kbnode_commit:
 276  * @root: the nodes
 277  *
 278  * Commits changes made to the kblist at ROOT. Note that ROOT my change,
 279  * and it is therefore passed by reference.
 280  * The function has the effect of removing all nodes marked as deleted.
 281  *
 282  * Returns: true if any node has been changed
 283  */
 284 int
 285 cdk_kbnode_commit (cdk_kbnode_t * root)
 286 {
 287   cdk_kbnode_t n, nl;
 288   int changed = 0;
 289
 290   for (n = *root, nl = NULL; n; n = nl->next)
 291     {
 292       if (n->is_deleted)
 293         {
 294           if (n == *root)
 295             *root = nl = n->next;
 296           else
 297             nl->next = n->next;
 298           if (!n->is_cloned)
 299             cdk_pkt_release (n->pkt);
 300           cdk_free (n);
 301           changed = 1;
 302         }
 303       else
 304         nl = n;
 305     }
 306   return changed;
 307 }
 308
 309
 310 /**
 311  * cdk_kbnode_remove:
 312  * @root: the root node
 313  * @node: the node to delete
 314  *
 315  * Removes a node from the root node.
 316  */
 317 void
 318 cdk_kbnode_remove (cdk_kbnode_t * root, cdk_kbnode_t node)
 319 {
 320   cdk_kbnode_t n, nl;
 321
 322   for (n = *root, nl = NULL; n; n = nl->next)
 323     {
 324       if (n == node)
 325         {
 326           if (n == *root)
 327             *root = nl = n->next;
 328           else
 329             nl->next = n->next;
 330           if (!n->is_cloned)
 331             cdk_pkt_release (n->pkt);
 332           cdk_free (n);
 333         }
 334       else
 335         nl = n;
 336     }
 337 }
 338
 339
 340
 341 /**
 342  * cdk_cdknode_move:
 343  * @root: root node
 344  * @node: the node to move
 345  * @where: destination place where to move the node.
 346  *
 347  * Moves NODE behind right after WHERE or to the beginning if WHERE is NULL.
 348  */
 349 void
 350 cdk_kbnode_move (cdk_kbnode_t * root, cdk_kbnode_t node, cdk_kbnode_t where)
 351 {
 352   cdk_kbnode_t tmp, prev;
 353
 354   if (!root || !*root || !node)
 355     return;
 356   for (prev = *root; prev && prev->next != node; prev = prev->next)
 357     ;
 358   if (!prev)
 359     return;                     /* Node is not in the list */
 360
 361   if (!where)
 362     {                           /* Move node before root */
 363       if (node == *root)
 364         return;
 365       prev->next = node->next;
 366       node->next = *root;
 367       *root = node;
 368       return;
 369     }
 370   if (node == where)            /* Move it after where. */
 371     return;
 372   tmp = node->next;
 373   node->next = where->next;
 374   where->next = node;
 375   prev->next = tmp;
 376 }
 377
 378
 379 /**
 380  * cdk_kbnode_get_packet:
 381  * @node: the key node
 382  *
 383  * Get packet in node.
 384  *
 385  * Returns: the packet which is stored inside the node in @node.
 386  **/
 387 cdk_packet_t
 388 cdk_kbnode_get_packet (cdk_kbnode_t node)
 389 {
 390   if (node)
 391     return node->pkt;
 392   return NULL;
 393 }
 394
 395
 396 /**
 397  * cdk_kbnode_read_from_mem:
 398  * @ret_node: the new key node
 399  * @armor: whether base64 or not
 400  * @buf: the buffer which stores the key sequence
 401  * @buflen: the length of the buffer
 402  *
 403  * Tries to read a key node from the memory buffer @buf.
 404  **/
 405 cdk_error_t
 406 cdk_kbnode_read_from_mem (cdk_kbnode_t * ret_node,
 407                           int armor,
 408                           const byte * buf, size_t buflen)
 409 {
 410   cdk_stream_t inp;
 411   cdk_error_t rc;
 412
 413   if (!ret_node || !buf)
 414     return CDK_Inv_Value;
 415
 416   *ret_node = NULL;
 417   if (!buflen)
 418     return gnutls_assert_val(CDK_Too_Short);
 419
 420   rc = cdk_stream_tmp_from_mem (buf, buflen, &inp);
 421   if (rc)
 422     return gnutls_assert_val(rc);
 423
 424   if (armor)
 425     cdk_stream_set_armor_flag (inp, 0);
 426
 427   rc = cdk_keydb_get_keyblock (inp, ret_node);
 428   if (rc)
 429     gnutls_assert ();
 430   cdk_stream_close (inp);
 431   return rc;
 432 }
 433
 434
 435 /**
 436  * cdk_kbnode_write_to_mem_alloc:
 437  * @node: the key node
 438  * @r_buf: buffer to hold the raw data
 439  * @r_buflen: buffer length of the allocated raw data.
 440  *
 441  * The function acts similar to cdk_kbnode_write_to_mem but
 442  * it allocates the buffer to avoid the lengthy second run.
 443  */
 444 cdk_error_t
 445 cdk_kbnode_write_to_mem_alloc (cdk_kbnode_t node,
 446                                byte ** r_buf, size_t * r_buflen)
 447 {
 448   cdk_kbnode_t n;
 449   cdk_stream_t s;
 450   cdk_error_t rc;
 451   size_t len;
 452
 453   if (!node || !r_buf || !r_buflen)
 454     {
 455       gnutls_assert ();
 456       return CDK_Inv_Value;
 457     }
 458
 459   *r_buf = NULL;
 460   *r_buflen = 0;
 461
 462   rc = cdk_stream_tmp_new (&s);
 463   if (rc)
 464     {
 465       gnutls_assert ();
 466       return rc;
 467     }
 468
 469   for (n = node; n; n = n->next)
 470     {
 471       /* Skip all packets which cannot occur in a key composition. */
 472       if (n->pkt->pkttype != CDK_PKT_PUBLIC_KEY &&
 473           n->pkt->pkttype != CDK_PKT_PUBLIC_SUBKEY &&
 474           n->pkt->pkttype != CDK_PKT_SECRET_KEY &&
 475           n->pkt->pkttype != CDK_PKT_SECRET_SUBKEY &&
 476           n->pkt->pkttype != CDK_PKT_SIGNATURE &&
 477           n->pkt->pkttype != CDK_PKT_USER_ID &&
 478           n->pkt->pkttype != CDK_PKT_ATTRIBUTE)
 479         continue;
 480       rc = cdk_pkt_write (s, n->pkt);
 481       if (rc)
 482         {
 483           cdk_stream_close (s);
 484           gnutls_assert ();
 485           return rc;
 486         }
 487     }
 488
 489   cdk_stream_seek (s, 0);
 490   len = cdk_stream_get_length (s);
 491   *r_buf = cdk_calloc (1, len);
 492   *r_buflen = cdk_stream_read (s, *r_buf, len);
 493   cdk_stream_close (s);
 494   return 0;
 495 }
 496
 497
 498 /**
 499  * cdk_kbnode_write_to_mem:
 500  * @node: the key node
 501  * @buf: the buffer to store the node data
 502  * @r_nbytes: the new length of the buffer.
 503  *
 504  * Tries to write the contents of the key node to the buffer @buf and
 505  * return the length of it in @r_nbytes. If buf is (0), only the
 506  * length of the node is calculated and returned in @r_nbytes.
 507  * Whenever it is possible, the cdk_kbnode_write_to_mem_alloc should be used.
 508  **/
 509 cdk_error_t
 510 cdk_kbnode_write_to_mem (cdk_kbnode_t node, byte * buf, size_t * r_nbytes)
 511 {
 512   cdk_kbnode_t n;
 513   cdk_stream_t s;
 514   cdk_error_t rc;
 515   size_t len;
 516
 517   if (!node || !r_nbytes)
 518     {
 519       gnutls_assert ();
 520       return CDK_Inv_Value;
 521     }
 522
 523   rc = cdk_stream_tmp_new (&s);
 524   if (rc)
 525     {
 526       gnutls_assert ();
 527       return rc;
 528     }
 529
 530   for (n = node; n; n = n->next)
 531     {
 532       /* Skip all packets which cannot occur in a key composition. */
 533       if (n->pkt->pkttype != CDK_PKT_PUBLIC_KEY &&
 534           n->pkt->pkttype != CDK_PKT_PUBLIC_SUBKEY &&
 535           n->pkt->pkttype != CDK_PKT_SECRET_KEY &&
 536           n->pkt->pkttype != CDK_PKT_SECRET_SUBKEY &&
 537           n->pkt->pkttype != CDK_PKT_SIGNATURE &&
 538           n->pkt->pkttype != CDK_PKT_USER_ID &&
 539           n->pkt->pkttype != CDK_PKT_ATTRIBUTE)
 540         continue;
 541       rc = cdk_pkt_write (s, n->pkt);
 542       if (rc)
 543         {
 544           cdk_stream_close (s);
 545           gnutls_assert ();
 546           return rc;
 547         }
 548     }
 549
 550   cdk_stream_seek (s, 0);
 551   len = cdk_stream_get_length (s);
 552   if (!buf)
 553     {
 554       *r_nbytes = len;          /* Only return the length of the buffer */
 555       cdk_stream_close (s);
 556       return 0;
 557     }
 558   if (*r_nbytes < len)
 559     {
 560       *r_nbytes = len;
 561       rc = CDK_Too_Short;
 562     }
 563   if (!rc)
 564     *r_nbytes = cdk_stream_read (s, buf, len);
 565   else
 566     gnutls_assert ();
 567   cdk_stream_close (s);
 568   return rc;
 569 }
 570
 571
 572 /**
 573  * cdk_kbnode_hash:
 574  * @node: the key node
 575  * @hashctx: uint8_t pointer to the hash context
 576  * @is_v4: OpenPGP signature (yes=1, no=0)
 577  * @pkttype: packet type to hash (if (0) use the packet type from the node)
 578  * @flags: flags which depend on the operation
 579  *
 580  * Hashes the key node contents. Two modes are supported. If the packet
 581  * type is used (!= 0) then the function searches the first node with
 582  * this type. Otherwise the node is seen as a single node and the type
 583  * is extracted from it.
 584  **/
 585 cdk_error_t
 586 cdk_kbnode_hash (cdk_kbnode_t node, digest_hd_st * md, int is_v4,
 587                  cdk_packet_type_t pkttype, int flags)
 588 {
 589   cdk_packet_t pkt;
 590
 591   if (!node || !md)
 592     {
 593       gnutls_assert ();
 594       return CDK_Inv_Value;
 595     }
 596   if (!pkttype)
 597     {
 598       pkt = cdk_kbnode_get_packet (node);
 599       pkttype = pkt->pkttype;
 600     }
 601   else
 602     {
 603       pkt = cdk_kbnode_find_packet (node, pkttype);
 604       if (!pkt)
 605         {
 606           gnutls_assert ();
 607           return CDK_Inv_Packet;
 608         }
 609     }
 610
 611   switch (pkttype)
 612     {
 613     case CDK_PKT_PUBLIC_KEY:
 614     case CDK_PKT_PUBLIC_SUBKEY:
 615       _cdk_hash_pubkey (pkt->pkt.public_key, md, flags & 1);
 616       break;
 617
 618     case CDK_PKT_USER_ID:
 619       _cdk_hash_userid (pkt->pkt.user_id, is_v4, md);
 620       break;
 621
 622     case CDK_PKT_SIGNATURE:
 623       _cdk_hash_sig_data (pkt->pkt.signature, md);
 624       break;
 625
 626     default:
 627       gnutls_assert ();
 628       return CDK_Inv_Mode;
 629     }
 630   return 0;
 631 }