contrib/pgcrypto/internal-sha2.c

   1 /*
   2  * internal.c
   3  *              Wrapper for builtin functions
   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 <time.h>
  35
  36 #include "px.h"
  37 #include "sha2.h"
  38
  39 void            init_sha224(PX_MD * h);
  40 void            init_sha256(PX_MD * h);
  41 void            init_sha384(PX_MD * h);
  42 void            init_sha512(PX_MD * h);
  43
  44 /* SHA224 */
  45
  46 static unsigned
  47 int_sha224_len(PX_MD * h)
  48 {
  49         return SHA224_DIGEST_LENGTH;
  50 }
  51
  52 static unsigned
  53 int_sha224_block_len(PX_MD * h)
  54 {
  55         return SHA224_BLOCK_LENGTH;
  56 }
  57
  58 static void
  59 int_sha224_update(PX_MD * h, const uint8 *data, unsigned dlen)
  60 {
  61         SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
  62
  63         SHA224_Update(ctx, data, dlen);
  64 }
  65
  66 static void
  67 int_sha224_reset(PX_MD * h)
  68 {
  69         SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
  70
  71         SHA224_Init(ctx);
  72 }
  73
  74 static void
  75 int_sha224_finish(PX_MD * h, uint8 *dst)
  76 {
  77         SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
  78
  79         SHA224_Final(dst, ctx);
  80 }
  81
  82 static void
  83 int_sha224_free(PX_MD * h)
  84 {
  85         SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
  86
  87         memset(ctx, 0, sizeof(*ctx));
  88         px_free(ctx);
  89         px_free(h);
  90 }
  91
  92 /* SHA256 */
  93
  94 static unsigned
  95 int_sha256_len(PX_MD * h)
  96 {
  97         return SHA256_DIGEST_LENGTH;
  98 }
  99
 100 static unsigned
 101 int_sha256_block_len(PX_MD * h)
 102 {
 103         return SHA256_BLOCK_LENGTH;
 104 }
 105
 106 static void
 107 int_sha256_update(PX_MD * h, const uint8 *data, unsigned dlen)
 108 {
 109         SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
 110
 111         SHA256_Update(ctx, data, dlen);
 112 }
 113
 114 static void
 115 int_sha256_reset(PX_MD * h)
 116 {
 117         SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
 118
 119         SHA256_Init(ctx);
 120 }
 121
 122 static void
 123 int_sha256_finish(PX_MD * h, uint8 *dst)
 124 {
 125         SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
 126
 127         SHA256_Final(dst, ctx);
 128 }
 129
 130 static void
 131 int_sha256_free(PX_MD * h)
 132 {
 133         SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
 134
 135         memset(ctx, 0, sizeof(*ctx));
 136         px_free(ctx);
 137         px_free(h);
 138 }
 139
 140 /* SHA384 */
 141
 142 static unsigned
 143 int_sha384_len(PX_MD * h)
 144 {
 145         return SHA384_DIGEST_LENGTH;
 146 }
 147
 148 static unsigned
 149 int_sha384_block_len(PX_MD * h)
 150 {
 151         return SHA384_BLOCK_LENGTH;
 152 }
 153
 154 static void
 155 int_sha384_update(PX_MD * h, const uint8 *data, unsigned dlen)
 156 {
 157         SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
 158
 159         SHA384_Update(ctx, data, dlen);
 160 }
 161
 162 static void
 163 int_sha384_reset(PX_MD * h)
 164 {
 165         SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
 166
 167         SHA384_Init(ctx);
 168 }
 169
 170 static void
 171 int_sha384_finish(PX_MD * h, uint8 *dst)
 172 {
 173         SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
 174
 175         SHA384_Final(dst, ctx);
 176 }
 177
 178 static void
 179 int_sha384_free(PX_MD * h)
 180 {
 181         SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
 182
 183         memset(ctx, 0, sizeof(*ctx));
 184         px_free(ctx);
 185         px_free(h);
 186 }
 187
 188 /* SHA512 */
 189
 190 static unsigned
 191 int_sha512_len(PX_MD * h)
 192 {
 193         return SHA512_DIGEST_LENGTH;
 194 }
 195
 196 static unsigned
 197 int_sha512_block_len(PX_MD * h)
 198 {
 199         return SHA512_BLOCK_LENGTH;
 200 }
 201
 202 static void
 203 int_sha512_update(PX_MD * h, const uint8 *data, unsigned dlen)
 204 {
 205         SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
 206
 207         SHA512_Update(ctx, data, dlen);
 208 }
 209
 210 static void
 211 int_sha512_reset(PX_MD * h)
 212 {
 213         SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
 214
 215         SHA512_Init(ctx);
 216 }
 217
 218 static void
 219 int_sha512_finish(PX_MD * h, uint8 *dst)
 220 {
 221         SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
 222
 223         SHA512_Final(dst, ctx);
 224 }
 225
 226 static void
 227 int_sha512_free(PX_MD * h)
 228 {
 229         SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
 230
 231         memset(ctx, 0, sizeof(*ctx));
 232         px_free(ctx);
 233         px_free(h);
 234 }
 235
 236 /* init functions */
 237
 238 void
 239 init_sha224(PX_MD * md)
 240 {
 241         SHA224_CTX *ctx;
 242
 243         ctx = px_alloc(sizeof(*ctx));
 244         memset(ctx, 0, sizeof(*ctx));
 245
 246         md->p.ptr = ctx;
 247
 248         md->result_size = int_sha224_len;
 249         md->block_size = int_sha224_block_len;
 250         md->reset = int_sha224_reset;
 251         md->update = int_sha224_update;
 252         md->finish = int_sha224_finish;
 253         md->free = int_sha224_free;
 254
 255         md->reset(md);
 256 }
 257
 258 void
 259 init_sha256(PX_MD * md)
 260 {
 261         SHA256_CTX *ctx;
 262
 263         ctx = px_alloc(sizeof(*ctx));
 264         memset(ctx, 0, sizeof(*ctx));
 265
 266         md->p.ptr = ctx;
 267
 268         md->result_size = int_sha256_len;
 269         md->block_size = int_sha256_block_len;
 270         md->reset = int_sha256_reset;
 271         md->update = int_sha256_update;
 272         md->finish = int_sha256_finish;
 273         md->free = int_sha256_free;
 274
 275         md->reset(md);
 276 }
 277
 278 void
 279 init_sha384(PX_MD * md)
 280 {
 281         SHA384_CTX *ctx;
 282
 283         ctx = px_alloc(sizeof(*ctx));
 284         memset(ctx, 0, sizeof(*ctx));
 285
 286         md->p.ptr = ctx;
 287
 288         md->result_size = int_sha384_len;
 289         md->block_size = int_sha384_block_len;
 290         md->reset = int_sha384_reset;
 291         md->update = int_sha384_update;
 292         md->finish = int_sha384_finish;
 293         md->free = int_sha384_free;
 294
 295         md->reset(md);
 296 }
 297
 298 void
 299 init_sha512(PX_MD * md)
 300 {
 301         SHA512_CTX *ctx;
 302
 303         ctx = px_alloc(sizeof(*ctx));
 304         memset(ctx, 0, sizeof(*ctx));
 305
 306         md->p.ptr = ctx;
 307
 308         md->result_size = int_sha512_len;
 309         md->block_size = int_sha512_block_len;
 310         md->reset = int_sha512_reset;
 311         md->update = int_sha512_update;
 312         md->finish = int_sha512_finish;
 313         md->free = int_sha512_free;
 314
 315         md->reset(md);
 316 }