rabbit/rabbit_c.c

   1 /* rabbit_c.c */
   2 /*
   3     This file is part of the ARM-Crypto-Lib.
   4     Copyright (C) 2006-2011 Daniel Otte (daniel.otte@rub.de)
   5
   6     This program is free software: you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation, either version 3 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include <string.h>
  21 #include <stdint.h>
  22 #include "rabbit.h"
  23
  24 #ifndef ESTREAM
  25 #define ESTREAM 0
  26 #endif
  27
  28 /*
  29 void dump_ctx(rabbit_ctx_t* ctx){
  30         uint8_t i=0;
  31         cli_putstr_P(PSTR("\r\n --- ctx dump ---\r\n  b = "));
  32         cli_hexdump_byte(ctx->carry);
  33         do{
  34                 if((i&3)==0){
  35                         cli_putstr_P(PSTR("\r\n"));
  36                 }
  37                 cli_putstr_P(PSTR("  X"));
  38                 cli_hexdump_byte(i);
  39                 cli_putstr_P(PSTR(" = 0x"));
  40                 cli_hexdump_rev(&(ctx->x[i]), 4);
  41         }while(++i<8);
  42         i=0;
  43         do{
  44                 if((i&3)==0){
  45                         cli_putstr_P(PSTR("\r\n"));
  46                 }
  47                 cli_putstr_P(PSTR("  C"));
  48                 cli_hexdump_byte(i);
  49                 cli_putstr_P(PSTR(" = 0x"));
  50                 cli_hexdump_rev(&(ctx->c[i]), 4);
  51         }while(++i<8);
  52 }
  53 */
  54
  55 static
  56 const uint32_t c_const[8] = {
  57                 0x4D34D34D, 0xD34D34D3,
  58                 0x34D34D34, 0x4D34D34D,
  59                 0xD34D34D3, 0x34D34D34,
  60                 0x4D34D34D, 0xD34D34D3
  61 };
  62
  63 static
  64 void gen_g(uint32_t* dest, rabbit_ctx_t* ctx){
  65         uint8_t i=0;
  66         uint64_t a;
  67         uint32_t t, *x, *c;
  68         x = ctx->x;
  69         c = ctx->c;
  70         do{
  71                 t = *x++ + *c++;
  72                 a = ((uint64_t)t)*((uint64_t)t);
  73                 dest[i] = (uint32_t)(a^(a>>32));
  74         }while(++i<8);
  75 }
  76
  77 static
  78 void update_c(rabbit_ctx_t* ctx){
  79         uint8_t i=0;
  80         uint64_t a;
  81         uint32_t *c;
  82         const uint32_t *con;
  83         c = ctx->c;
  84         con = c_const;
  85         a = ctx->carry;
  86         do{
  87                 a += *c;
  88                 a += *con++;
  89                 *c++ = (uint32_t)a;
  90                 a >>= 32;
  91         }while(++i<8);
  92         ctx->carry = a?1:0;
  93 }
  94
  95 #define ROT16(a) (((a)<<16) | ((a)>>16))
  96 #define ROT8(a)  (((a)<< 8) | ((a)>>24))
  97
  98 static
  99 void step(rabbit_ctx_t* ctx){
 100         uint32_t g[8];
 101         uint8_t i=0;
 102         update_c(ctx);
 103         gen_g(g, ctx);
 104         memcpy(ctx->x, g, 8*4);
 105         do{
 106                 ctx->x[i] += ROT16(g[(i+8-1)%8]) + ROT16(g[(i+8-2)%8]);
 107                 ++i;
 108                 ctx->x[i] += ROT8(g[(i+8-1)%8]) + g[(i+8-2)%8];
 109         }while(++i<8);
 110 }
 111
 112 static
 113 void keysetup(rabbit_ctx_t* ctx, const void* key){
 114         uint16_t *x, *c;
 115         uint8_t i=0;
 116         x = (uint16_t*)(ctx->x);
 117         c = (uint16_t*)(ctx->c);
 118         ctx->carry = 0;
 119         do{
 120                 *x++ = ((uint16_t*)key)[i];
 121                 *x++ = ((uint16_t*)key)[(i+1)%8];
 122                 *c++ = ((uint16_t*)key)[(i+5)%8];
 123                 *c++ = ((uint16_t*)key)[(i+4)%8];
 124                 ++i;
 125                 *x++ = ((uint16_t*)key)[(i+4)%8];
 126                 *x++ = ((uint16_t*)key)[(i+5)%8];
 127                 *c++ = ((uint16_t*)key)[(i+1)%8];
 128                 *c++ = ((uint16_t*)key)[i];
 129         }while(++i<8);
 130         i=0;
 131         do{
 132                 step(ctx);
 133         }while(++i<4);
 134         i=0;
 135         do{
 136                 ctx->c[i] ^= ctx->x[(i+4)%8];
 137         }while(++i<8);
 138 }
 139
 140 static
 141 void ivsetup(rabbit_ctx_t* ctx, const void* iv){
 142         uint8_t i;
 143         uint32_t t;
 144         uint8_t t_iv[8];
 145         i=0;
 146 #if ESTREAM
 147         memcpy(t_iv, iv, 8);
 148 #else
 149         do{
 150                 t_iv[i] = ((uint8_t*)iv)[7-i];
 151                 t_iv[7-i] = ((uint8_t*)iv)[i];
 152         }while(++i<4);
 153 #endif
 154         ctx->c[0] ^= *((uint32_t*)t_iv);
 155         ctx->c[4] ^= *((uint32_t*)t_iv);
 156         ctx->c[2] ^= ((uint32_t*)t_iv)[1];
 157         ctx->c[6] ^= ((uint32_t*)t_iv)[1];
 158         t = (( (uint32_t)((uint16_t*)t_iv)[3])<<16) | (((uint16_t*)t_iv)[1]);
 159         ctx->c[1] ^= t;
 160         ctx->c[5] ^= t;
 161         t = (( (uint32_t)((uint16_t*)t_iv)[2])<<16) | (((uint16_t*)t_iv)[0]);
 162         ctx->c[3] ^= t;
 163         ctx->c[7] ^= t;
 164         i=4;
 165         do{
 166                 step(ctx);
 167         }while(--i);
 168 }
 169
 170 static
 171 void extract(rabbit_ctx_t* ctx){
 172         int8_t i=0;
 173         uint8_t *t;
 174         uint16_t v;
 175         t = ctx->buffer;
 176         i=6;
 177         do{
 178                 v =   ((uint16_t*)(ctx->x))[(2*(i+ 8)+1)%16]
 179                     ^ ((uint16_t*)(ctx->x))[(2*(i+11)+0)%16];
 180                 *t++ = v>>8;
 181                 *t++ = (uint8_t)v;
 182                 v =   ((uint16_t*)(ctx->x))[(2*(i+ 8)+0)%16]
 183                     ^ ((uint16_t*)(ctx->x))[(2*(i+13)+1)%16];
 184                 *t++ = v>>8;
 185                 *t++ = (uint8_t)v;
 186
 187                 i-=2;
 188         }while(i>=0);
 189 #if ESTREAM
 190         uint8_t x;
 191         i=0;
 192         do{
 193                 x = ctx->buffer[i];
 194                 ctx->buffer[i] = ctx->buffer[15-i];
 195                 ctx->buffer[15-i] = x;
 196         }while(++i<8);
 197 #endif
 198 }
 199
 200 static const uint8_t key80_pad[] = { 0xDE, 0x05, 0x6E, 0xAC, 0x8A, 0x11 };
 201
 202 void rabbit_init(const void* key, uint16_t keysize_b,
 203                   const void* iv,
 204                   rabbit_ctx_t* ctx){
 205         uint8_t t_key[16];
 206         if(keysize_b==80){
 207                 memcpy(t_key, key, 10);
 208                 memcpy(t_key+10, key80_pad, 6);
 209         }else{
 210                 memcpy(t_key, key, 16);
 211         }
 212 #if !ESTREAM
 213         uint8_t i=0, t;
 214         do{
 215                 t = t_key[i];
 216                 t_key[i] = t_key[15-i];
 217                 t_key[15-i] = t;
 218         }while(++i<8);
 219 #endif
 220         keysetup(ctx, t_key);
 221
 222
 223         if(iv){
 224                 ivsetup(ctx, iv);
 225         }
 226         extract(ctx);
 227         ctx->buffer_idx = 16;
 228 }
 229
 230 uint8_t rabbit_gen(rabbit_ctx_t* ctx){
 231         if(ctx->buffer_idx==16){
 232                 step(ctx);
 233                 extract(ctx);
 234                 ctx->buffer_idx = 0;
 235         }
 236         return ctx->buffer[ctx->buffer_idx++];
 237 }