lib/block.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 <assert.h>
  15
  16 #include <kripto/block.h>
  17 #include <kripto/desc/block.h>
  18
  19 struct kripto_block
  20 {
  21         const kripto_block_desc *desc;
  22 };
  23
  24 kripto_block *kripto_block_create
  25 (
  26         const kripto_block_desc *desc,
  27         unsigned int rounds,
  28         const void *key,
  29         unsigned int key_len
  30 )
  31 {
  32         assert(desc);
  33         assert(desc->create);
  34
  35         assert(key);
  36         assert(key_len);
  37         assert(key_len <= kripto_block_maxkey(desc));
  38
  39         return desc->create(rounds, key, key_len);
  40 }
  41
  42 kripto_block *kripto_block_recreate
  43 (
  44         kripto_block *s,
  45         unsigned int rounds,
  46         const void *key,
  47         unsigned int key_len
  48 )
  49 {
  50         assert(s);
  51         assert(s->desc);
  52         assert(s->desc->recreate);
  53
  54         assert(key);
  55         assert(key_len);
  56         assert(key_len <= kripto_block_maxkey(s->desc));
  57
  58         return s->desc->recreate(s, rounds, key, key_len);
  59 }
  60
  61 void kripto_block_tweak
  62 (
  63         kripto_block *s,
  64         const void *tweak,
  65         unsigned int len
  66 )
  67 {
  68         assert(s);
  69         assert(s->desc);
  70         assert(s->desc->tweak);
  71
  72         assert(tweak);
  73         assert(len);
  74
  75         s->desc->tweak(s, tweak, len);
  76 }
  77
  78 void kripto_block_encrypt
  79 (
  80         const kripto_block *s,
  81         const void *pt,
  82         void *ct
  83 )
  84 {
  85         assert(s);
  86         assert(s->desc);
  87         assert(s->desc->encrypt);
  88         assert(pt);
  89         assert(ct);
  90
  91         s->desc->encrypt(s, pt, ct);
  92 }
  93
  94 void kripto_block_decrypt
  95 (
  96         const kripto_block *s,
  97         const void *ct,
  98         void *pt
  99 )
 100 {
 101         assert(s);
 102         assert(s->desc);
 103         assert(s->desc->decrypt);
 104         assert(ct);
 105         assert(pt);
 106
 107         s->desc->decrypt(s, ct, pt);
 108 }
 109
 110 void kripto_block_destroy(kripto_block *s)
 111 {
 112         assert(s);
 113         assert(s->desc);
 114         assert(s->desc->destroy);
 115
 116         s->desc->destroy(s);
 117 }
 118
 119 const kripto_block_desc *kripto_block_getdesc(const kripto_block *s)
 120 {
 121         assert(s);
 122         assert(s->desc);
 123
 124         return s->desc;
 125 }
 126
 127 unsigned int kripto_block_size(const kripto_block_desc *desc)
 128 {
 129         assert(desc);
 130         assert(desc->blocksize);
 131
 132         return desc->blocksize;
 133 }
 134
 135 unsigned int kripto_block_maxkey(const kripto_block_desc *desc)
 136 {
 137         assert(desc);
 138         assert(desc->maxkey);
 139
 140         return desc->maxkey;
 141 }
 142
 143 unsigned int kripto_block_maxtweak(const kripto_block_desc *desc)
 144 {
 145         assert(desc);
 146
 147         return desc->maxtweak;
 148 }