lib/gnutls_str.c

   1 /*
   2  * Copyright (C) 2002, 2004, 2005, 2007, 2008, 2009, 2010 Free Software
   3  * Foundation, Inc.
   4  *
   5  * Author: Nikos Mavrogiannopoulos
   6  *
   7  * This file is part of GnuTLS.
   8  *
   9  * The GnuTLS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  22  * USA
  23  *
  24  */
  25
  26 #include <gnutls_int.h>
  27 #include <gnutls_errors.h>
  28 #include <gnutls_num.h>
  29 #include <gnutls_str.h>
  30 #include <stdarg.h>
  31
  32 /* These function are like strcat, strcpy. They only
  33  * do bound checking (they shouldn't cause buffer overruns),
  34  * and they always produce null terminated strings.
  35  *
  36  * They should be used only with null terminated strings.
  37  */
  38 void
  39 _gnutls_str_cat (char *dest, size_t dest_tot_size, const char *src)
  40 {
  41   size_t str_size = strlen (src);
  42   size_t dest_size = strlen (dest);
  43
  44   if (dest_tot_size - dest_size > str_size)
  45     {
  46       strcat (dest, src);
  47     }
  48   else
  49     {
  50       if (dest_tot_size - dest_size > 0)
  51         {
  52           strncat (dest, src, (dest_tot_size - dest_size) - 1);
  53           dest[dest_tot_size - 1] = 0;
  54         }
  55     }
  56 }
  57
  58 void
  59 _gnutls_str_cpy (char *dest, size_t dest_tot_size, const char *src)
  60 {
  61   size_t str_size = strlen (src);
  62
  63   if (dest_tot_size > str_size)
  64     {
  65       strcpy (dest, src);
  66     }
  67   else
  68     {
  69       if (dest_tot_size > 0)
  70         {
  71           strncpy (dest, src, (dest_tot_size) - 1);
  72           dest[dest_tot_size - 1] = 0;
  73         }
  74     }
  75 }
  76
  77 void
  78 _gnutls_mem_cpy (char *dest, size_t dest_tot_size, const char *src,
  79                  size_t src_size)
  80 {
  81
  82   if (dest_tot_size >= src_size)
  83     {
  84       memcpy (dest, src, src_size);
  85     }
  86   else
  87     {
  88       if (dest_tot_size > 0)
  89         {
  90           memcpy (dest, src, dest_tot_size);
  91         }
  92     }
  93 }
  94
  95 void
  96 _gnutls_buffer_init (gnutls_buffer_st * str)
  97 {
  98   str->data = str->allocd = NULL;
  99   str->max_length = 0;
 100   str->length = 0;
 101 }
 102
 103 void
 104 _gnutls_buffer_clear (gnutls_buffer_st * str)
 105 {
 106   if (str == NULL || str->allocd == NULL)
 107     return;
 108   gnutls_free (str->allocd);
 109
 110   str->data = str->allocd = NULL;
 111   str->max_length = 0;
 112   str->length = 0;
 113 }
 114
 115 #define MIN_CHUNK 1024
 116
 117 int
 118 _gnutls_buffer_append_data (gnutls_buffer_st * dest, const void *data,
 119                             size_t data_size)
 120 {
 121   size_t tot_len = data_size + dest->length;
 122
 123   if (dest->max_length >= tot_len)
 124     {
 125       size_t unused = MEMSUB (dest->data, dest->allocd);
 126
 127       if (dest->max_length - unused <= tot_len)
 128         {
 129           if (dest->length && dest->data)
 130             memmove (dest->allocd, dest->data, dest->length);
 131
 132           dest->data = dest->allocd;
 133         }
 134       memmove (&dest->data[dest->length], data, data_size);
 135       dest->length = tot_len;
 136
 137       return tot_len;
 138     }
 139   else
 140     {
 141       size_t unused = MEMSUB (dest->data, dest->allocd);
 142       size_t new_len =
 143         MAX (data_size, MIN_CHUNK) + MAX (dest->max_length, MIN_CHUNK);
 144
 145       dest->allocd = gnutls_realloc (dest->allocd, new_len);
 146       if (dest->allocd == NULL)
 147         {
 148           gnutls_assert ();
 149           return GNUTLS_E_MEMORY_ERROR;
 150         }
 151       dest->max_length = new_len;
 152       dest->data = dest->allocd + unused;
 153
 154       if (dest->length && dest->data)
 155         memmove (dest->allocd, dest->data, dest->length);
 156       dest->data = dest->allocd;
 157
 158       memcpy (&dest->data[dest->length], data, data_size);
 159       dest->length = tot_len;
 160
 161       return tot_len;
 162     }
 163 }
 164
 165 int
 166 _gnutls_buffer_resize (gnutls_buffer_st * dest, size_t new_size)
 167 {
 168   if (dest->max_length >= new_size)
 169     {
 170       size_t unused = MEMSUB (dest->data, dest->allocd);
 171       if (dest->max_length - unused <= new_size)
 172         {
 173           if (dest->length && dest->data)
 174             memmove (dest->allocd, dest->data, dest->length);
 175           dest->data = dest->allocd;
 176         }
 177
 178       return 0;
 179     }
 180   else
 181     {
 182       size_t unused = MEMSUB (dest->data, dest->allocd);
 183       size_t alloc_len =
 184         MAX (new_size, MIN_CHUNK) + MAX (dest->max_length, MIN_CHUNK);
 185
 186       dest->allocd = gnutls_realloc (dest->allocd, alloc_len);
 187       if (dest->allocd == NULL)
 188         {
 189           gnutls_assert ();
 190           return GNUTLS_E_MEMORY_ERROR;
 191         }
 192       dest->max_length = alloc_len;
 193       dest->data = dest->allocd + unused;
 194
 195       if (dest->length && dest->data)
 196         memmove (dest->allocd, dest->data, dest->length);
 197       dest->data = dest->allocd;
 198
 199       return 0;
 200     }
 201 }
 202
 203 int
 204 _gnutls_buffer_append_str (gnutls_buffer_st * dest, const char *src)
 205 {
 206   return _gnutls_buffer_append_data (dest, src, strlen (src));
 207 }
 208
 209 /* returns data from a string in a constant buffer.
 210  * The data will NOT be valid if buffer is released or
 211  * data are appended in the buffer.
 212  */
 213 void
 214 _gnutls_buffer_pop_datum (gnutls_buffer_st * str, gnutls_datum_t * data,
 215                           size_t req_size)
 216 {
 217
 218   if (str->length == 0)
 219     {
 220       data->data = NULL;
 221       data->size = 0;
 222       return;
 223     }
 224
 225   if (req_size > str->length)
 226     req_size = str->length;
 227
 228   data->data = str->data;
 229   data->size = req_size;
 230
 231   str->data += req_size;
 232   str->length -= req_size;
 233
 234   /* if string becomes empty start from begining */
 235   if (str->length == 0)
 236     {
 237       str->data = str->allocd;
 238     }
 239
 240   return;
 241 }
 242
 243 /* converts the buffer to a datum if possible. After this call the buffer
 244  * is at an usable state and might not be used or deinitialized */
 245 int
 246 _gnutls_buffer_to_datum (gnutls_buffer_st * str, gnutls_datum_t * data)
 247 {
 248
 249   if (str->length == 0)
 250     {
 251       data->data = NULL;
 252       data->size = 0;
 253       return 0;
 254     }
 255
 256   if (str->allocd != str->data)
 257     {
 258       data->data = gnutls_malloc (str->length);
 259       if (data->data == NULL)
 260         {
 261           gnutls_assert ();
 262           return GNUTLS_E_MEMORY_ERROR;
 263         }
 264       memcpy (data->data, str->data, str->length);
 265       data->size = str->length;
 266       _gnutls_buffer_clear (str);
 267     }
 268   else
 269     {
 270       data->data = str->data;
 271       data->size = str->length;
 272     }
 273
 274   return 0;
 275 }
 276
 277 /* returns data from a string in a constant buffer.
 278  */
 279 void
 280 _gnutls_buffer_pop_data (gnutls_buffer_st * str, void *data,
 281                          size_t * req_size)
 282 {
 283   gnutls_datum_t tdata;
 284
 285   _gnutls_buffer_pop_datum (str, &tdata, *req_size);
 286
 287   *req_size = tdata.size;
 288   memcpy (data, tdata.data, tdata.size);
 289
 290   return;
 291 }
 292
 293 int
 294 _gnutls_buffer_append_printf (gnutls_buffer_st * dest, const char *fmt, ...)
 295 {
 296   va_list args;
 297   int len;
 298   char *str;
 299
 300   va_start (args, fmt);
 301   len = vasprintf (&str, fmt, args);
 302   va_end (args);
 303
 304   if (len < 0 || !str)
 305     return -1;
 306
 307   len = _gnutls_buffer_append_str (dest, str);
 308
 309   free (str);
 310
 311   return len;
 312 }
 313
 314 static int
 315 _gnutls_buffer_insert_data (gnutls_buffer_st * dest, int pos, const void *str,
 316                             size_t str_size)
 317 {
 318   size_t orig_length = dest->length;
 319   int ret;
 320
 321   ret = _gnutls_buffer_resize (dest, dest->length + str_size);  /* resize to make space */
 322   if (ret < 0)
 323     return ret;
 324
 325   memmove (&dest->data[pos + str_size], &dest->data[pos], orig_length - pos);
 326
 327   memcpy (&dest->data[pos], str, str_size);
 328   dest->length += str_size;
 329
 330   return 0;
 331 }
 332
 333 static void
 334 _gnutls_buffer_delete_data (gnutls_buffer_st * dest, int pos, size_t str_size)
 335 {
 336   memmove (&dest->data[pos], &dest->data[pos + str_size],
 337            dest->length - pos - str_size);
 338
 339   dest->length -= str_size;
 340
 341   return;
 342 }
 343
 344
 345 int
 346 _gnutls_buffer_escape (gnutls_buffer_st * dest,
 347                        const char *const invalid_chars)
 348 {
 349   int rv = -1;
 350   char t[5];
 351   int pos = 0;
 352
 353   while (pos < dest->length)
 354     {
 355
 356       if (dest->data[pos] == '\\' || strchr (invalid_chars, dest->data[pos])
 357           || !isgraph (dest->data[pos]))
 358         {
 359
 360           snprintf (t, sizeof (t), "%%%.2X", (unsigned int) dest->data[pos]);
 361
 362           _gnutls_buffer_delete_data (dest, pos, 1);
 363
 364           if (_gnutls_buffer_insert_data (dest, pos, t, 3) < 0)
 365             {
 366               rv = -1;
 367               goto cleanup;
 368             }
 369
 370         }
 371       pos++;
 372     }
 373
 374   rv = 0;
 375
 376 cleanup:
 377
 378   return rv;
 379 }
 380
 381 int
 382 _gnutls_buffer_unescape (gnutls_buffer_st * dest)
 383 {
 384   int rv = -1;
 385   int pos = 0;
 386
 387   while (pos < dest->length)
 388     {
 389       if (dest->data[pos] == '%')
 390         {
 391           char b[3];
 392           unsigned int u;
 393           unsigned char x;
 394
 395           b[0] = dest->data[pos + 1];
 396           b[1] = dest->data[pos + 2];
 397           b[2] = 0;
 398
 399           sscanf (b, "%02x", &u);
 400
 401           x = u;
 402
 403           _gnutls_buffer_delete_data (dest, pos, 3);
 404           _gnutls_buffer_insert_data (dest, pos, &x, 1);
 405         }
 406       pos++;
 407     }
 408
 409   rv = 0;
 410
 411   return rv;
 412 }
 413
 414
 415 /* Converts the given string (old) to hex. A buffer must be provided
 416  * to hold the new hex string. The new string will be null terminated.
 417  * If the buffer does not have enough space to hold the string, a
 418  * truncated hex string is returned (always null terminated).
 419  */
 420 char *
 421 _gnutls_bin2hex (const void *_old, size_t oldlen,
 422                  char *buffer, size_t buffer_size, const char *separator)
 423 {
 424   unsigned int i, j;
 425   const opaque *old = _old;
 426   int step = 2;
 427   const char empty[] = "";
 428
 429   if (separator != NULL && separator[0] != 0)
 430     step = 3;
 431   else
 432     separator = empty;
 433
 434   if (buffer_size < 3)
 435     {
 436       gnutls_assert();
 437       return NULL;
 438     }
 439
 440   i = j = 0;
 441   sprintf (&buffer[j], "%.2x", old[i]);
 442   j += 2;
 443   i++;
 444
 445   for (; i < oldlen && j + step < buffer_size; j += step)
 446     {
 447       sprintf (&buffer[j], "%s%.2x", separator, old[i]);
 448       i++;
 449     }
 450   buffer[j] = '\0';
 451
 452   return buffer;
 453 }
 454
 455 /**
 456  * gnutls_hex2bin:
 457  * @hex_data: string with data in hex format
 458  * @hex_size: size of hex data
 459  * @bin_data: output array with binary data
 460  * @bin_size: when calling *@bin_size should hold size of @bin_data,
 461  *            on return will hold actual size of @bin_data.
 462  *
 463  * Convert a buffer with hex data to binary data.
 464  *
 465  * Returns: %GNUTLS_E_SUCCESS on success, otherwise an error.
 466  *
 467  * Since: 2.4.0
 468  **/
 469 int
 470 gnutls_hex2bin (const char *hex_data,
 471                 size_t hex_size, char *bin_data, size_t * bin_size)
 472 {
 473   return _gnutls_hex2bin (hex_data, (int) hex_size, bin_data, bin_size);
 474 }
 475
 476 int
 477 _gnutls_hex2bin (const opaque * hex_data, int hex_size, opaque * bin_data,
 478                  size_t * bin_size)
 479 {
 480   int i, j;
 481   opaque hex2_data[3];
 482   unsigned long val;
 483
 484   hex2_data[2] = 0;
 485
 486   for (i = j = 0; i < hex_size;)
 487     {
 488       if (!isxdigit (hex_data[i]))      /* skip non-hex such as the ':' in 00:FF */
 489         {
 490           i++;
 491           continue;
 492         }
 493
 494       if (j > *bin_size)
 495         {
 496           gnutls_assert ();
 497           return GNUTLS_E_SHORT_MEMORY_BUFFER;
 498         }
 499
 500       hex2_data[0] = hex_data[i];
 501       hex2_data[1] = hex_data[i + 1];
 502       i += 2;
 503
 504       val = strtoul ((char *) hex2_data, NULL, 16);
 505       if (val == ULONG_MAX)
 506         {
 507           gnutls_assert ();
 508           return GNUTLS_E_PARSING_ERROR;
 509         }
 510       bin_data[j] = val;
 511       j++;
 512     }
 513   *bin_size = j;
 514
 515   return 0;
 516 }
 517
 518
 519 /* compare hostname against certificate, taking account of wildcards
 520  * return 1 on success or 0 on error
 521  *
 522  * note: certnamesize is required as X509 certs can contain embedded NULs in
 523  * the strings such as CN or subjectAltName
 524  */
 525 int
 526 _gnutls_hostname_compare (const char *certname,
 527                           size_t certnamesize, const char *hostname)
 528 {
 529   /* find the first different character */
 530   for (; *certname && *hostname && toupper (*certname) == toupper (*hostname);
 531        certname++, hostname++, certnamesize--)
 532     ;
 533
 534   /* the strings are the same */
 535   if (certnamesize == 0 && *hostname == '\0')
 536     return 1;
 537
 538   if (*certname == '*')
 539     {
 540       /* a wildcard certificate */
 541
 542       certname++;
 543       certnamesize--;
 544
 545       while (1)
 546         {
 547           /* Use a recursive call to allow multiple wildcards */
 548           if (_gnutls_hostname_compare (certname, certnamesize, hostname))
 549             return 1;
 550
 551           /* wildcards are only allowed to match a single domain
 552              component or component fragment */
 553           if (*hostname == '\0' || *hostname == '.')
 554             break;
 555           hostname++;
 556         }
 557
 558       return 0;
 559     }
 560
 561   return 0;
 562 }
 563
 564 int
 565 _gnutls_buffer_append_prefix (gnutls_buffer_st * buf, size_t data_size)
 566 {
 567   opaque ss[4];
 568   _gnutls_write_uint32 (data_size, ss);
 569   return _gnutls_buffer_append_data (buf, ss, 4);
 570 }
 571
 572 /* Reads an uint32 number from the buffer. If check is non zero it will also check whether
 573  * the number read, is less than the data in the buffer
 574  */
 575 int
 576 _gnutls_buffer_pop_prefix (gnutls_buffer_st * buf, size_t * data_size,
 577                            int check)
 578 {
 579   size_t size;
 580
 581   if (buf->length < 4)
 582     {
 583       gnutls_assert ();
 584       return GNUTLS_E_PARSING_ERROR;
 585     }
 586
 587   size = _gnutls_read_uint32 (buf->data);
 588   if (check && size > buf->length - 4)
 589     {
 590       gnutls_assert ();
 591       return GNUTLS_E_PARSING_ERROR;
 592     }
 593
 594   buf->data += 4;
 595   buf->length -= 4;
 596
 597   *data_size = size;
 598
 599   return 0;
 600 }
 601
 602 int
 603 _gnutls_buffer_pop_datum_prefix (gnutls_buffer_st * buf,
 604                                  gnutls_datum_t * data)
 605 {
 606   size_t size;
 607   int ret;
 608
 609   ret = _gnutls_buffer_pop_prefix (buf, &size, 1);
 610   if (ret < 0)
 611     {
 612       gnutls_assert ();
 613       return ret;
 614     }
 615
 616   if (size > 0)
 617     {
 618       size_t osize = size;
 619       _gnutls_buffer_pop_datum (buf, data, size);
 620       if (osize != data->size)
 621         {
 622           gnutls_assert ();
 623           return GNUTLS_E_PARSING_ERROR;
 624         }
 625     }
 626   else
 627     {
 628       data->size = 0;
 629       data->data = NULL;
 630     }
 631
 632   return 0;
 633 }
 634
 635 int
 636 _gnutls_buffer_append_data_prefix (gnutls_buffer_st * buf, const void *data,
 637                                    size_t data_size)
 638 {
 639   _gnutls_buffer_append_prefix (buf, data_size);
 640   if (data_size > 0)
 641     return _gnutls_buffer_append_data (buf, data, data_size);
 642
 643   return 0;
 644 }
 645
 646 int
 647 _gnutls_buffer_pop_data_prefix (gnutls_buffer_st * buf, void *data,
 648                                 size_t * data_size)
 649 {
 650   size_t size;
 651   int ret;
 652
 653   ret = _gnutls_buffer_pop_prefix (buf, &size, 1);
 654   if (ret < 0)
 655     {
 656       gnutls_assert ();
 657       return ret;
 658     }
 659
 660   if (size > 0)
 661     _gnutls_buffer_pop_data (buf, data, data_size);
 662
 663   return 0;
 664 }