lib/mode/ecb.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 <string.h>
  17 #include <stdlib.h>
  18 #include <assert.h>
  19
  20 #include <kripto/macros.h>
  21 #include <kripto/memwipe.h>
  22 #include <kripto/block.h>
  23 #include <kripto/mode.h>
  24 #include <kripto/mode_desc.h>
  25 #include <kripto/stream.h>
  26 #include <kripto/stream_desc.h>
  27
  28 #include <kripto/mode/ecb.h>
  29
  30 struct kripto_stream
  31 {
  32         kripto_stream_desc *desc;
  33         const kripto_block *block;
  34         unsigned int block_size;
  35 };
  36
  37 static size_t ecb_encrypt
  38 (
  39         kripto_stream *s,
  40         const void *pt,
  41         void *ct,
  42         const size_t len
  43 )
  44 {
  45         size_t i;
  46
  47         if(len & (s->block_size - 1)) return 0;
  48
  49         for(i = 0; i < len; i += s->block_size)
  50                 kripto_block_encrypt(s->block, CU8(pt) + i, U8(ct) + i);
  51
  52         return i;
  53 }
  54
  55 static size_t ecb_decrypt
  56 (
  57         kripto_stream *s,
  58         const void *ct,
  59         void *pt,
  60         const size_t len
  61 )
  62 {
  63         size_t i;
  64
  65         if(len & (s->block_size - 1)) return 0;
  66
  67         for(i = 0; i < len; i += s->block_size)
  68                 kripto_block_decrypt(s->block, CU8(ct) + i, U8(pt) + i);
  69
  70         return i;
  71 }
  72
  73 static void ecb_destroy(kripto_stream *s)
  74 {
  75         kripto_memwipe(s, sizeof(kripto_stream)
  76                 + s->block_size
  77                 + sizeof(kripto_stream_desc)
  78         );
  79         free(s);
  80 }
  81
  82 static unsigned int ecb_max_iv(kripto_block_desc *desc)
  83 {
  84         (void)desc;
  85
  86         return 0;
  87 }
  88
  89 static kripto_stream *ecb_create
  90 (
  91         const kripto_block *block,
  92         const void *iv,
  93         const unsigned int iv_len
  94 )
  95 {
  96         kripto_stream *s;
  97         kripto_block_desc *b;
  98         struct kripto_stream_desc *stream;
  99
 100         (void)iv;
 101         (void)iv_len;
 102         assert(block);
 103         assert(!iv_len);
 104
 105         b = kripto_block_get_desc(block);
 106
 107         s = malloc(sizeof(kripto_stream)
 108                 + sizeof(kripto_stream_desc)
 109         );
 110
 111         s->block_size = kripto_block_size(b);
 112
 113         stream = (struct kripto_stream_desc *)
 114                 ((uint8_t *)s + sizeof(kripto_stream));
 115
 116         stream->encrypt = &ecb_encrypt;
 117         stream->decrypt = &ecb_decrypt;
 118         stream->prng = 0;
 119         stream->create = 0;
 120         stream->destroy = &ecb_destroy;
 121         stream->max_key = kripto_block_max_key(b);
 122         stream->max_iv = 0;
 123
 124         s->desc = stream;
 125         s->block = block;
 126
 127         return s;
 128 }
 129
 130 static const kripto_mode_desc ecb =
 131 {
 132         &ecb_create,
 133         &ecb_max_iv
 134 };
 135
 136 kripto_mode_desc *const kripto_mode_ecb = &ecb;