lib/mac/keccak.c

   1 /*
   2  * Written in 2013 by Gregor Pintar <grpintar@gmail.com>
   3  *
   4  * To the extent possible under law, the author(s) have dedicated
   5  * all copyright and related and neighboring rights to this software
   6  * to the public domain worldwide.
   7  *
   8  * This software is distributed without any warranty.
   9  *
  10  * You should have received a copy of the CC0 Public Domain Dedication.
  11  * If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
  12  */
  13
  14 #include <stdint.h>
  15 #include <stdlib.h>
  16 #include <limits.h>
  17
  18 #include <kripto/cast.h>
  19 #include <kripto/memwipe.h>
  20 #include <kripto/hash.h>
  21 #include <kripto/hash/keccak1600.h>
  22 #include <kripto/hash/keccak800.h>
  23 #include <kripto/mac.h>
  24 #include <kripto/desc/mac.h>
  25 #include <kripto/object/mac.h>
  26
  27 #include <kripto/mac/keccak1600.h>
  28 #include <kripto/mac/keccak800.h>
  29
  30 struct kripto_mac
  31 {
  32         struct kripto_mac_object obj;
  33         kripto_hash *hash;
  34 };
  35
  36 static void keccak_input
  37 (
  38         kripto_mac *s,
  39         const void *in,
  40         size_t len
  41 )
  42 {
  43         kripto_hash_input(s->hash, in, len);
  44 }
  45
  46 static void keccak_tag(kripto_mac *s, void *tag, unsigned int len)
  47 {
  48         kripto_hash_output(s->hash, tag, len);
  49 }
  50
  51 static kripto_mac *keccak_recreate
  52 (
  53         kripto_mac *s,
  54         unsigned int r,
  55         const void *key,
  56         unsigned int key_len,
  57         unsigned int tag_len
  58 )
  59 {
  60         (void)kripto_hash_recreate(s->hash, r, tag_len);
  61
  62         kripto_hash_input(s->hash, key, key_len);
  63
  64         return s;
  65 }
  66
  67 static kripto_mac *keccak1600_create
  68 (
  69         const kripto_mac_desc *desc,
  70         unsigned int r,
  71         const void *key,
  72         unsigned int key_len,
  73         unsigned int tag_len
  74 )
  75 {
  76         kripto_mac *s;
  77
  78         (void)desc;
  79
  80         s = malloc(sizeof(kripto_mac));
  81         if(!s) return 0;
  82
  83         s->obj.desc = kripto_mac_keccak1600;
  84
  85         s->hash = kripto_hash_create(kripto_hash_keccak1600, r, tag_len);
  86         if(!s->hash)
  87         {
  88                 free(s);
  89                 return 0;
  90         }
  91
  92         kripto_hash_input(s->hash, key, key_len);
  93
  94         return s;
  95 }
  96
  97 static kripto_mac *keccak800_create
  98 (
  99         const kripto_mac_desc *desc,
 100         unsigned int r,
 101         const void *key,
 102         unsigned int key_len,
 103         unsigned int tag_len
 104 )
 105 {
 106         kripto_mac *s;
 107
 108         (void)desc;
 109
 110         s = malloc(sizeof(kripto_mac));
 111         if(!s) return 0;
 112
 113         s->obj.desc = kripto_mac_keccak800;
 114
 115         s->hash = kripto_hash_create(kripto_hash_keccak800, r, tag_len);
 116         if(!s->hash)
 117         {
 118                 free(s);
 119                 return 0;
 120         }
 121
 122         kripto_hash_input(s->hash, key, key_len);
 123
 124         return s;
 125 }
 126
 127 static void keccak_destroy(kripto_mac *s)
 128 {
 129         kripto_hash_destroy(s->hash);
 130         free(s);
 131 }
 132
 133 static const kripto_mac_desc keccak1600 =
 134 {
 135         &keccak1600_create,
 136         &keccak_recreate,
 137         &keccak_input,
 138         &keccak_tag,
 139         &keccak_destroy,
 140         99, /* max tag */
 141         UINT_MAX /* max key */
 142 };
 143
 144 const kripto_mac_desc *const kripto_mac_keccak1600 = &keccak1600;
 145
 146 static const kripto_mac_desc keccak800 =
 147 {
 148         &keccak800_create,
 149         &keccak_recreate,
 150         &keccak_input,
 151         &keccak_tag,
 152         &keccak_destroy,
 153         49, /* max tag */
 154         UINT_MAX /* max key */
 155 };
 156
 157 const kripto_mac_desc *const kripto_mac_keccak800 = &keccak800;