lib/stream/keccak1600.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 <stdint.h>
  16 #include <stdlib.h>
  17 #include <limits.h>
  18
  19 #include <kripto/cast.h>
  20 #include <kripto/memwipe.h>
  21 #include <kripto/hash.h>
  22 #include <kripto/hash/keccak1600.h>
  23 #include <kripto/stream.h>
  24 #include <kripto/desc/stream.h>
  25
  26 #include <kripto/stream/keccak1600.h>
  27
  28 struct kripto_stream
  29 {
  30         const kripto_stream_desc *stream;
  31         kripto_hash *hash;
  32 };
  33
  34 static kripto_stream *keccak1600_recreate
  35 (
  36         kripto_stream *s,
  37         unsigned int r,
  38         const void *key,
  39         unsigned int key_len,
  40         const void *iv,
  41         unsigned int iv_len
  42 )
  43 {
  44         (void)kripto_hash_recreate(s->hash, r, key_len);
  45
  46         kripto_hash_input(s->hash, key, key_len);
  47         kripto_hash_input(s->hash, iv, iv_len);
  48
  49         return s;
  50 }
  51
  52 static void keccak1600_crypt
  53 (
  54         kripto_stream *s,
  55         const void *in,
  56         void *out,
  57         size_t len
  58 )
  59 {
  60         size_t i;
  61         uint8_t buf[64];
  62         unsigned int n;
  63
  64         for(i = 0, n = 64; i < len; i++)
  65         {
  66                 if(n == 64)
  67                 {
  68                         if(len - i < 64)
  69                                 kripto_hash_output(s->hash, buf, len - i);
  70                         else
  71                                 kripto_hash_output(s->hash, buf, 64);
  72
  73                         n = 0;
  74                 }
  75
  76                 U8(out)[i] = CU8(in)[i] ^ buf[n++];
  77         }
  78
  79         kripto_memwipe(buf, 64);
  80 }
  81
  82 static void keccak1600_prng(kripto_stream *s, void *out, size_t len)
  83 {
  84         kripto_hash_output(s->hash, out, len);
  85 }
  86
  87 static kripto_stream *keccak1600_create
  88 (
  89         const kripto_stream_desc *desc,
  90         unsigned int r,
  91         const void *key,
  92         unsigned int key_len,
  93         const void *iv,
  94         unsigned int iv_len
  95 )
  96 {
  97         kripto_stream *s;
  98
  99         (void)desc;
 100
 101         s = malloc(sizeof(kripto_stream));
 102         if(!s) return 0;
 103
 104         s->stream = kripto_stream_keccak1600;
 105
 106         s->hash = kripto_hash_create(kripto_hash_keccak1600, r, key_len);
 107         if(!s->hash)
 108         {
 109                 free(s);
 110                 return 0;
 111         }
 112
 113         kripto_hash_input(s->hash, key, key_len);
 114         kripto_hash_input(s->hash, iv, iv_len);
 115
 116         return s;
 117 }
 118
 119 static void keccak1600_destroy(kripto_stream *s)
 120 {
 121         kripto_hash_destroy(s->hash);
 122         free(s);
 123 }
 124
 125 static const kripto_stream_desc keccak1600 =
 126 {
 127         &keccak1600_create,
 128         &keccak1600_recreate,
 129         &keccak1600_crypt,
 130         &keccak1600_crypt,
 131         &keccak1600_prng,
 132         &keccak1600_destroy,
 133         1,
 134         99, /* max key */
 135         UINT_MAX /* max iv */
 136 };
 137
 138 const kripto_stream_desc *const kripto_stream_keccak1600 = &keccak1600;