glib/ghmac.c

   1 /* ghmac.h - data hashing functions
   2  *
   3  * Copyright (C) 2011  Collabora Ltd.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: Stef Walter <stefw@collabora.co.uk>
  21  */
  22
  23 #include "config.h"
  24
  25 #include <string.h>
  26
  27 #include "ghmac.h"
  28
  29 #include "glib/galloca.h"
  30 #include "gatomic.h"
  31 #include "gslice.h"
  32 #include "gmem.h"
  33 #include "gstrfuncs.h"
  34 #include "gtestutils.h"
  35 #include "gtypes.h"
  36 #include "glibintl.h"
  37
  38
  39 /**
  40  * SECTION:hmac
  41  * @title: Secure HMAC Digests
  42  * @short_description: computes the HMAC for data
  43  *
  44  * HMACs should be used when producing a cookie or hash based on data
  45  * and a key. Simple mechanisms for using SHA1 and other algorithms to
  46  * digest a key and data together are vulnerable to various security
  47  * issues. <ulink url="http://en.wikipedia.org/wiki/HMAC">HMAC</ulink>
  48  * uses algorithms like SHA1 in a secure way to produce a digest of a
  49  * key and data.
  50  *
  51  * Both the key and data are arbitrary byte arrays of bytes or characters.
  52  *
  53  * Support for HMAC Digests has been added in GLib 2.30.
  54  */
  55
  56 struct _GHmac
  57 {
  58   int ref_count;
  59   GChecksumType digest_type;
  60   GChecksum *digesti;
  61   GChecksum *digesto;
  62 };
  63
  64 /**
  65  * g_hmac_new:
  66  * @digest_type: the desired type of digest
  67  * @key: (array length=key_len): the key for the HMAC
  68  * @key_len: the length of the keys
  69  *
  70  * Creates a new #GHmac, using the digest algorithm @digest_type.
  71  * If the @digest_type is not known, %NULL is returned.
  72  * A #GHmac can be used to compute the HMAC of a key and an
  73  * arbitrary binary blob, using different hashing algorithms.
  74  *
  75  * A #GHmac works by feeding a binary blob through g_hmac_update()
  76  * until the data is complete; the digest can then be extracted
  77  * using g_hmac_get_string(), which will return the checksum as a
  78  * hexadecimal string; or g_hmac_get_digest(), which will return a
  79  * array of raw bytes. Once either g_hmac_get_string() or
  80  * g_hmac_get_digest() have been called on a #GHmac, the HMAC
  81  * will be closed and it won't be possible to call g_hmac_update()
  82  * on it anymore.
  83  *
  84  * Return value: the newly created #GHmac, or %NULL.
  85  *   Use g_hmac_unref() to free the memory allocated by it.
  86  *
  87  * Since: 2.30
  88  */
  89 GHmac *
  90 g_hmac_new (GChecksumType  digest_type,
  91             const guchar  *key,
  92             gsize          key_len)
  93 {
  94   GChecksum *checksum;
  95   GHmac *hmac;
  96   guchar *buffer;
  97   guchar *pad;
  98   gsize i, len;
  99   gsize block_size;
 100
 101   checksum = g_checksum_new (digest_type);
 102   g_return_val_if_fail (checksum != NULL, NULL);
 103
 104   switch (digest_type)
 105     {
 106     case G_CHECKSUM_MD5:
 107     case G_CHECKSUM_SHA1:
 108       block_size = 64; /* RFC 2104 */
 109       break;
 110     case G_CHECKSUM_SHA256:
 111       block_size = 64; /* RFC draft-kelly-ipsec-ciph-sha2-01 */
 112       break;
 113     default:
 114       g_return_val_if_reached (NULL);
 115     }
 116
 117   hmac = g_slice_new0 (GHmac);
 118   hmac->ref_count = 1;
 119   hmac->digest_type = digest_type;
 120   hmac->digesti = checksum;
 121   hmac->digesto = g_checksum_new (digest_type);
 122
 123   buffer = g_alloca (block_size);
 124   pad = g_alloca (block_size);
 125
 126   memset (buffer, 0, block_size);
 127
 128   /* If the key is too long, hash it */
 129   if (key_len > block_size)
 130     {
 131       len = block_size;
 132       g_checksum_update (hmac->digesti, key, key_len);
 133       g_checksum_get_digest (hmac->digesti, buffer, &len);
 134       g_checksum_reset (hmac->digesti);
 135     }
 136
 137   /* Otherwise pad it with zeros */
 138   else
 139     {
 140       memcpy (buffer, key, key_len);
 141     }
 142
 143   /* First pad */
 144   for (i = 0; i < block_size; i++)
 145     pad[i] = 0x36 ^ buffer[i]; /* ipad value */
 146   g_checksum_update (hmac->digesti, pad, block_size);
 147
 148   /* Second pad */
 149   for (i = 0; i < block_size; i++)
 150     pad[i] = 0x5c ^ buffer[i]; /* opad value */
 151   g_checksum_update (hmac->digesto, pad, block_size);
 152
 153   return hmac;
 154 }
 155
 156 /**
 157  * g_hmac_copy:
 158  * @hmac: the #GHmac to copy
 159  *
 160  * Copies a #GHmac. If @hmac has been closed, by calling
 161  * g_hmac_get_string() or g_hmac_get_digest(), the copied
 162  * HMAC will be closed as well.
 163  *
 164  * Return value: the copy of the passed #GHmac. Use g_hmac_unref()
 165  *   when finished using it.
 166  *
 167  * Since: 2.30
 168  */
 169 GHmac *
 170 g_hmac_copy (const GHmac *hmac)
 171 {
 172   GHmac *copy;
 173
 174   g_return_val_if_fail (hmac != NULL, NULL);
 175
 176   copy = g_slice_new (GHmac);
 177   copy->ref_count = 1;
 178   copy->digest_type = hmac->digest_type;
 179   copy->digesti = g_checksum_copy (hmac->digesti);
 180   copy->digesto = g_checksum_copy (hmac->digesto);
 181
 182   return copy;
 183 }
 184
 185 /**
 186  * g_hmac_ref:
 187  * @hmac: a valid #GHmac
 188  *
 189  * Atomically increments the reference count of @hmac by one.
 190  *
 191  * This function is MT-safe and may be called from any thread.
 192  *
 193  * Return value: the passed in #GHmac.
 194  *
 195  * Since: 2.30
 196  **/
 197 GHmac *
 198 g_hmac_ref (GHmac *hmac)
 199 {
 200   g_return_val_if_fail (hmac != NULL, NULL);
 201
 202   g_atomic_int_inc (&hmac->ref_count);
 203
 204   return hmac;
 205 }
 206
 207 /**
 208  * g_hmac_unref:
 209  * @hmac: a #GHmac
 210  *
 211  * Atomically decrements the reference count of @hmac by one.
 212  *
 213  * If the reference count drops to 0, all keys and values will be
 214  * destroyed, and all memory allocated by the hash table is released.
 215  * This function is MT-safe and may be called from any thread.
 216  * Frees the memory allocated for @hmac.
 217  *
 218  * Since: 2.30
 219  */
 220 void
 221 g_hmac_unref (GHmac *hmac)
 222 {
 223   g_return_if_fail (hmac != NULL);
 224
 225   if (g_atomic_int_dec_and_test (&hmac->ref_count))
 226     {
 227       g_checksum_free (hmac->digesti);
 228       g_checksum_free (hmac->digesto);
 229       g_slice_free (GHmac, hmac);
 230     }
 231 }
 232
 233 /**
 234  * g_hmac_update:
 235  * @hmac: a #GHmac
 236  * @data: (array length=length): buffer used to compute the checksum
 237  * @length: size of the buffer, or -1 if it is a nul-terminated string
 238  *
 239  * Feeds @data into an existing #GHmac.
 240  *
 241  * The HMAC must still be open, that is g_hmac_get_string() or
 242  * g_hmac_get_digest() must not have been called on @hmac.
 243  *
 244  * Since: 2.30
 245  */
 246 void
 247 g_hmac_update (GHmac        *hmac,
 248                const guchar *data,
 249                gssize        length)
 250 {
 251   g_return_if_fail (hmac != NULL);
 252   g_return_if_fail (length == 0 || data != NULL);
 253
 254   g_checksum_update (hmac->digesti, data, length);
 255 }
 256
 257 /**
 258  * g_hmac_get_string:
 259  * @hmac: a #GHmac
 260  *
 261  * Gets the HMAC as an hexadecimal string.
 262  *
 263  * Once this function has been called the #GHmac can no longer be
 264  * updated with g_hmac_update().
 265  *
 266  * The hexadecimal characters will be lower case.
 267  *
 268  * Return value: the hexadecimal representation of the HMAC. The
 269  *   returned string is owned by the HMAC and should not be modified
 270  *   or freed.
 271  *
 272  * Since: 2.30
 273  */
 274 const gchar *
 275 g_hmac_get_string (GHmac *hmac)
 276 {
 277   guint8 *buffer;
 278   gsize digest_len;
 279
 280   g_return_val_if_fail (hmac != NULL, NULL);
 281
 282   digest_len = g_checksum_type_get_length (hmac->digest_type);
 283   buffer = g_alloca (digest_len);
 284
 285   /* This is only called for its side-effect of updating hmac->digesto... */
 286   g_hmac_get_digest (hmac, buffer, &digest_len);
 287   /* ... because we get the string from the checksum rather than
 288    * stringifying buffer ourselves
 289    */
 290   return g_checksum_get_string (hmac->digesto);
 291 }
 292
 293 /**
 294  * g_hmac_get_digest:
 295  * @hmac: a #GHmac
 296  * @buffer: output buffer
 297  * @digest_len: an inout parameter. The caller initializes it to the
 298  *   size of @buffer. After the call it contains the length of the digest
 299  *
 300  * Gets the digest from @checksum as a raw binary array and places it
 301  * into @buffer. The size of the digest depends on the type of checksum.
 302  *
 303  * Once this function has been called, the #GHmac is closed and can
 304  * no longer be updated with g_checksum_update().
 305  *
 306  * Since: 2.30
 307  */
 308 void
 309 g_hmac_get_digest (GHmac  *hmac,
 310                    guint8 *buffer,
 311                    gsize  *digest_len)
 312 {
 313   gsize len;
 314
 315   g_return_if_fail (hmac != NULL);
 316
 317   len = g_checksum_type_get_length (hmac->digest_type);
 318   g_return_if_fail (*digest_len >= len);
 319
 320   /* Use the same buffer, because we can :) */
 321   g_checksum_get_digest (hmac->digesti, buffer, &len);
 322   g_checksum_update (hmac->digesto, buffer, len);
 323   g_checksum_get_digest (hmac->digesto, buffer, digest_len);
 324 }
 325
 326 /**
 327  * g_compute_hmac_for_data:
 328  * @digest_type: a #GChecksumType to use for the HMAC
 329  * @key: (array length=key_len): the key to use in the HMAC
 330  * @key_len: the length of the key
 331  * @data: binary blob to compute the HMAC of
 332  * @length: length of @data
 333  *
 334  * Computes the HMAC for a binary @data of @length. This is a
 335  * convenience wrapper for g_hmac_new(), g_hmac_get_string()
 336  * and g_hmac_unref().
 337  *
 338  * The hexadecimal string returned will be in lower case.
 339  *
 340  * Return value: the HMAC of the binary data as a string in hexadecimal.
 341  *   The returned string should be freed with g_free() when done using it.
 342  *
 343  * Since: 2.30
 344  */
 345 gchar *
 346 g_compute_hmac_for_data (GChecksumType  digest_type,
 347                          const guchar  *key,
 348                          gsize          key_len,
 349                          const guchar  *data,
 350                          gsize          length)
 351 {
 352   GHmac *hmac;
 353   gchar *retval;
 354
 355   g_return_val_if_fail (length == 0 || data != NULL, NULL);
 356
 357   hmac = g_hmac_new (digest_type, key, key_len);
 358   if (!hmac)
 359     return NULL;
 360
 361   g_hmac_update (hmac, data, length);
 362   retval = g_strdup (g_hmac_get_string (hmac));
 363   g_hmac_unref (hmac);
 364
 365   return retval;
 366 }
 367
 368 /**
 369  * g_compute_hmac_for_string:
 370  * @digest_type: a #GChecksumType to use for the HMAC
 371  * @key: (array length=key_len): the key to use in the HMAC
 372  * @key_len: the length of the key
 373  * @str: the string to compute the HMAC for
 374  * @length: the length of the string, or -1 if the string is nul-terminated
 375  *
 376  * Computes the HMAC for a string.
 377  *
 378  * The hexadecimal string returned will be in lower case.
 379  *
 380  * Return value: the HMAC as a hexadecimal string.
 381  *     The returned string should be freed with g_free()
 382  *     when done using it.
 383  *
 384  * Since: 2.30
 385  */
 386 gchar *
 387 g_compute_hmac_for_string (GChecksumType  digest_type,
 388                            const guchar  *key,
 389                            gsize          key_len,
 390                            const gchar   *str,
 391                            gssize         length)
 392 {
 393   g_return_val_if_fail (length == 0 || str != NULL, NULL);
 394
 395   if (length < 0)
 396     length = strlen (str);
 397
 398   return g_compute_hmac_for_data (digest_type, key, key_len,
 399                                   (const guchar *) str, length);
 400 }