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  * contrib/pgcrypto/px-hmac.c
  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                                 i;
  56         uint8      *keybuf;
  57         PX_MD      *md = h->md;
  58
  59         bs = px_md_block_size(md);
  60         keybuf = palloc0(bs);
  61
  62         if (klen > bs)
  63         {
  64                 px_md_update(md, key, klen);
  65                 px_md_finish(md, keybuf);
  66                 px_md_reset(md);
  67         }
  68         else
  69                 memcpy(keybuf, key, klen);
  70
  71         for (i = 0; i < bs; i++)
  72         {
  73                 h->p.ipad[i] = keybuf[i] ^ HMAC_IPAD;
  74                 h->p.opad[i] = keybuf[i] ^ HMAC_OPAD;
  75         }
  76
  77         px_memset(keybuf, 0, bs);
  78         pfree(keybuf);
  79
  80         px_md_update(md, h->p.ipad, bs);
  81 }
  82
  83 static void
  84 hmac_reset(PX_HMAC *h)
  85 {
  86         PX_MD      *md = h->md;
  87         unsigned        bs = px_md_block_size(md);
  88
  89         px_md_reset(md);
  90         px_md_update(md, h->p.ipad, bs);
  91 }
  92
  93 static void
  94 hmac_update(PX_HMAC *h, const uint8 *data, unsigned dlen)
  95 {
  96         px_md_update(h->md, data, dlen);
  97 }
  98
  99 static void
 100 hmac_finish(PX_HMAC *h, uint8 *dst)
 101 {
 102         PX_MD      *md = h->md;
 103         unsigned        bs,
 104                                 hlen;
 105         uint8      *buf;
 106
 107         bs = px_md_block_size(md);
 108         hlen = px_md_result_size(md);
 109
 110         buf = palloc(hlen);
 111
 112         px_md_finish(md, buf);
 113
 114         px_md_reset(md);
 115         px_md_update(md, h->p.opad, bs);
 116         px_md_update(md, buf, hlen);
 117         px_md_finish(md, dst);
 118
 119         px_memset(buf, 0, hlen);
 120         pfree(buf);
 121 }
 122
 123 static void
 124 hmac_free(PX_HMAC *h)
 125 {
 126         unsigned        bs;
 127
 128         bs = px_md_block_size(h->md);
 129         px_md_free(h->md);
 130
 131         px_memset(h->p.ipad, 0, bs);
 132         px_memset(h->p.opad, 0, bs);
 133         pfree(h->p.ipad);
 134         pfree(h->p.opad);
 135         pfree(h);
 136 }
 137
 138
 139 /* PUBLIC FUNCTIONS */
 140
 141 int
 142 px_find_hmac(const char *name, PX_HMAC **res)
 143 {
 144         int                     err;
 145         PX_MD      *md;
 146         PX_HMAC    *h;
 147         unsigned        bs;
 148
 149         err = px_find_digest(name, &md);
 150         if (err)
 151                 return err;
 152
 153         bs = px_md_block_size(md);
 154         if (bs < 2)
 155         {
 156                 px_md_free(md);
 157                 return PXE_HASH_UNUSABLE_FOR_HMAC;
 158         }
 159
 160         h = palloc(sizeof(*h));
 161         h->p.ipad = palloc(bs);
 162         h->p.opad = palloc(bs);
 163         h->md = md;
 164
 165         h->result_size = hmac_result_size;
 166         h->block_size = hmac_block_size;
 167         h->reset = hmac_reset;
 168         h->update = hmac_update;
 169         h->finish = hmac_finish;
 170         h->free = hmac_free;
 171         h->init = hmac_init;
 172
 173         *res = h;
 174
 175         return 0;
 176 }