seed/seed_c.c

   1 /* seed_c.c */
   2 /*
   3     This file is part of the ARM-Crypto-Lib.
   4     Copyright (C) 2006-2010  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  * \file        seed_c.c
  21  * \author      Daniel Otte
  22  * \date        2007-06-1
  23  * \brief       SEED parts in C for ARM
  24  * \par License
  25  * GPL
  26  *
  27  */
  28 #include <stdint.h>
  29 #include <string.h>
  30 #include "seed.h"
  31 #include "seed_sbox.h"
  32
  33
  34 static
  35 uint32_t g_function(uint32_t x);
  36 /******************************************************************************/
  37
  38 static
  39 void changeendian32(uint32_t * a){
  40         *a = (*a & 0x000000FF) << 24 |
  41                  (*a & 0x0000FF00) <<  8 |
  42                  (*a & 0x00FF0000) >>  8 |
  43                  (*a & 0xFF000000) >> 24;
  44 }
  45
  46 /******************************************************************************/
  47 static
  48 uint32_t bigendian_sum32(uint32_t a, uint32_t b){
  49         changeendian32(&a);
  50         changeendian32(&b);
  51         a += b;
  52         changeendian32(&a);
  53         return a;
  54 }
  55
  56 /******************************************************************************/
  57 static
  58 uint32_t bigendian_sub32(uint32_t a, uint32_t b){
  59         changeendian32(&a);
  60         changeendian32(&b);
  61         a -= b;
  62         changeendian32(&a);
  63         return a;
  64 }
  65
  66 /******************************************************************************/
  67 static inline
  68 uint64_t bigendian_rotl8_64(uint64_t a){
  69         /*
  70         changeendian64(&a);
  71         a = (a<<8) | (a>>(64-8));
  72         changeendian64(&a);
  73         */
  74         a = (a>>8) | (a<<(64-8));
  75         return a;
  76 }
  77
  78 /******************************************************************************/
  79 static inline
  80 uint64_t bigendian_rotr8_64(uint64_t a){
  81         /*
  82         changeendian64(&a);
  83         a = (a>>8) | (a<<(64-8));
  84         changeendian64(&a);
  85         */
  86         a = (a<<8) | (a>>(64-8));
  87         return a;
  88 }
  89
  90 /******************************************************************************/
  91 static
  92 uint64_t f_function(const uint64_t* a, uint32_t k0, uint32_t k1){
  93         uint32_t c,d;
  94
  95         c = *a & 0x00000000FFFFFFFFLL;
  96         d = (*a>>32) & 0x00000000FFFFFFFFLL;
  97
  98         c ^= k0; d ^= k1;
  99         d ^= c;
 100         d = g_function(d);
 101         c = bigendian_sum32(c,d);
 102         c = g_function(c);
 103         d = bigendian_sum32(c,d);
 104         d = g_function(d);
 105         c = bigendian_sum32(c,d);
 106         return ((uint64_t)d << 32) | c;
 107 }
 108
 109 /******************************************************************************/
 110 #define M0 0xfc
 111 #define M1 0xf3
 112 #define M2 0xcf
 113 #define M3 0x3f
 114
 115 #define X3 (((uint8_t*)(&x))[0])
 116 #define X2 (((uint8_t*)(&x))[1])
 117 #define X1 (((uint8_t*)(&x))[2])
 118 #define X0 (((uint8_t*)(&x))[3])
 119
 120 #define Z3 (((uint8_t*)(&z))[0])
 121 #define Z2 (((uint8_t*)(&z))[1])
 122 #define Z1 (((uint8_t*)(&z))[2])
 123 #define Z0 (((uint8_t*)(&z))[3])
 124
 125 static
 126 uint32_t g_function(uint32_t x){
 127         uint32_t z;
 128         /* sbox substitution */
 129         X3 = seed_sbox2[X3];
 130         X2 = seed_sbox1[X2];
 131         X1 = seed_sbox2[X1];
 132         X0 = seed_sbox1[X0];
 133         /* now the permutation */
 134         Z0 = (X0 & M0) ^ (X1 & M1) ^ (X2 & M2) ^ (X3 & M3);
 135         Z1 = (X0 & M1) ^ (X1 & M2) ^ (X2 & M3) ^ (X3 & M0);
 136         Z2 = (X0 & M2) ^ (X1 & M3) ^ (X2 & M0) ^ (X3 & M1);
 137         Z3 = (X0 & M3) ^ (X1 & M0) ^ (X2 & M1) ^ (X3 & M2);
 138         return z;
 139 }
 140 /******************************************************************************/
 141 typedef struct {
 142         uint32_t k0, k1;
 143 } keypair_t;
 144
 145 keypair_t getnextkeys(uint32_t *keystate, uint8_t curround){
 146         keypair_t ret;
 147         if (curround>15){
 148                 /* ERROR */
 149                 ret.k0 = ret.k1 = 0;
 150         } else {
 151         /*      ret.k0 = g_function(keystate[0] + keystate[2] - pgm_read_dword(&(seed_kc[curround])));
 152                 ret.k1 = g_function(keystate[1] - keystate[3] + pgm_read_dword(&(seed_kc[curround]))); */
 153                 ret.k0 = bigendian_sum32(keystate[0], keystate[2]);
 154                 ret.k0 = bigendian_sub32(ret.k0, seed_kc[curround]);
 155                 ret.k0 = g_function(ret.k0);
 156                 ret.k1 = bigendian_sub32(keystate[1], keystate[3]);
 157                 ret.k1 = bigendian_sum32(ret.k1, seed_kc[curround]);
 158                 ret.k1 = g_function(ret.k1);
 159
 160                 if (curround & 1){
 161                         /* odd round (1,3,5, ...) */
 162                         ((uint64_t*)keystate)[1] = bigendian_rotl8_64( ((uint64_t*)keystate)[1] );
 163                 } else {
 164                         /* even round (0,2,4, ...) */
 165                         ((uint64_t*)keystate)[0] = bigendian_rotr8_64(((uint64_t*)keystate)[0]);
 166                 }
 167         }
 168         return ret;
 169 }
 170
 171
 172 /******************************************************************************/
 173
 174 keypair_t getprevkeys(uint32_t *keystate, uint8_t curround){
 175         keypair_t ret;
 176         if (curround>15){
 177                 /* ERROR */
 178                 ret.k0 = ret.k1 = 0;
 179         } else {
 180                 if (curround & 1){
 181                         /* odd round (1,3,5, ..., 15) */
 182                         ((uint64_t*)keystate)[1] = bigendian_rotr8_64( ((uint64_t*)keystate)[1] );
 183                 } else {
 184                         /* even round (0,2,4, ..., 14) */
 185                         ((uint64_t*)keystate)[0] = bigendian_rotl8_64(((uint64_t*)keystate)[0]);
 186                 }
 187         /*      ret.k0 = g_function(keystate[0] + keystate[2] - pgm_read_dword(&(seed_kc[curround])));
 188                 ret.k1 = g_function(keystate[1] - keystate[3] + pgm_read_dword(&(seed_kc[curround]))); */
 189                 ret.k0 = bigendian_sum32(keystate[0], keystate[2]);
 190                 ret.k0 = bigendian_sub32(ret.k0, seed_kc[curround]);
 191                 ret.k0 = g_function(ret.k0);
 192                 ret.k1 = bigendian_sub32(keystate[1], keystate[3]);
 193                 ret.k1 = bigendian_sum32(ret.k1, seed_kc[curround]);
 194                 ret.k1 = g_function(ret.k1);
 195                 }
 196         return ret;
 197 }
 198
 199 /******************************************************************************/
 200
 201 void seed_init(const void * key, seed_ctx_t * ctx){
 202         memcpy(ctx->k, key, 128/8);
 203 }
 204
 205 /******************************************************************************/
 206
 207 #define L (((uint64_t*)buffer)[0])
 208 #define R (((uint64_t*)buffer)[1])
 209
 210 void seed_enc(void * buffer, const seed_ctx_t * ctx){
 211         uint8_t r;
 212         keypair_t k;
 213         for(r=0; r<8; ++r){
 214                         k = getnextkeys(((seed_ctx_t*)ctx)->k, 2*r);
 215 /*
 216         DEBUG_S("\r\n\tDBG ka,0: "); cli_hexdump(&k.k0, 4);
 217         DEBUG_S("\r\n\tDBG ka,1: "); cli_hexdump(&k.k1, 4);
 218         DEBUG_S("\r\n\t DBG L: "); cli_hexdump((uint8_t*)buffer+0, 8);
 219         DEBUG_S("\r\n\t DBG R: "); cli_hexdump((uint8_t*)buffer+8, 8);
 220 */
 221                         L ^= f_function(&R,k.k0,k.k1);
 222
 223                         k = getnextkeys(((seed_ctx_t*)ctx)->k, 2*r+1);
 224 /*
 225         DEBUG_S("\r\n\tDBG kb,0: "); cli_hexdump(&k.k0, 4);
 226         DEBUG_S("\r\n\tDBG kb,1: "); cli_hexdump(&k.k1, 4);
 227         DEBUG_S("\r\n\t DBG L: "); cli_hexdump((uint8_t*)buffer+8, 8);
 228         DEBUG_S("\r\n\t DBG R: "); cli_hexdump((uint8_t*)buffer+0, 8);
 229 */
 230                         R ^= f_function(&L,k.k0,k.k1);
 231         }
 232         /* just an exchange without temp. variable */
 233         L ^= R;
 234         R ^= L;
 235         L ^= R;
 236 }
 237
 238 /******************************************************************************/
 239
 240 #define L (((uint64_t*)buffer)[0])
 241 #define R (((uint64_t*)buffer)[1])
 242
 243 void seed_dec(void * buffer, const seed_ctx_t * ctx){
 244         int8_t r;
 245         keypair_t k;
 246         for(r=7; r>=0; --r){
 247                         k = getprevkeys(((seed_ctx_t*)ctx)->k, 2*r+1);
 248 /*
 249         DEBUG_S("\r\n\tDBG ka,0: "); cli_hexdump(&k.k0, 4);
 250         DEBUG_S("\r\n\tDBG ka,1: "); cli_hexdump(&k.k1, 4);
 251         DEBUG_S("\r\n\t DBG L: "); cli_hexdump((uint8_t*)buffer+0, 8);
 252         DEBUG_S("\r\n\t DBG R: "); cli_hexdump((uint8_t*)buffer+8, 8);
 253 */
 254                         L ^= f_function(&R,k.k0,k.k1);
 255
 256                         k = getprevkeys(((seed_ctx_t*)ctx)->k, 2*r+0);
 257 /*
 258         DEBUG_S("\r\n\tDBG kb,0: "); cli_hexdump(&k.k0, 4);
 259         DEBUG_S("\r\n\tDBG kb,1: "); cli_hexdump(&k.k1, 4);
 260         DEBUG_S("\r\n\t DBG L: "); cli_hexdump((uint8_t*)buffer+8, 8);
 261         DEBUG_S("\r\n\t DBG R: "); cli_hexdump((uint8_t*)buffer+0, 8);
 262 */
 263                         R ^= f_function(&L,k.k0,k.k1);
 264         }
 265         /* just an exchange without temp. variable */
 266         L ^= R;
 267         R ^= L;
 268         L ^= R;
 269 }
 270
 271
 272
 273
 274
 275
 276
 277
 278
 279
 280