include/reactos/libs/gnutls/nettle/hmac.h

   1 /* hmac.h
   2  *
   3  * HMAC message authentication code (RFC-2104).
   4  */
   5
   6 /* nettle, low-level cryptographics library
   7  *
   8  * Copyright (C) 2001, 2002 Niels Möller
   9  *
  10  * The nettle library is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or (at your
  13  * option) any later version.
  14  *
  15  * The nettle library is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  17  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  18  * License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with the nettle library; see the file COPYING.LIB.  If not, write to
  22  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  23  * MA 02111-1301, USA.
  24  */
  25
  26 #ifndef NETTLE_HMAC_H_INCLUDED
  27 #define NETTLE_HMAC_H_INCLUDED
  28
  29 #include "nettle-meta.h"
  30
  31 #include "md5.h"
  32 #include "ripemd160.h"
  33 #include "sha1.h"
  34 #include "sha2.h"
  35
  36 #ifdef __cplusplus
  37 extern "C" {
  38 #endif
  39
  40 /* Namespace mangling */
  41 #define hmac_set_key nettle_hmac_set_key
  42 #define hmac_update nettle_hmac_update
  43 #define hmac_digest nettle_hmac_digest
  44 #define hmac_md5_set_key nettle_hmac_md5_set_key
  45 #define hmac_md5_update nettle_hmac_md5_update
  46 #define hmac_md5_digest nettle_hmac_md5_digest
  47 #define hmac_ripemd160_set_key nettle_hmac_ripemd160_set_key
  48 #define hmac_ripemd160_update nettle_hmac_ripemd160_update
  49 #define hmac_ripemd160_digest nettle_hmac_ripemd160_digest
  50 #define hmac_sha1_set_key nettle_hmac_sha1_set_key
  51 #define hmac_sha1_update nettle_hmac_sha1_update
  52 #define hmac_sha1_digest nettle_hmac_sha1_digest
  53 #define hmac_sha224_set_key nettle_hmac_sha224_set_key
  54 #define hmac_sha224_digest nettle_hmac_sha224_digest
  55 #define hmac_sha256_set_key nettle_hmac_sha256_set_key
  56 #define hmac_sha256_update nettle_hmac_sha256_update
  57 #define hmac_sha256_digest nettle_hmac_sha256_digest
  58 #define hmac_sha384_set_key nettle_hmac_sha384_set_key
  59 #define hmac_sha384_digest nettle_hmac_sha384_digest
  60 #define hmac_sha512_set_key nettle_hmac_sha512_set_key
  61 #define hmac_sha512_update nettle_hmac_sha512_update
  62 #define hmac_sha512_digest nettle_hmac_sha512_digest
  63
  64         void
  65          hmac_set_key(void *outer, void *inner, void *state,
  66                       const struct nettle_hash *hash,
  67                       unsigned length, const uint8_t * key);
  68
  69 /* This function is not strictly needed, it's s just the same as the
  70  * hash update function. */
  71         void
  72          hmac_update(void *state,
  73                      const struct nettle_hash *hash,
  74                      unsigned length, const uint8_t * data);
  75
  76         void
  77          hmac_digest(const void *outer, const void *inner, void *state,
  78                      const struct nettle_hash *hash,
  79                      unsigned length, uint8_t * digest);
  80
  81
  82 #define HMAC_CTX(type) \
  83 { type outer; type inner; type state; }
  84
  85 #define HMAC_SET_KEY(ctx, hash, length, key)                    \
  86   hmac_set_key( &(ctx)->outer, &(ctx)->inner, &(ctx)->state,    \
  87                 (hash), (length), (key) )
  88
  89 #define HMAC_DIGEST(ctx, hash, length, digest)                  \
  90   hmac_digest( &(ctx)->outer, &(ctx)->inner, &(ctx)->state,     \
  91                (hash), (length), (digest) )
  92
  93 /* HMAC using specific hash functions */
  94
  95 /* hmac-md5 */
  96         struct hmac_md5_ctx HMAC_CTX(struct md5_ctx);
  97
  98         void
  99          hmac_md5_set_key(struct hmac_md5_ctx *ctx,
 100                           unsigned key_length, const uint8_t * key);
 101
 102         void
 103          hmac_md5_update(struct hmac_md5_ctx *ctx,
 104                          unsigned length, const uint8_t * data);
 105
 106         void
 107          hmac_md5_digest(struct hmac_md5_ctx *ctx,
 108                          unsigned length, uint8_t * digest);
 109
 110
 111 /* hmac-ripemd160 */
 112         struct hmac_ripemd160_ctx HMAC_CTX(struct ripemd160_ctx);
 113
 114         void
 115          hmac_ripemd160_set_key(struct hmac_ripemd160_ctx *ctx,
 116                                 unsigned key_length, const uint8_t * key);
 117
 118         void
 119          hmac_ripemd160_update(struct hmac_ripemd160_ctx *ctx,
 120                                unsigned length, const uint8_t * data);
 121
 122         void
 123          hmac_ripemd160_digest(struct hmac_ripemd160_ctx *ctx,
 124                                unsigned length, uint8_t * digest);
 125
 126
 127 /* hmac-sha1 */
 128         struct hmac_sha1_ctx HMAC_CTX(struct sha1_ctx);
 129
 130         void
 131          hmac_sha1_set_key(struct hmac_sha1_ctx *ctx,
 132                            unsigned key_length, const uint8_t * key);
 133
 134         void
 135          hmac_sha1_update(struct hmac_sha1_ctx *ctx,
 136                           unsigned length, const uint8_t * data);
 137
 138         void
 139          hmac_sha1_digest(struct hmac_sha1_ctx *ctx,
 140                           unsigned length, uint8_t * digest);
 141
 142 /* hmac-sha256 */
 143         struct hmac_sha256_ctx HMAC_CTX(struct sha256_ctx);
 144
 145         void
 146          hmac_sha256_set_key(struct hmac_sha256_ctx *ctx,
 147                              unsigned key_length, const uint8_t * key);
 148
 149         void
 150          hmac_sha256_update(struct hmac_sha256_ctx *ctx,
 151                             unsigned length, const uint8_t * data);
 152
 153         void
 154          hmac_sha256_digest(struct hmac_sha256_ctx *ctx,
 155                             unsigned length, uint8_t * digest);
 156
 157 /* hmac-sha224 */
 158 #define hmac_sha224_ctx hmac_sha256_ctx
 159
 160         void
 161          hmac_sha224_set_key(struct hmac_sha224_ctx *ctx,
 162                              unsigned key_length, const uint8_t * key);
 163
 164 #define hmac_sha224_update nettle_hmac_sha256_update
 165
 166         void
 167          hmac_sha224_digest(struct hmac_sha224_ctx *ctx,
 168                             unsigned length, uint8_t * digest);
 169
 170 /* hmac-sha512 */
 171         struct hmac_sha512_ctx HMAC_CTX(struct sha512_ctx);
 172
 173         void
 174          hmac_sha512_set_key(struct hmac_sha512_ctx *ctx,
 175                              unsigned key_length, const uint8_t * key);
 176
 177         void
 178          hmac_sha512_update(struct hmac_sha512_ctx *ctx,
 179                             unsigned length, const uint8_t * data);
 180
 181         void
 182          hmac_sha512_digest(struct hmac_sha512_ctx *ctx,
 183                             unsigned length, uint8_t * digest);
 184
 185 /* hmac-sha384 */
 186 #define hmac_sha384_ctx hmac_sha512_ctx
 187
 188         void
 189          hmac_sha384_set_key(struct hmac_sha512_ctx *ctx,
 190                              unsigned key_length, const uint8_t * key);
 191
 192 #define hmac_sha384_update nettle_hmac_sha512_update
 193
 194         void
 195          hmac_sha384_digest(struct hmac_sha512_ctx *ctx,
 196                             unsigned length, uint8_t * digest);
 197
 198 #ifdef __cplusplus
 199 }
 200 #endif
 201 #endif                          /* NETTLE_HMAC_H_INCLUDED */