grain.c

   1 /**
   2  *
   3  * author: Daniel Otte
   4  * email:  daniel.otte@rub.de
   5  * license: GPLv3
   6  *
   7  */
   8
   9
  10 #include <stdint.h>
  11 #include <string.h>
  12 #include <avr/pgmspace.h>
  13 #include "grain.h"
  14
  15
  16 #define GRAIN_REVERSEKEY
  17
  18 /* s0, s1, s2, ..., s78, s79 */
  19 #define S(i) ((ctx->lfsr[9-((i)/8)])>>(7-((i)%8)))
  20 /* b0, b1, b2, ..., b78, b79 */
  21 #define B(i) ((ctx->nfsr[9-((i)/8)])>>(7-((i)%8)))
  22 #define _B(i) (((ctx->nfsr[9-((i)/8)])>>(7-((i)%8)))&1)
  23
  24
  25 uint8_t h_lut[4] PROGMEM = {0x4C, 0xB6, 0xD3, 0x26};
  26
  27 #ifdef GRAIN_BADOPTIMISATION
  28 uint8_t g_lut[128] PROGMEM = {
  29         0xF0, 0xA5, 0x0F, 0x5A, 0x0F, 0x5A, 0xF0, 0xA5, 0x0F, 0x5A, 0xF0, 0xA5, 0xF0, 0x5A, 0x0F, 0x0F,
  30         0xC3, 0x96, 0x3C, 0x69, 0x3C, 0x69, 0xC3, 0x96, 0x9C, 0xC9, 0x63, 0x36, 0x63, 0xC9, 0x9C, 0x9C,
  31         0x0F, 0x5A, 0x0F, 0x5A, 0xF0, 0xA5, 0xF0, 0x5A, 0xF0, 0xA5, 0xF0, 0xA5, 0x0F, 0xA5, 0x0F, 0xF0,
  32         0x3C, 0x69, 0x3C, 0x69, 0xC3, 0x96, 0xC3, 0x69, 0x63, 0x36, 0x63, 0x36, 0x9C, 0x36, 0x9C, 0x63,
  33         0x0F, 0xD2, 0xF0, 0x2D, 0xF0, 0x2D, 0x0F, 0xD2, 0xF0, 0x2D, 0x0F, 0xD2, 0x0F, 0x2D, 0xF0, 0x78,
  34         0x3C, 0xE1, 0xC3, 0x1E, 0xC3, 0x1E, 0x3C, 0xE1, 0x63, 0xBE, 0x9C, 0x41, 0x9C, 0xBE, 0x63, 0xEB,
  35         0x00, 0xDD, 0x00, 0xDD, 0xFF, 0x22, 0xFF, 0xDD, 0xFF, 0x22, 0xFF, 0x22, 0x00, 0x22, 0xF0, 0x87,
  36         0xF3, 0x2E, 0xF3, 0x2E, 0x0C, 0xD1, 0x0C, 0x2E, 0xAC, 0x71, 0xAC, 0x71, 0x53, 0x71, 0xA3, 0xD4  };
  37 #endif
  38
  39 uint8_t grain_enc(grain_ctx_t* ctx){
  40         uint8_t s80, s0, c1, c2;
  41         uint8_t i;
  42         /* clock the LFSR */
  43         s0=S(0);
  44         s80 =S(62) ^ S(51) ^ S(38) ^ S(23) ^ S(13) ^ s0;
  45         s80 &= 1;
  46         c1 = s80;
  47         for(i=0; i<10; ++i){
  48                 c2 = (ctx->lfsr[i])>>7;
  49                 ctx->lfsr[i] = ((ctx->lfsr[i])<<1) | c1;
  50                 c1 = c2;
  51         }
  52         /* clock the NFSR */
  53         uint8_t b80;
  54 /*      778 Byte in this variant / 617 clks enc_time */
  55 #ifndef GRAIN_BADOPTIMISATION
  56     uint8_t a,b,d,e;
  57         b80 = B(62) ^ B(60) ^ B(52) ^ B(45) ^
  58               B(37) ^ B(33) ^ B(28) ^ B(21) ^
  59               B(14) ^ B( 9) ^ B( 0) ^ s0;
  60         b80 ^= (a = B(63) & B(60));
  61         b80 ^= (b = B(37) & B(33));
  62         b80 ^= B(15) & B( 9); // c
  63         b80 ^= (d = B(60) & B(52) & B(45));
  64         b80 ^= (e = B(33) & B(28) & B(21));
  65         b80 ^= B(63) & B(45) & B(28) & B(9); // f
  66         /* -- */
  67         b80 ^= b & B(60) & B(52); // g
  68         b80 ^= a & B(21) & B(15); // h
  69         b80 ^= d & B(63) & B(37); // i
  70         b80 ^= e & B(15) & B( 9); // j
  71         b80 ^= e & B(52) & B(45) & B(37); // k
  72 #else
  73         /* let's reorder the bits */
  74         uint16_t x;
  75
  76 /*
  77         x  = _B(21); x<<=1;
  78         x |= _B(33); x<<=1;
  79         x |= _B(9) ; x<<=1;
  80         x |= _B(45); x<<=1;
  81         x |= _B(52); x<<=1;
  82         x |= _B(37); x<<=1;
  83         x |= _B(60); x<<=1;
  84         x |= _B(28); x<<=1;
  85         x |= _B(15); x<<=1;
  86         x |= _B(63);
  87 */
  88         x  = ((ctx->nfsr[8])&0x41)<<1; // B15 & B09
  89         x |= ((ctx->nfsr[2])&0x09);    // B63 & B60
  90 //      x |= ((ctx->nfsr[4])&0x04)<<4; // B45
  91         x |= (((ctx->nfsr[5])&0x44) |
  92               ((ctx->nfsr[3])&0x08) |
  93               (((((ctx->nfsr[7])&0x04)<<3) |((ctx->nfsr[4])&0x04))<<2) )<<2; // B37 & B33
  94 //      x |= ((ctx->nfsr[3])&0x08)<<2; // B52
  95         x |= ((ctx->nfsr[6])&0x08)>>1; // B28
  96 //      x |= ((ctx->nfsr[7])&0x04)<<7; // B21
  97
  98
  99         b80 = pgm_read_byte(g_lut+(x/8))>>(x%8);
 100         b80 ^= s0 ^ B(62) ^ B(14) ^ B(0);
 101 #endif
 102         c1 = b80 & 1;
 103         for(i=0; i<10; ++i){
 104                 c2 = (ctx->nfsr[i])>>7;
 105                 ctx->nfsr[i] = ((ctx->nfsr[i])<<1) | c1;
 106                 c1 = c2;
 107         }
 108         /* now the h function */
 109         uint8_t h;
 110         i = (S(2)&1) |
 111             ((S(24)&1) << 1) |
 112             ((S(45)&1) << 2) |
 113             ((S(63)&1) << 3) |
 114             ((B(62)&1) << 4);
 115
 116         h = (pgm_read_byte(h_lut+(i/8)))>>(i%8);
 117
 118         h ^= B(0) ^ B(1) ^ B(3) ^ B(9) ^ B(30) ^ B(42) ^ B(55);
 119         return h&1;
 120 }
 121
 122 #ifdef GRAIN_REVERSEKEY
 123
 124 static
 125 uint8_t reverse_bits(uint8_t a){
 126         uint8_t lut[16] = {
 127                 0x0, 0x8, 0x4, 0xC,   /* 0000 1000 0100 1100 */
 128                 0x2, 0xA, 0x6, 0xE,   /* 0010 1010 0110 1110 */
 129                 0x1, 0x9, 0x5, 0xD,   /* 0001 1001 0101 1101 */
 130                 0x3, 0xB, 0x7, 0xF }; /* 0011 1011 0111 1111 */
 131         uint8_t x;
 132         x = ((lut[a&0xf]) << 4) | lut[a>>4];
 133         return x;
 134 }
 135 #else
 136
 137 #define reverse_bits(a) (a)
 138
 139 #endif
 140
 141 void grain_init(const void* key, const void* iv, grain_ctx_t* ctx){
 142         uint8_t i,t;
 143
 144         /* load the 80bit key */
 145         for(i=0; i<10; ++i){
 146                 ctx->nfsr[9-i] = reverse_bits(((uint8_t*)key)[i]);
 147         }
 148         /* load the 64bit iv */
 149         for(i=0; i<8; ++i){
 150                 ctx->lfsr[9-i] = reverse_bits(((uint8_t*)iv)[i]);
 151         }
 152         /* set the other bits of iv to 1 */
 153         ctx->lfsr[0] = ctx->lfsr[1] = 0xFF;
 154
 155         /* run it 160 times */
 156         for(i=0; i<160; ++i){
 157                 t = grain_enc(ctx);
 158                 (ctx->lfsr[0]) ^= t;
 159                 (ctx->nfsr[0]) ^= t;
 160         }
 161 }
 162
 163
 164
 165
 166
 167