lib/mode/ctr.c

   1 /*
   2  * Copyright (C) 2011 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
  19 #include <kripto/macros.h>
  20 #include <kripto/memwipe.h>
  21 #include <kripto/block.h>
  22 #include <kripto/mode.h>
  23 #include <kripto/mode_desc.h>
  24 #include <kripto/stream.h>
  25 #include <kripto/stream_desc.h>
  26
  27 #include <kripto/mode/ctr.h>
  28
  29 struct kripto_stream
  30 {
  31         kripto_stream_desc *desc;
  32         const kripto_block *block;
  33         unsigned int block_size;
  34         uint8_t *x;
  35         uint8_t *buf;
  36         unsigned int used;
  37 };
  38
  39 static size_t ctr_crypt
  40 (
  41         kripto_stream *s,
  42         const void *in,
  43         void *out,
  44         const size_t len
  45 )
  46 {
  47         size_t i;
  48         unsigned int n;
  49
  50         for(i = 0; i < len; i++)
  51         {
  52                 if(s->used == s->block_size)
  53                 {
  54                         kripto_block_encrypt(s->block, s->x, s->buf);
  55                         s->used = 0;
  56
  57                         for(n = s->block_size - 1; n; n--)
  58                                 if(++s->x[n]) break;
  59                 }
  60
  61                 U8(out)[i] = CU8(in)[i] ^ s->buf[s->used++];
  62         }
  63
  64         return i;
  65 }
  66
  67 static size_t ctr_prng
  68 (
  69         kripto_stream *s,
  70         void *out,
  71         const size_t len
  72 )
  73 {
  74         size_t i;
  75         unsigned int n;
  76
  77         for(i = 0; i < len; i++)
  78         {
  79                 if(s->used == s->block_size)
  80                 {
  81                         kripto_block_encrypt(s->block, s->x, s->buf);
  82                         s->used = 0;
  83
  84                         for(n = s->block_size - 1; n; n--)
  85                                 if(++s->x[n]) break;
  86                 }
  87
  88                 U8(out)[i] = s->buf[s->used++];
  89         }
  90
  91         return i;
  92 }
  93
  94 static void ctr_destroy(kripto_stream *s)
  95 {
  96         kripto_memwipe(s, sizeof(kripto_stream)
  97                 + (s->block_size << 1)
  98                 + sizeof(kripto_stream_desc)
  99         );
 100
 101         free(s);
 102 }
 103
 104 static kripto_stream *ctr_create
 105 (
 106         const kripto_block *block,
 107         const void *iv,
 108         const unsigned int iv_len
 109 )
 110 {
 111         kripto_stream *s;
 112         kripto_block_desc *b;
 113         struct kripto_stream_desc *stream;
 114
 115         b = kripto_block_get_desc(block);
 116
 117         s = malloc(sizeof(kripto_stream)
 118                 + (kripto_block_size(b) << 1)
 119                 + sizeof(kripto_stream_desc)
 120         );
 121         if(!s) return 0;
 122
 123         s->block_size = kripto_block_size(b);
 124
 125         stream = (struct kripto_stream_desc *)
 126                 ((uint8_t *)s + sizeof(kripto_stream));
 127
 128         s->x = (uint8_t *)stream + sizeof(kripto_stream_desc);
 129         s->buf = s->x + s->block_size;
 130
 131         stream->encrypt = &ctr_crypt;
 132         stream->decrypt = &ctr_crypt;
 133         stream->prng = &ctr_prng;
 134         stream->create = 0;
 135         stream->destroy = &ctr_destroy;
 136         stream->max_key = kripto_block_max_key(b);
 137         stream->max_iv = s->block_size;
 138
 139         s->desc = stream;
 140
 141         if(iv_len) memcpy(s->x, iv, iv_len);
 142         memset(s->x + iv_len, 0, s->block_size - iv_len);
 143
 144         s->used = s->block_size;
 145         s->block = block;
 146
 147         return s;
 148 }
 149
 150 static const struct kripto_mode_desc ctr =
 151 {
 152         &ctr_create,
 153         &kripto_block_size
 154 };
 155
 156 kripto_mode_desc *const kripto_mode_ctr = &ctr;