mickey128/mickey128.c

   1 /* mickey128.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 <stdint.h>
  21 #include <string.h>
  22 #include "memxor.h"
  23 #include "mickey128.h"
  24
  25 /*
  26 RTAPS = { 0,4,5,  8,10,11,14  ,16,20,  25,30,  32,35,36,38,
  27          42,43,46,  50,51,53,54,55,  56,57,60,61,62,63,
  28          65,66,69,  73,74,76,79,  80,81,82,85,86,  90,91,92,95,
  29          97,100,101,  105,106,107,108,109,111,  112,113,115,116,117,
  30          127,  128,129,130,131,133,135,  136,137,140,142,  145,148,150,
  31          152,153,154,156,157 }
  32
  33          0011.0001  0100.1101  0001.0001  0100.0010  0101.1001
  34          0100.1100  1110.1100  1111.0011
  35          0010.0110  1001.0110  0110.0111  1001.1100
  36          0011.0010  1011.1110  0011.1011
  37          1000.0000  1010.1111  0101.0011  0101.0010
  38          0011.0111
  39
  40          1000110010110010100010000100001010011010001100100011011111001111011001
  41          0001101001111001100011100101001100011111011101110000000001111101011100
  42          101001001010111011
  43
  44          1000.1100 1011.0010 1000.1000 0100.0010 1001.1010 0011.0010
  45          0011.0111 1100.1111 0110.0100 0110.1001 1110.0110 0011.1001
  46          0100.1100 0111.1101 1101.1100 0000.0001 1111.0101 1100.1010
  47          0100.1010 1110.11
  48 */
  49
  50 uint8_t rtaps[] = {
  51         0x31, 0x4D, 0x11, 0x42,
  52         0x59, 0x4C, 0xEC, 0xF3,
  53         0x26, 0x96, 0x67, 0x9C,
  54         0x32, 0xBE, 0x3B, 0x80,
  55         0xAF, 0x53, 0x52, 0x37
  56 };
  57
  58 #define SHL0(a) c1=((a)>>7); (a)=(((a)<<1)|c0)
  59 #define SHL1(a) c0=((a)>>7); (a)=(((a)<<1)|c1)
  60
  61 #define SHLX0(a) c1=((a)>>7); (a)^=(((a)<<1)|c0)
  62 #define SHLX1(a) c0=((a)>>7); (a)^=(((a)<<1)|c1)
  63
  64 static
  65 void clock_r(uint8_t* r, uint8_t ibit, uint8_t cbit){
  66         uint8_t i,c0=0,c1=0; /* carry */
  67         ibit ^= ((r[159/8])>>(159%8))&1; /* ibit is now the same as feedback_bit */
  68         if(cbit){
  69                 for(i=0; i<10; ++i){
  70                         SHLX0(r[2*i+0]);
  71                         SHLX1(r[2*i+1]);
  72                 }
  73         } else {
  74                 for(i=0; i<10; ++i){
  75                         SHL0(r[2*i+0]);
  76                         SHL1(r[2*i+1]);
  77                 }
  78         }
  79         if(ibit){
  80                 memxor(r, rtaps, 20);
  81         }
  82 }
  83
  84 /* comp0 (filling spaces with zero) (one at each side)
  85  * 0101.1110 1111.0010 1101.0110 0101.1101
  86  * 0101.0101 0000.1001 0010.0110 0111.1001
  87  * 0110.0010 0111.0000 0000.0000 0111.1001
  88  * 0011.0001 1101.1001 1010.1111 0011.0111
  89  * 1011.1110 0000.0110 1011.1110 0000.1111
  90  * --
  91  * 5E F2 D6 5D
  92  * 55 09 26 79
  93  * 62 70 00 79
  94  * 31 D9 AF 37
  95  * BE 06 BE 0F
  96  */
  97 uint8_t comp0[] = {
  98         0x5E, 0xF2, 0xD6, 0x5D,
  99         0x55, 0x09, 0x26, 0x79,
 100         0x62, 0x70, 0x00, 0x79,
 101         0x31, 0xD9, 0xAF, 0x37,
 102         0xBE, 0x06, 0xBE, 0x0F
 103 };
 104
 105
 106 /* comp1 (shifting one bit right to make calculation easier, so inserting two zeros)
 107  * 0110.0000 0011.1110 0011.0010 1111.1010
 108  * 0011.0000 0111.1001 0110.1100 1111.1101
 109  * 1100.0001 1000.0111 0000.0001 1111.1000
 110  * 1000.1010 1100.0110 1100.0001 1100.1100
 111  * 0110.1010 1011.0111 1110.1000 1111.1111
 112  * --
 113  * 60 3E 32 FA
 114  * 30 79 6C FD
 115  * C1 87 01 F8
 116  * 8A C6 C1 CC
 117  * 6A B7 E8 FF
 118 */
 119 /*
 120 uint8_t comp1[] PROGMEM = {
 121         0x60, 0x3E, 0x32, 0xFA, 0x30, 0x79, 0x6C, 0xFD, 0xC1, 0x87,
 122         0x01, 0xF8, 0x8A, 0xC6, 0xC1, 0xCC, 0x6A, 0xB7, 0xE8, 0xFF
 123 };
 124 */
 125 /* comp1
 126  * 0000.1100 1111.1000 1001.1000 1011.1110
 127  * 0001.1001 0011.1100 0110.1101 0111.1111
 128  * 0000.0111 1100.0011 0000.0000 0011.1110
 129  * 1010.0010 1100.0111 0000.0110 0110.0110
 130  * 1010.1101 1101.1010 0010.1111 1111.1110
 131  * --
 132  * 0C F8 98 BE
 133  * 19 3C 6D 7F
 134  * 07 C3 00 3E
 135  * A2 C7 06 66
 136  * AD DA 2F FE
 137 */
 138 /*
 139 uint8_t comp1[] PROGMEM = {
 140         0x0C, 0xF8, 0x98, 0xBE, 0x19, 0x3C, 0x6D, 0x7F, 0x07, 0xC3,
 141         0x00, 0x3E, 0xA2, 0xC7, 0x06, 0x66, 0xAD, 0xDA, 0x2F, 0xFE
 142 };
 143 */
 144 /* comp1
 145  * 0011.0000 0001.1111 0001.1001 0111.1101
 146  * 1001.1000 0011.1100 1011.0110 1111.1110
 147  * 1110.0000 1100.0011 0000.0000 0111.1100
 148  * 0100.0101 1110.0011 0110.0000 0110.0110
 149  * 1011.0101 0101.1011 1111.0100 0111.1111
 150  * --
 151  * 30 1F 19 7D
 152  * 98 3C B6 FE
 153  * E0 C3 00 7C
 154  * 45 E3 60 66
 155  * B5 5B F4 7F
 156 */
 157
 158 uint8_t comp1[] = {
 159         0x30, 0x1F, 0x19, 0x7D,
 160         0x98, 0x3C, 0xB6, 0xFE,
 161         0xE0, 0xC3, 0x00, 0x7C,
 162         0x45, 0xE3, 0x60, 0x66,
 163         0xB5, 0x5B, 0xF4, 0x7F
 164 };
 165
 166 /* fb0
 167  * 1010.1111 0001.1111 0011.1100 1100.0100
 168  * 0010.0010 1010.0011 0010.1111 0000.1110
 169  * 1000.0001 0100.1101 1110.0101 0110.0110
 170  * 1001.0001 0100.1011 0101.0100 1101.0100
 171  * 1100.0001 0000.1011 0110.0011 1000.0011
 172  * --
 173  * AF 1F 3C C4
 174  * 22 A3 2F 0E
 175  * 81 4D E5 66
 176  * 91 4B 54 D4
 177  * C1 0B 63 83
 178  */
 179 uint8_t fb0[] = {
 180         0xAF, 0x1F, 0x3C, 0xC4,
 181         0x22, 0xA3, 0x2F, 0x0E,
 182         0x81, 0x4D, 0xE5, 0x66,
 183         0x91, 0x4B, 0x54, 0xD4,
 184         0xC1, 0x0B, 0x63, 0x83
 185 };
 186
 187 /* fb1
 188  * 1010.1011 0111.0111 1111.0100 1001.1011
 189  * 1001.0000 1000.1100 0111.1001 0111.0000
 190  * 1011.0110 0001.1000 1001.1010 0110.1111
 191  * 1110.0111 0111.1110 0100.1011 0110.1100
 192  * 1110.1111 1000.0000 1010.0111 0001.0001
 193  * --
 194  * AB 77 F4 9B
 195  * 90 8C 79 70
 196  * B6 18 9A 6F
 197  * E7 7E 4B 6C
 198  * EF 80 A7 11
 199  */
 200 uint8_t fb1[] = {
 201         0xAB, 0x77, 0xF4, 0x9B,
 202         0x90, 0x8C, 0x79, 0x70,
 203         0xB6, 0x18, 0x9A, 0x6F,
 204         0xE7, 0x7E, 0x4B, 0x6C,
 205         0xEF, 0x80, 0xA7, 0x11
 206 };
 207
 208 static
 209 void clock_s(uint8_t* s, uint8_t ibit, uint8_t cbit){
 210         uint8_t s0[20], s1[20];
 211         uint8_t i,c=0, c2=0;
 212         ibit ^= (s[19])>>7;
 213         memcpy(s0,s,20);
 214         memxor(s0, comp0, 20);
 215         for(i=0; i<20; ++i){
 216                 s1[19-i]= c|((s[19-i])>>1);
 217                 c = (s[19-i])<<7;
 218         }
 219         memxor(s1, comp1, 20);
 220         c=0;
 221         for(i=0; i<20; ++i){
 222                 c2=(s[i])>>7;
 223                 s[i]=((s[i])<<1) ^ ((s0[i])&(s1[i])) ^ c;
 224                 c=c2;
 225         }
 226         s[0] &= 0xFE;
 227         if(ibit){
 228                 memxor(s, cbit?fb1:fb0, 20);
 229         }
 230 }
 231
 232 static
 233 void clock_kg(uint8_t* r, uint8_t* s, uint8_t mixing, uint8_t input){
 234         uint8_t rb, sb;
 235         rb = ((s[ 54/8])>>(( 54%8))) ^ ((r[106/8])>>(((106%8))));
 236         sb = ((s[106/8])>>((106%8))) ^ ((r[ 53/8])>>((( 53%8))));
 237         rb &= 1;
 238         sb &= 1;
 239         mixing = input ^ (mixing & ((s[80/8]>>((80%8))) & 1));
 240         clock_r(r, mixing, rb);
 241         clock_s(s, input, sb);
 242 }
 243
 244 void mickey128_init(void* key, uint16_t keysize_b,
 245                     void* iv,  uint16_t ivsize_b,
 246                     mickey128_ctx_t* ctx){
 247         uint16_t i;
 248         memset(ctx->r, 0, 20);
 249         memset(ctx->s, 0, 20);
 250         for(i=0; i<ivsize_b; ++i){
 251                 clock_kg(ctx->r, ctx->s, 1, 1&((((uint8_t*)iv)[i/8])>>(7-(i%8))));
 252         }
 253         for(i=0; i<keysize_b; ++i){
 254                 clock_kg(ctx->r, ctx->s, 1, 1&((((uint8_t*)key)[i/8])>>(7-(i%8))));
 255         }
 256         for(i=0; i<160; ++i){
 257                 clock_kg(ctx->r, ctx->s, 1, 0);
 258         }
 259 }
 260
 261 uint8_t mickey128_getbit(mickey128_ctx_t* ctx){
 262         uint8_t ret;
 263         ret = 1&(*(ctx->r) ^ *(ctx->s));
 264         clock_kg(ctx->r, ctx->s, 0, 0);
 265         return ret;
 266 }
 267
 268 uint8_t mickey128_getbyte(mickey128_ctx_t* ctx){
 269         uint8_t i,ret=0;
 270         for(i=0; i<8; ++i){
 271                 ret<<=1;
 272                 ret |= 1&(((ctx->r)[0]) ^ ((ctx->s)[0]));
 273                 clock_kg(ctx->r, ctx->s, 0, 0);
 274         }
 275         return ret;
 276 }
 277
 278