g13/g13tuple.c

   1 /* g13tuple.c - Tuple handling
   2  * Copyright (C) 2009 Free Software Foundation, Inc.
   3  * Copyright (C) 2009, 2015, 2016  Werner Koch
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <assert.h>
  27
  28 #include "g13.h"
  29 #include "g13tuple.h"
  30 #include "keyblob.h"  /* Required for dump_tupledesc.  */
  31
  32
  33 /* Definition of the tuple descriptor object.  */
  34 struct tupledesc_s
  35 {
  36   unsigned char *data; /* The tuple data.  */
  37   size_t datalen;      /* The length of the data.  */
  38   size_t pos;          /* The current position as used by next_tuple.  */
  39   int refcount;        /* Number of references hold. */
  40 };
  41
  42
  43
  44 /* Append the TAG and the VALUE to the MEMBUF.  There is no error
  45    checking here; this is instead done while getting the value back
  46    from the membuf. */
  47 void
  48 append_tuple (membuf_t *membuf, int tag, const void *value, size_t length)
  49 {
  50   unsigned char buf[2];
  51
  52   assert (tag >= 0 && tag <= 0xffff);
  53   assert (length <= 0xffff);
  54
  55   buf[0] = tag >> 8;
  56   buf[1] = tag;
  57   put_membuf (membuf, buf, 2);
  58   buf[0] = length >> 8;
  59   buf[1] = length;
  60   put_membuf (membuf, buf, 2);
  61   if (length)
  62     put_membuf (membuf, value, length);
  63 }
  64
  65
  66 /* Append the unsigned integer VALUE under TAG to MEMBUF.  We make
  67  * sure that the most significant bit is always cleared to explicitly
  68  * flag the value as unsigned.  */
  69 void
  70 append_tuple_uint (membuf_t *membuf, int tag, unsigned long long value)
  71 {
  72   unsigned char buf[16];
  73   unsigned char *p;
  74   unsigned int len;
  75
  76   p = buf + sizeof buf;
  77   len = 0;
  78   do
  79     {
  80       if (p == buf)
  81         BUG () ;
  82       *--p = (value & 0xff);
  83       value >>= 8;
  84       len++;
  85     }
  86   while (value);
  87
  88   /* Prepend a zero byte if the first byte has its MSB set.  */
  89   if ((*p & 0x80))
  90     {
  91       if (p == buf)
  92         BUG () ;
  93       *--p = 0;
  94       len++;
  95     }
  96
  97   append_tuple (membuf, tag, p, len);
  98 }
  99
 100
 101 /* Create a tuple object by moving the ownership of (DATA,DATALEN) to
 102  * a new object.  Returns 0 on success and stores the new object at
 103  * R_TUPLEHD.  The return object must be released using
 104  * destroy_tuples().  */
 105 gpg_error_t
 106 create_tupledesc (tupledesc_t *r_desc, void *data, size_t datalen)
 107 {
 108   if (datalen < 5 || memcmp (data, "\x00\x00\x00\x01\x01", 5))
 109     return gpg_error (GPG_ERR_NOT_SUPPORTED);
 110
 111   *r_desc = xtrymalloc (sizeof **r_desc);
 112   if (!*r_desc)
 113     return gpg_error_from_syserror ();
 114   (*r_desc)->data = data;
 115   (*r_desc)->datalen = datalen;
 116   (*r_desc)->pos = 0;
 117   (*r_desc)->refcount = 1;
 118   return 0;
 119 }
 120
 121 /* Unref a tuple descriptor and if the refcount is down to 0 release
 122    its allocated storage.  */
 123 void
 124 destroy_tupledesc (tupledesc_t tupledesc)
 125 {
 126   if (!tupledesc)
 127     return;
 128
 129   if (!--tupledesc->refcount)
 130     {
 131       xfree (tupledesc->data);
 132       xfree (tupledesc);
 133     }
 134 }
 135
 136
 137 tupledesc_t
 138 ref_tupledesc (tupledesc_t tupledesc)
 139 {
 140   if (tupledesc)
 141     tupledesc->refcount++;
 142   return tupledesc;
 143 }
 144
 145
 146 /* Return a pointer to the memory used to store the tuples.  This is
 147  * the data originally provided to create_tupledesc.  It is higly
 148  * recommended that the callers uses ref_tupledesc before calling this
 149  * function and unref_tupledesc when the return data will not anymore
 150  * be used.  */
 151 const void *
 152 get_tupledesc_data (tupledesc_t tupledesc, size_t *r_datalen)
 153 {
 154   *r_datalen = tupledesc->datalen;
 155   return tupledesc->data;
 156 }
 157
 158 /* Find the first tuple with tag TAG.  On success return a pointer to
 159    its value and store the length of the value at R_LENGTH.  If no
 160    tuple was found return NULL.  For use by next_tuple, the last
 161    position is stored in the descriptor.  */
 162 const void *
 163 find_tuple (tupledesc_t tupledesc, unsigned int tag, size_t *r_length)
 164 {
 165   const unsigned char *s;
 166   const unsigned char *s_end; /* Points right behind the data. */
 167   unsigned int t;
 168   size_t n;
 169
 170   s = tupledesc->data;
 171   if (!s)
 172     return NULL;
 173   s_end = s + tupledesc->datalen;
 174   while (s < s_end)
 175     {
 176       /* We use addresses for the overflow check to avoid undefined
 177          behaviour.  size_t should work with all flat memory models.  */
 178       if ((size_t)s+3 >= (size_t)s_end || (size_t)s + 3 < (size_t)s)
 179         break;
 180       t  = s[0] << 8;
 181       t |= s[1];
 182       n  = s[2] << 8;
 183       n |= s[3];
 184       s += 4;
 185       if ((size_t)s + n > (size_t)s_end || (size_t)s + n < (size_t)s)
 186         break;
 187       if (t == tag)
 188         {
 189           tupledesc->pos = (s + n) - tupledesc->data;
 190           *r_length = n;
 191           return s;
 192         }
 193       s += n;
 194     }
 195   return NULL;
 196 }
 197
 198
 199 /* Helper for find_tuple_uint and others.  */
 200 static gpg_error_t
 201 convert_uint (const unsigned char *s, size_t n, unsigned long long *r_value)
 202 {
 203   unsigned long long value = 0;
 204
 205   *r_value = 0;
 206
 207   if (!s)
 208     return gpg_error (GPG_ERR_NOT_FOUND);
 209   if (!n || (*s & 0x80)) /* No bytes or negative.  */
 210     return gpg_error (GPG_ERR_ERANGE);
 211   if (n && !*s) /* Skip a leading zero.  */
 212     {
 213       n--;
 214       s++;
 215     }
 216   if (n > sizeof value)
 217     return gpg_error (GPG_ERR_ERANGE);
 218   for (; n; n--, s++)
 219     {
 220       value <<= 8;
 221       value |= *s;
 222     }
 223   *r_value = value;
 224   return 0;
 225 }
 226
 227
 228 /* Similar to find-tuple but expects an unsigned int value and stores
 229  * that at R_VALUE.  If the tag was not found GPG_ERR_NOT_FOUND is
 230  * returned and 0 stored at R_VALUE.  If the value cannot be converted
 231  * to an unsigned integer GPG_ERR_ERANGE is returned.  */
 232 gpg_error_t
 233 find_tuple_uint (tupledesc_t tupledesc, unsigned int tag,
 234                  unsigned long long *r_value)
 235 {
 236   const unsigned char *s;
 237   size_t n;
 238
 239   s = find_tuple (tupledesc, tag, &n);
 240   return convert_uint (s, n, r_value);
 241 }
 242
 243
 244 const void *
 245 next_tuple (tupledesc_t tupledesc, unsigned int *r_tag, size_t *r_length)
 246 {
 247   const unsigned char *s;
 248   const unsigned char *s_end; /* Points right behind the data.  */
 249   unsigned int t;
 250   size_t n;
 251
 252   s = tupledesc->data;
 253   if (!s)
 254     return NULL;
 255   s_end = s + tupledesc->datalen;
 256   s += tupledesc->pos;
 257   if (s < s_end
 258       && !((size_t)s + 3 >= (size_t)s_end || (size_t)s + 3 < (size_t)s))
 259     {
 260       t  = s[0] << 8;
 261       t |= s[1];
 262       n  = s[2] << 8;
 263       n |= s[3];
 264       s += 4;
 265       if (!((size_t)s + n > (size_t)s_end || (size_t)s + n < (size_t)s))
 266         {
 267           tupledesc->pos = (s + n) - tupledesc->data;
 268           *r_tag = t;
 269           *r_length = n;
 270           return s;
 271         }
 272     }
 273
 274   return NULL;
 275 }
 276
 277
 278 /* Return true if BUF has only printable characters.  */
 279 static int
 280 all_printable (const void *buf, size_t buflen)
 281 {
 282   const unsigned char *s;
 283
 284   for (s=buf ; buflen; s++, buflen--)
 285     if (*s < 32 && *s > 126)
 286       return 0;
 287   return 1;
 288 }
 289
 290
 291 /* Print information about TUPLES to the log stream.  */
 292 void
 293 dump_tupledesc (tupledesc_t tuples)
 294 {
 295   size_t n;
 296   unsigned int tag;
 297   const void *value;
 298   unsigned long long uint;
 299
 300   log_info ("keyblob dump:\n");
 301   tag = KEYBLOB_TAG_BLOBVERSION;
 302   value = find_tuple (tuples, tag, &n);
 303   while (value)
 304     {
 305       log_info ("   tag: %-5u len: %-2u value: ", tag, (unsigned int)n);
 306       if (!n)
 307         log_printf ("[none]\n");
 308       else
 309         {
 310           switch (tag)
 311             {
 312             case KEYBLOB_TAG_ENCKEY:
 313             case KEYBLOB_TAG_MACKEY:
 314               log_printf ("[confidential]\n");
 315               break;
 316
 317             case KEYBLOB_TAG_ALGOSTR:
 318               if (n < 100 && all_printable (value, n))
 319                 log_printf ("%.*s\n", (int)n, (const char*)value);
 320               else
 321                 log_printhex ("", value, n);
 322               break;
 323
 324             case KEYBLOB_TAG_CONT_NSEC:
 325             case KEYBLOB_TAG_ENC_NSEC:
 326             case KEYBLOB_TAG_ENC_OFF:
 327               if (!convert_uint (value, n, &uint))
 328                 log_printf ("%llu\n", uint);
 329               else
 330                 log_printhex ("", value, n);
 331               break;
 332
 333             default:
 334               log_printhex ("", value, n);
 335               break;
 336             }
 337         }
 338       value = next_tuple (tuples, &tag, &n);
 339     }
 340 }