contrib/pgcrypto/px-hmac.c

   1 /*
   2  * px-hmac.c
   3  *              HMAC implementation.
   4  *
   5  * Copyright (c) 2001 Marko Kreen
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *        notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *        notice, this list of conditions and the following disclaimer in the
  15  *        documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.      IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $PostgreSQL$
  30  */
  31
  32 #include "postgres.h"
  33
  34 #include "px.h"
  35
  36 #define HMAC_IPAD 0x36
  37 #define HMAC_OPAD 0x5C
  38
  39 static unsigned
  40 hmac_result_size(PX_HMAC * h)
  41 {
  42         return px_md_result_size(h->md);
  43 }
  44
  45 static unsigned
  46 hmac_block_size(PX_HMAC * h)
  47 {
  48         return px_md_block_size(h->md);
  49 }
  50
  51 static void
  52 hmac_init(PX_HMAC * h, const uint8 *key, unsigned klen)
  53 {
  54         unsigned        bs,
  55                                 hlen,
  56                                 i;
  57         uint8      *keybuf;
  58         PX_MD      *md = h->md;
  59
  60         bs = px_md_block_size(md);
  61         hlen = px_md_result_size(md);
  62         keybuf = px_alloc(bs);
  63         memset(keybuf, 0, bs);
  64
  65         if (klen > bs)
  66         {
  67                 px_md_update(md, key, klen);
  68                 px_md_finish(md, keybuf);
  69                 px_md_reset(md);
  70         }
  71         else
  72                 memcpy(keybuf, key, klen);
  73
  74         for (i = 0; i < bs; i++)
  75         {
  76                 h->p.ipad[i] = keybuf[i] ^ HMAC_IPAD;
  77                 h->p.opad[i] = keybuf[i] ^ HMAC_OPAD;
  78         }
  79
  80         memset(keybuf, 0, bs);
  81         px_free(keybuf);
  82
  83         px_md_update(md, h->p.ipad, bs);
  84 }
  85
  86 static void
  87 hmac_reset(PX_HMAC * h)
  88 {
  89         PX_MD      *md = h->md;
  90         unsigned        bs = px_md_block_size(md);
  91
  92         px_md_reset(md);
  93         px_md_update(md, h->p.ipad, bs);
  94 }
  95
  96 static void
  97 hmac_update(PX_HMAC * h, const uint8 *data, unsigned dlen)
  98 {
  99         px_md_update(h->md, data, dlen);
 100 }
 101
 102 static void
 103 hmac_finish(PX_HMAC * h, uint8 *dst)
 104 {
 105         PX_MD      *md = h->md;
 106         unsigned        bs,
 107                                 hlen;
 108         uint8      *buf;
 109
 110         bs = px_md_block_size(md);
 111         hlen = px_md_result_size(md);
 112
 113         buf = px_alloc(hlen);
 114
 115         px_md_finish(md, buf);
 116
 117         px_md_reset(md);
 118         px_md_update(md, h->p.opad, bs);
 119         px_md_update(md, buf, hlen);
 120         px_md_finish(md, dst);
 121
 122         memset(buf, 0, hlen);
 123         px_free(buf);
 124 }
 125
 126 static void
 127 hmac_free(PX_HMAC * h)
 128 {
 129         unsigned        bs;
 130
 131         bs = px_md_block_size(h->md);
 132         px_md_free(h->md);
 133
 134         memset(h->p.ipad, 0, bs);
 135         memset(h->p.opad, 0, bs);
 136         px_free(h->p.ipad);
 137         px_free(h->p.opad);
 138         px_free(h);
 139 }
 140
 141
 142 /* PUBLIC FUNCTIONS */
 143
 144 int
 145 px_find_hmac(const char *name, PX_HMAC ** res)
 146 {
 147         int                     err;
 148         PX_MD      *md;
 149         PX_HMAC    *h;
 150         unsigned        bs;
 151
 152         err = px_find_digest(name, &md);
 153         if (err)
 154                 return err;
 155
 156         bs = px_md_block_size(md);
 157         if (bs < 2)
 158         {
 159                 px_md_free(md);
 160                 return PXE_HASH_UNUSABLE_FOR_HMAC;
 161         }
 162
 163         h = px_alloc(sizeof(*h));
 164         h->p.ipad = px_alloc(bs);
 165         h->p.opad = px_alloc(bs);
 166         h->md = md;
 167
 168         h->result_size = hmac_result_size;
 169         h->block_size = hmac_block_size;
 170         h->reset = hmac_reset;
 171         h->update = hmac_update;
 172         h->finish = hmac_finish;
 173         h->free = hmac_free;
 174         h->init = hmac_init;
 175
 176         *res = h;
 177
 178         return 0;
 179 }