lib/mac.c

   1 /*
   2  * Copyright (C) 2013 Gregor Pintar <grpintar@gmail.com>
   3  *
   4  * Permission is granted to deal in this work without any restriction,
   5  * including unlimited rights to use, publicly perform, publish,
   6  * reproduce, relicence, modify, merge, and/or distribute in any form,
   7  * for any purpose, with or without fee, and by any means.
   8  *
   9  * This work is provided "AS IS" and WITHOUT WARRANTY of any kind,
  10  * to the utmost extent permitted by applicable law. In no event
  11  * shall a licensor, author or contributor be held liable for any
  12  * issues arising in any way out of dealing in the work.
  13  */
  14
  15 #include <assert.h>
  16
  17 #include <kripto/mac_desc.h>
  18
  19 #include <kripto/mac.h>
  20
  21 struct kripto_mac
  22 {
  23         const kripto_mac_desc *desc;
  24 };
  25
  26 kripto_mac *kripto_mac_create
  27 (
  28         const kripto_mac_desc *desc,
  29         unsigned int rounds,
  30         const void *key,
  31         unsigned int key_len,
  32         unsigned int tag_len
  33 )
  34 {
  35         assert(desc);
  36         assert(desc->create);
  37
  38         assert(key);
  39         assert(key_len);
  40
  41         return desc->create(desc, rounds, key, key_len, tag_len);
  42 }
  43
  44 kripto_mac *kripto_mac_recreate
  45 (
  46         kripto_mac *s,
  47         unsigned int rounds,
  48         const void *key,
  49         unsigned int key_len,
  50         unsigned int tag_len
  51 )
  52 {
  53         assert(s);
  54         assert(s->desc);
  55         assert(s->desc->recreate);
  56
  57         assert(key);
  58         assert(key_len);
  59
  60         return s->desc->recreate(s, rounds, key, key_len, tag_len);
  61 }
  62
  63 void kripto_mac_input(kripto_mac *s, const void *in, size_t len)
  64 {
  65         assert(s);
  66         assert(s->desc);
  67         assert(s->desc->input);
  68
  69         s->desc->input(s, in, len);
  70 }
  71
  72 void kripto_mac_tag(kripto_mac *s, void *tag, unsigned int len)
  73 {
  74         assert(s);
  75         assert(s->desc);
  76         assert(s->desc->tag);
  77
  78         s->desc->tag(s, tag, len);
  79 }
  80
  81 void kripto_mac_destroy(kripto_mac *s)
  82 {
  83         assert(s);
  84         assert(s->desc);
  85         assert(s->desc->destroy);
  86
  87         s->desc->destroy(s);
  88 }
  89
  90 int kripto_mac_all
  91 (
  92         const kripto_mac_desc *desc,
  93         unsigned int rounds,
  94         const void *key,
  95         unsigned int key_len,
  96         const void *in,
  97         unsigned int in_len,
  98         void *tag,
  99         unsigned int tag_len
 100 )
 101 {
 102         kripto_mac *s;
 103
 104         assert(desc);
 105
 106         s = kripto_mac_create(desc, rounds, key, key_len, tag_len);
 107         if(!s) return -1;
 108
 109         kripto_mac_input(s, in, in_len);
 110         kripto_mac_tag(s, tag, tag_len);
 111
 112         kripto_mac_destroy(s);
 113
 114         return 0;
 115 }
 116
 117 const kripto_mac_desc *kripto_mac_getdesc(const kripto_mac *s)
 118 {
 119         assert(s);
 120         assert(s->desc);
 121
 122         return s->desc;
 123 }
 124
 125 unsigned int kripto_mac_maxtag(const kripto_mac_desc *desc)
 126 {
 127         assert(desc);
 128
 129         return desc->maxtag;
 130 }