lib/authstream.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 #include <stdint.h>
  17
  18 #include <kripto/desc/authstream.h>
  19
  20 #include <kripto/authstream.h>
  21
  22 struct kripto_authstream
  23 {
  24         const kripto_authstream_desc *desc;
  25         unsigned int multof;
  26 };
  27
  28 kripto_authstream *kripto_authstream_create
  29 (
  30         const kripto_authstream_desc *desc,
  31         unsigned int rounds,
  32         const void *key,
  33         unsigned int key_len,
  34         const void *iv,
  35         unsigned int iv_len,
  36         unsigned int tag_len
  37 )
  38 {
  39         assert(desc);
  40         assert(desc->create);
  41
  42         assert(key);
  43         assert(key_len);
  44         assert(key_len <= kripto_authstream_maxkey(desc));
  45         assert(iv_len <= kripto_authstream_maxiv(desc));
  46         if(iv_len) assert(iv);
  47         assert(tag_len <= kripto_authstream_maxtag(desc));
  48
  49         return desc->create(desc, rounds, key, key_len, iv, iv_len, tag_len);
  50 }
  51
  52 kripto_authstream *kripto_authstream_recreate
  53 (
  54         kripto_authstream *s,
  55         unsigned int rounds,
  56         const void *key,
  57         unsigned int key_len,
  58         const void *iv,
  59         unsigned int iv_len,
  60         unsigned int tag_len
  61 )
  62 {
  63         assert(s);
  64         assert(s->desc);
  65         assert(s->desc->recreate);
  66
  67         assert(key);
  68         assert(key_len);
  69         assert(key_len <= kripto_authstream_maxkey(s->desc));
  70         assert(iv_len <= kripto_authstream_maxiv(s->desc));
  71         if(iv_len) assert(iv);
  72         assert(tag_len <= kripto_authstream_maxtag(s->desc));
  73
  74         return s->desc->recreate(s, rounds, key, key_len, iv, iv_len, tag_len);
  75 }
  76
  77 void kripto_authstream_encrypt
  78 (
  79         kripto_authstream *s,
  80         const void *pt,
  81         void *ct,
  82         size_t len
  83 )
  84 {
  85         assert(s);
  86         assert(s->desc);
  87         assert(s->desc->encrypt);
  88         assert(len % kripto_authstream_multof(s->desc) == 0);
  89
  90         s->desc->encrypt(s, pt, ct, len);
  91 }
  92
  93 void kripto_authstream_decrypt
  94 (
  95         kripto_authstream *s,
  96         const void *ct,
  97         void *pt,
  98         size_t len
  99 )
 100 {
 101         assert(s);
 102         assert(s->desc);
 103         assert(s->desc->decrypt);
 104         assert(len % kripto_authstream_multof(s->desc) == 0);
 105
 106         s->desc->decrypt(s, ct, pt, len);
 107 }
 108
 109 void kripto_authstream_header
 110 (
 111         kripto_authstream *s,
 112         const void *header,
 113         size_t len
 114 )
 115 {
 116         assert(s);
 117         assert(s->desc);
 118         assert(s->desc->header);
 119
 120         s->desc->header(s, header, len);
 121 }
 122
 123 void kripto_authstream_tag
 124 (
 125         kripto_authstream *s,
 126         void *tag,
 127         unsigned int len
 128 )
 129 {
 130         assert(s);
 131         assert(s->desc);
 132         assert(s->desc->tag);
 133
 134         s->desc->tag(s, tag, len);
 135 }
 136
 137 void kripto_authstream_destroy(kripto_authstream *s)
 138 {
 139         assert(s);
 140         assert(s->desc);
 141         assert(s->desc->destroy);
 142
 143         s->desc->destroy(s);
 144 }
 145
 146 unsigned int kripto_authstream_multof(const kripto_authstream *s)
 147 {
 148         assert(s);
 149         assert(s->multof);
 150
 151         return s->multof;
 152 }
 153
 154 const kripto_authstream_desc *kripto_authstream_getdesc(const kripto_authstream *s)
 155 {
 156         assert(s);
 157         assert(s->desc);
 158
 159         return s->desc;
 160 }
 161
 162 unsigned int kripto_authstream_maxkey(const kripto_authstream_desc *desc)
 163 {
 164         assert(desc);
 165         assert(desc->maxkey);
 166
 167         return desc->maxkey;
 168 }
 169
 170 unsigned int kripto_authstream_maxiv(const kripto_authstream_desc *desc)
 171 {
 172         assert(desc);
 173
 174         return desc->maxiv;
 175 }
 176
 177 unsigned int kripto_authstream_maxtag(const kripto_authstream_desc *desc)
 178 {
 179         assert(desc);
 180
 181         return desc->maxtag;
 182 }