lib/stream/rc4.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 <stdlib.h>
  17 #include <limits.h>
  18 #include <assert.h>
  19
  20 #include <kripto/cast.h>
  21 #include <kripto/memwipe.h>
  22 #include <kripto/stream.h>
  23 #include <kripto/desc/stream.h>
  24
  25 #include <kripto/stream/rc4.h>
  26 #include <kripto/stream/rc4i.h>
  27
  28 struct kripto_stream
  29 {
  30         const kripto_stream_desc *desc;
  31         uint8_t p[256];
  32         uint8_t i;
  33         uint8_t j;
  34 };
  35
  36 static void improved_setup
  37 (
  38         kripto_stream *s,
  39         const void *key,
  40         unsigned int key_len,
  41         const void *iv,
  42         unsigned int iv_len,
  43         unsigned int rounds
  44 )
  45 {
  46         unsigned int i;
  47         unsigned int j;
  48         uint8_t t;
  49
  50         s->i = s->j = 0;
  51
  52         for(i = 0; i < 256; i++) s->p[i] = i;
  53
  54         /* key */
  55         if(key && key_len)
  56         {
  57                 j = 0;
  58                 for(i = 0; i < rounds; i++)
  59                 {
  60                         s->j = s->j + s->p[s->i] + CU8(key)[j++];
  61                         if(j == key_len) j = 0;
  62
  63                         t = s->p[s->i];
  64                         s->p[s->i] = s->p[s->j];
  65                         s->p[s->j] = t;
  66
  67                         s->i++;
  68                 }
  69         }
  70
  71         /* iv */
  72         if(iv && iv_len)
  73         {
  74                 j = 0;
  75                 for(i = 0; i < rounds; i++)
  76                 {
  77                         s->j = s->j + s->p[s->i] + CU8(iv)[j++];
  78                         if(j == iv_len) j = 0;
  79
  80                         t = s->p[s->i];
  81                         s->p[s->i] = s->p[s->j];
  82                         s->p[s->j] = t;
  83
  84                         s->i++;
  85                 }
  86
  87                 /* key */
  88                 if(key && key_len)
  89                 {
  90                         j = 0;
  91                         for(i = 0; i < rounds; i++)
  92                         {
  93                                 s->j = s->j + s->p[s->i] + CU8(key)[j++];
  94                                 if(j == key_len) j = 0;
  95
  96                                 t = s->p[s->i];
  97                                 s->p[s->i] = s->p[s->j];
  98                                 s->p[s->j] = t;
  99
 100                                 s->i++;
 101                         }
 102                 }
 103         }
 104
 105         s->i = s->j; /* original RC4: s->i = s->j = 0; */
 106 }
 107
 108 static uint8_t rc4(kripto_stream *s)
 109 {
 110         uint8_t t;
 111
 112         s->i++;
 113         s->j = s->j + s->p[s->i];
 114
 115         t = s->p[s->i];
 116         s->p[s->i] = s->p[s->j];
 117         s->p[s->j] = t;
 118
 119         return(s->p[(uint8_t)(s->p[s->i] + s->p[s->j])]);
 120 }
 121
 122 static void rc4_crypt
 123 (
 124         kripto_stream *s,
 125         const void *in,
 126         void *out,
 127         size_t len
 128 )
 129 {
 130         size_t i;
 131
 132         for(i = 0; i < len; i++)
 133                 U8(out)[i] = CU8(in)[i] ^ rc4(s);
 134 }
 135
 136 static void rc4_prng
 137 (
 138         kripto_stream *s,
 139         void *out,
 140         size_t len
 141 )
 142 {
 143         size_t i;
 144
 145         for(i = 0; i < len; i++)
 146                 U8(out)[i] = rc4(s);
 147 }
 148
 149 static kripto_stream *rc4i_recreate
 150 (
 151         kripto_stream *s,
 152         unsigned int r,
 153         const void *key,
 154         unsigned int key_len,
 155         const void *iv,
 156         unsigned int iv_len
 157 )
 158 {
 159         unsigned int rounds = r;
 160
 161         assert(key_len + iv_len <= 256);
 162         if(!rounds) rounds = 512;
 163
 164         improved_setup(s, key, key_len, iv, iv_len, r);
 165
 166         return s;
 167 }
 168
 169 static kripto_stream *rc4_recreate
 170 (
 171         kripto_stream *s,
 172         unsigned int r,
 173         const void *key,
 174         unsigned int key_len,
 175         const void *iv,
 176         unsigned int iv_len
 177 )
 178 {
 179         unsigned int i;
 180
 181         assert(key_len + iv_len <= 256);
 182
 183         improved_setup(s, key, key_len, iv, iv_len, 256);
 184
 185         s->i = s->j = 0;
 186
 187         /* drop ? */
 188         for(i = 0; i < r; i++) (void)rc4(s);
 189
 190         return s;
 191 }
 192
 193 static kripto_stream *rc4i_create
 194 (
 195         const kripto_stream_desc *desc,
 196         unsigned int r,
 197         const void *key,
 198         unsigned int key_len,
 199         const void *iv,
 200         unsigned int iv_len
 201 )
 202 {
 203         kripto_stream *s;
 204
 205         (void)desc;
 206
 207         s = malloc(sizeof(kripto_stream));
 208         if(!s) return 0;
 209
 210         s->desc = kripto_stream_rc4i;
 211         (void)rc4i_recreate(s, r, key, key_len, iv, iv_len);
 212
 213         return s;
 214 }
 215
 216 static kripto_stream *rc4_create
 217 (
 218         const kripto_stream_desc *desc,
 219         unsigned int r,
 220         const void *key,
 221         unsigned int key_len,
 222         const void *iv,
 223         unsigned int iv_len
 224 )
 225 {
 226         kripto_stream *s;
 227         unsigned int i;
 228
 229         s = rc4i_create(desc, 256, key, key_len, iv, iv_len);
 230         if(!s) return 0;
 231
 232         s->desc = kripto_stream_rc4;
 233
 234         s->i = s->j = 0;
 235
 236         /* drop ? */
 237         for(i = 0; i < r; i++) (void)rc4(s);
 238
 239         return s;
 240 }
 241
 242 static void rc4_destroy(kripto_stream *s)
 243 {
 244         kripto_memwipe(s, sizeof(kripto_stream));
 245         free(s);
 246 }
 247
 248 /* RC4 */
 249 static const struct kripto_stream_desc rc4_desc =
 250 {
 251         &rc4_create,
 252         &rc4_recreate,
 253         &rc4_crypt,
 254         &rc4_crypt,
 255         &rc4_prng,
 256         &rc4_destroy,
 257         1,
 258         256, /* max key */
 259         0 /* max iv */
 260 };
 261
 262 const kripto_stream_desc *const kripto_stream_rc4 = &rc4_desc;
 263
 264 /* RC4i */
 265 static const struct kripto_stream_desc rc4i =
 266 {
 267         &rc4i_create,
 268         &rc4i_recreate,
 269         &rc4_crypt,
 270         &rc4_crypt,
 271         &rc4_prng,
 272         &rc4_destroy,
 273         1,
 274         256, /* max key */
 275         256 /* max iv */
 276 };
 277
 278 const kripto_stream_desc *const kripto_stream_rc4i = &rc4i;