lib/stream.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 #include <stdint.h>
  16
  17 #include <kripto/stream.h>
  18 #include <kripto/desc/stream.h>
  19
  20 struct kripto_stream
  21 {
  22         const kripto_stream_desc *desc;
  23         unsigned int multof;
  24 };
  25
  26 kripto_stream *kripto_stream_create
  27 (
  28         const kripto_stream_desc *desc,
  29         unsigned int rounds,
  30         const void *key,
  31         unsigned int key_len,
  32         const void *iv,
  33         unsigned int iv_len
  34 )
  35 {
  36         assert(desc);
  37         assert(desc->create);
  38
  39         assert(key);
  40         assert(key_len);
  41         assert(key_len <= kripto_stream_maxkey(desc));
  42         assert(iv_len <= kripto_stream_maxiv(desc));
  43         if(iv_len) assert(iv);
  44
  45         return desc->create(desc, rounds, key, key_len, iv, iv_len);
  46 }
  47
  48 kripto_stream *kripto_stream_recreate
  49 (
  50         kripto_stream *s,
  51         unsigned int rounds,
  52         const void *key,
  53         unsigned int key_len,
  54         const void *iv,
  55         unsigned int iv_len
  56 )
  57 {
  58         assert(s);
  59         assert(s->desc);
  60         assert(s->desc->recreate);
  61
  62         assert(key);
  63         assert(key_len);
  64         assert(key_len <= kripto_stream_maxkey(s->desc));
  65         assert(iv_len <= kripto_stream_maxiv(s->desc));
  66         if(iv_len) assert(iv);
  67
  68         return s->desc->recreate(s, rounds, key, key_len, iv, iv_len);
  69 }
  70
  71 void kripto_stream_encrypt
  72 (
  73         kripto_stream *s,
  74         const void *pt,
  75         void *ct,
  76         size_t len
  77 )
  78 {
  79         assert(s);
  80         assert(s->desc);
  81         assert(s->desc->encrypt);
  82         assert(len % kripto_stream_multof(s) == 0);
  83
  84         s->desc->encrypt(s, pt, ct, len);
  85 }
  86
  87 void kripto_stream_decrypt
  88 (
  89         kripto_stream *s,
  90         const void *ct,
  91         void *pt,
  92         size_t len
  93 )
  94 {
  95         assert(s);
  96         assert(s->desc);
  97         assert(s->desc->decrypt);
  98         assert(len % kripto_stream_multof(s) == 0);
  99
 100         s->desc->decrypt(s, ct, pt, len);
 101 }
 102
 103 void kripto_stream_prng
 104 (
 105         kripto_stream *s,
 106         void *out,
 107         size_t len
 108 )
 109 {
 110         assert(s);
 111         assert(s->desc);
 112         assert(s->desc->prng);
 113
 114         s->desc->prng(s, out, len);
 115 }
 116
 117 void kripto_stream_destroy(kripto_stream *s)
 118 {
 119         assert(s);
 120         assert(s->desc);
 121         assert(s->desc->destroy);
 122
 123         s->desc->destroy(s);
 124 }
 125
 126 unsigned int kripto_stream_multof(const kripto_stream *s)
 127 {
 128         assert(s);
 129         assert(s->multof);
 130
 131         return s->multof;
 132 }
 133
 134 const kripto_stream_desc *kripto_stream_getdesc(const kripto_stream *s)
 135 {
 136         assert(s);
 137         assert(s->desc);
 138
 139         return s->desc;
 140 }
 141
 142 unsigned int kripto_stream_maxkey(const kripto_stream_desc *desc)
 143 {
 144         assert(desc);
 145         assert(desc->maxkey);
 146
 147         return desc->maxkey;
 148 }
 149
 150 unsigned int kripto_stream_maxiv(const kripto_stream_desc *desc)
 151 {
 152         assert(desc);
 153
 154         return desc->maxiv;
 155 }