pd.if.org Git - zpackage/blob - libtomcrypt/src/ciphers/safer/safer.c

   1 /* LibTomCrypt, modular cryptographic library -- Tom St Denis
   2  *
   3  * LibTomCrypt is a library that provides various cryptographic
   4  * algorithms in a highly modular and flexible manner.
   5  *
   6  * The library is free for all purposes without any express
   7  * guarantee it works.
   8  */
   9
  10 /*******************************************************************************
  11 *
  12 * FILE:           safer.c
  13 *
  14 * LTC_DESCRIPTION:    block-cipher algorithm LTC_SAFER (Secure And Fast Encryption
  15 *                 Routine) in its four versions: LTC_SAFER K-64, LTC_SAFER K-128,
  16 *                 LTC_SAFER SK-64 and LTC_SAFER SK-128.
  17 *
  18 * AUTHOR:         Richard De Moliner (demoliner@isi.ee.ethz.ch)
  19 *                 Signal and Information Processing Laboratory
  20 *                 Swiss Federal Institute of Technology
  21 *                 CH-8092 Zuerich, Switzerland
  22 *
  23 * DATE:           September 9, 1995
  24 *
  25 * CHANGE HISTORY:
  26 *
  27 *******************************************************************************/
  28
  29 #include "tomcrypt.h"
  30
  31 #ifdef LTC_SAFER
  32
  33 #define __LTC_SAFER_TAB_C__
  34 #include "safer_tab.c"
  35
  36 const struct ltc_cipher_descriptor safer_k64_desc = {
  37    "safer-k64",
  38    8, 8, 8, 8, LTC_SAFER_K64_DEFAULT_NOF_ROUNDS,
  39    &safer_k64_setup,
  40    &safer_ecb_encrypt,
  41    &safer_ecb_decrypt,
  42    &safer_k64_test,
  43    &safer_done,
  44    &safer_64_keysize,
  45    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  46    },
  47
  48    safer_sk64_desc = {
  49    "safer-sk64",
  50    9, 8, 8, 8, LTC_SAFER_SK64_DEFAULT_NOF_ROUNDS,
  51    &safer_sk64_setup,
  52    &safer_ecb_encrypt,
  53    &safer_ecb_decrypt,
  54    &safer_sk64_test,
  55    &safer_done,
  56    &safer_64_keysize,
  57    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  58    },
  59
  60    safer_k128_desc = {
  61    "safer-k128",
  62    10, 16, 16, 8, LTC_SAFER_K128_DEFAULT_NOF_ROUNDS,
  63    &safer_k128_setup,
  64    &safer_ecb_encrypt,
  65    &safer_ecb_decrypt,
  66    &safer_sk128_test,
  67    &safer_done,
  68    &safer_128_keysize,
  69    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  70    },
  71
  72    safer_sk128_desc = {
  73    "safer-sk128",
  74    11, 16, 16, 8, LTC_SAFER_SK128_DEFAULT_NOF_ROUNDS,
  75    &safer_sk128_setup,
  76    &safer_ecb_encrypt,
  77    &safer_ecb_decrypt,
  78    &safer_sk128_test,
  79    &safer_done,
  80    &safer_128_keysize,
  81    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  82    };
  83
  84 /******************* Constants ************************************************/
  85 /* #define TAB_LEN      256  */
  86
  87 /******************* Assertions ***********************************************/
  88
  89 /******************* Macros ***************************************************/
  90 #define ROL8(x, n)   ((unsigned char)((unsigned int)(x) << (n)\
  91                                      |(unsigned int)((x) & 0xFF) >> (8 - (n))))
  92 #define EXP(x)       safer_ebox[(x) & 0xFF]
  93 #define LOG(x)       safer_lbox[(x) & 0xFF]
  94 #define PHT(x, y)    { y += x; x += y; }
  95 #define IPHT(x, y)   { x -= y; y -= x; }
  96
  97 /******************* Types ****************************************************/
  98
  99 #ifdef LTC_CLEAN_STACK
 100 static void _Safer_Expand_Userkey(const unsigned char *userkey_1,
 101                                  const unsigned char *userkey_2,
 102                                  unsigned int nof_rounds,
 103                                  int strengthened,
 104                                  safer_key_t key)
 105 #else
 106 static void Safer_Expand_Userkey(const unsigned char *userkey_1,
 107                                  const unsigned char *userkey_2,
 108                                  unsigned int nof_rounds,
 109                                  int strengthened,
 110                                  safer_key_t key)
 111 #endif
 112 {   unsigned int i, j, k;
 113     unsigned char ka[LTC_SAFER_BLOCK_LEN + 1];
 114     unsigned char kb[LTC_SAFER_BLOCK_LEN + 1];
 115
 116     if (LTC_SAFER_MAX_NOF_ROUNDS < nof_rounds)
 117         nof_rounds = LTC_SAFER_MAX_NOF_ROUNDS;
 118     *key++ = (unsigned char)nof_rounds;
 119     ka[LTC_SAFER_BLOCK_LEN] = (unsigned char)0;
 120     kb[LTC_SAFER_BLOCK_LEN] = (unsigned char)0;
 121     k = 0;
 122     for (j = 0; j < LTC_SAFER_BLOCK_LEN; j++) {
 123         ka[j] = ROL8(userkey_1[j], 5);
 124         ka[LTC_SAFER_BLOCK_LEN] ^= ka[j];
 125         kb[j] = *key++ = userkey_2[j];
 126         kb[LTC_SAFER_BLOCK_LEN] ^= kb[j];
 127     }
 128     for (i = 1; i <= nof_rounds; i++) {
 129         for (j = 0; j < LTC_SAFER_BLOCK_LEN + 1; j++) {
 130             ka[j] = ROL8(ka[j], 6);
 131             kb[j] = ROL8(kb[j], 6);
 132         }
 133         if (strengthened) {
 134            k = 2 * i - 1;
 135            while (k >= (LTC_SAFER_BLOCK_LEN + 1)) { k -= LTC_SAFER_BLOCK_LEN + 1; }
 136         }
 137         for (j = 0; j < LTC_SAFER_BLOCK_LEN; j++) {
 138             if (strengthened) {
 139                 *key++ = (ka[k]
 140                                 + safer_ebox[(int)safer_ebox[(int)((18 * i + j + 1)&0xFF)]]) & 0xFF;
 141                 if (++k == (LTC_SAFER_BLOCK_LEN + 1)) { k = 0; }
 142             } else {
 143                 *key++ = (ka[j] + safer_ebox[(int)safer_ebox[(int)((18 * i + j + 1)&0xFF)]]) & 0xFF;
 144             }
 145         }
 146         if (strengthened) {
 147            k = 2 * i;
 148            while (k >= (LTC_SAFER_BLOCK_LEN + 1)) { k -= LTC_SAFER_BLOCK_LEN + 1; }
 149         }
 150         for (j = 0; j < LTC_SAFER_BLOCK_LEN; j++) {
 151             if (strengthened) {
 152                 *key++ = (kb[k]
 153                                 + safer_ebox[(int)safer_ebox[(int)((18 * i + j + 10)&0xFF)]]) & 0xFF;
 154                 if (++k == (LTC_SAFER_BLOCK_LEN + 1)) { k = 0; }
 155             } else {
 156                 *key++ = (kb[j] + safer_ebox[(int)safer_ebox[(int)((18 * i + j + 10)&0xFF)]]) & 0xFF;
 157             }
 158         }
 159     }
 160
 161 #ifdef LTC_CLEAN_STACK
 162     zeromem(ka, sizeof(ka));
 163     zeromem(kb, sizeof(kb));
 164 #endif
 165 }
 166
 167 #ifdef LTC_CLEAN_STACK
 168 static void Safer_Expand_Userkey(const unsigned char *userkey_1,
 169                                  const unsigned char *userkey_2,
 170                                  unsigned int nof_rounds,
 171                                  int strengthened,
 172                                  safer_key_t key)
 173 {
 174    _Safer_Expand_Userkey(userkey_1, userkey_2, nof_rounds, strengthened, key);
 175    burn_stack(sizeof(unsigned char) * (2 * (LTC_SAFER_BLOCK_LEN + 1)) + sizeof(unsigned int)*2);
 176 }
 177 #endif
 178
 179 int safer_k64_setup(const unsigned char *key, int keylen, int numrounds, symmetric_key *skey)
 180 {
 181    LTC_ARGCHK(key != NULL);
 182    LTC_ARGCHK(skey != NULL);
 183
 184    if (numrounds != 0 && (numrounds < 6 || numrounds > LTC_SAFER_MAX_NOF_ROUNDS)) {
 185       return CRYPT_INVALID_ROUNDS;
 186    }
 187
 188    if (keylen != 8) {
 189       return CRYPT_INVALID_KEYSIZE;
 190    }
 191
 192    Safer_Expand_Userkey(key, key, (unsigned int)(numrounds != 0 ?numrounds:LTC_SAFER_K64_DEFAULT_NOF_ROUNDS), 0, skey->safer.key);
 193    return CRYPT_OK;
 194 }
 195
 196 int safer_sk64_setup(const unsigned char *key, int keylen, int numrounds, symmetric_key *skey)
 197 {
 198    LTC_ARGCHK(key != NULL);
 199    LTC_ARGCHK(skey != NULL);
 200
 201    if (numrounds != 0 && (numrounds < 6 || numrounds > LTC_SAFER_MAX_NOF_ROUNDS)) {
 202       return CRYPT_INVALID_ROUNDS;
 203    }
 204
 205    if (keylen != 8) {
 206       return CRYPT_INVALID_KEYSIZE;
 207    }
 208
 209    Safer_Expand_Userkey(key, key, (unsigned int)(numrounds != 0 ?numrounds:LTC_SAFER_SK64_DEFAULT_NOF_ROUNDS), 1, skey->safer.key);
 210    return CRYPT_OK;
 211 }
 212
 213 int safer_k128_setup(const unsigned char *key, int keylen, int numrounds, symmetric_key *skey)
 214 {
 215    LTC_ARGCHK(key != NULL);
 216    LTC_ARGCHK(skey != NULL);
 217
 218    if (numrounds != 0 && (numrounds < 6 || numrounds > LTC_SAFER_MAX_NOF_ROUNDS)) {
 219       return CRYPT_INVALID_ROUNDS;
 220    }
 221
 222    if (keylen != 16) {
 223       return CRYPT_INVALID_KEYSIZE;
 224    }
 225
 226    Safer_Expand_Userkey(key, key+8, (unsigned int)(numrounds != 0 ?numrounds:LTC_SAFER_K128_DEFAULT_NOF_ROUNDS), 0, skey->safer.key);
 227    return CRYPT_OK;
 228 }
 229
 230 int safer_sk128_setup(const unsigned char *key, int keylen, int numrounds, symmetric_key *skey)
 231 {
 232    LTC_ARGCHK(key != NULL);
 233    LTC_ARGCHK(skey != NULL);
 234
 235    if (numrounds != 0 && (numrounds < 6 || numrounds > LTC_SAFER_MAX_NOF_ROUNDS)) {
 236       return CRYPT_INVALID_ROUNDS;
 237    }
 238
 239    if (keylen != 16) {
 240       return CRYPT_INVALID_KEYSIZE;
 241    }
 242
 243    Safer_Expand_Userkey(key, key+8, (unsigned int)(numrounds != 0?numrounds:LTC_SAFER_SK128_DEFAULT_NOF_ROUNDS), 1, skey->safer.key);
 244    return CRYPT_OK;
 245 }
 246
 247 #ifdef LTC_CLEAN_STACK
 248 static int _safer_ecb_encrypt(const unsigned char *block_in,
 249                              unsigned char *block_out,
 250                              symmetric_key *skey)
 251 #else
 252 int safer_ecb_encrypt(const unsigned char *block_in,
 253                              unsigned char *block_out,
 254                              symmetric_key *skey)
 255 #endif
 256 {   unsigned char a, b, c, d, e, f, g, h, t;
 257     unsigned int round;
 258     unsigned char *key;
 259
 260     LTC_ARGCHK(block_in != NULL);
 261     LTC_ARGCHK(block_out != NULL);
 262     LTC_ARGCHK(skey != NULL);
 263
 264     key = skey->safer.key;
 265     a = block_in[0]; b = block_in[1]; c = block_in[2]; d = block_in[3];
 266     e = block_in[4]; f = block_in[5]; g = block_in[6]; h = block_in[7];
 267     if (LTC_SAFER_MAX_NOF_ROUNDS < (round = *key)) round = LTC_SAFER_MAX_NOF_ROUNDS;
 268     while(round-- > 0)
 269     {
 270         a ^= *++key; b += *++key; c += *++key; d ^= *++key;
 271         e ^= *++key; f += *++key; g += *++key; h ^= *++key;
 272         a = EXP(a) + *++key; b = LOG(b) ^ *++key;
 273         c = LOG(c) ^ *++key; d = EXP(d) + *++key;
 274         e = EXP(e) + *++key; f = LOG(f) ^ *++key;
 275         g = LOG(g) ^ *++key; h = EXP(h) + *++key;
 276         PHT(a, b); PHT(c, d); PHT(e, f); PHT(g, h);
 277         PHT(a, c); PHT(e, g); PHT(b, d); PHT(f, h);
 278         PHT(a, e); PHT(b, f); PHT(c, g); PHT(d, h);
 279         t = b; b = e; e = c; c = t; t = d; d = f; f = g; g = t;
 280     }
 281     a ^= *++key; b += *++key; c += *++key; d ^= *++key;
 282     e ^= *++key; f += *++key; g += *++key; h ^= *++key;
 283     block_out[0] = a & 0xFF; block_out[1] = b & 0xFF;
 284     block_out[2] = c & 0xFF; block_out[3] = d & 0xFF;
 285     block_out[4] = e & 0xFF; block_out[5] = f & 0xFF;
 286     block_out[6] = g & 0xFF; block_out[7] = h & 0xFF;
 287     return CRYPT_OK;
 288 }
 289
 290 #ifdef LTC_CLEAN_STACK
 291 int safer_ecb_encrypt(const unsigned char *block_in,
 292                              unsigned char *block_out,
 293                              symmetric_key *skey)
 294 {
 295     int err = _safer_ecb_encrypt(block_in, block_out, skey);
 296     burn_stack(sizeof(unsigned char) * 9 + sizeof(unsigned int) + sizeof(unsigned char *));
 297     return err;
 298 }
 299 #endif
 300
 301 #ifdef LTC_CLEAN_STACK
 302 static int _safer_ecb_decrypt(const unsigned char *block_in,
 303                              unsigned char *block_out,
 304                              symmetric_key *skey)
 305 #else
 306 int safer_ecb_decrypt(const unsigned char *block_in,
 307                              unsigned char *block_out,
 308                              symmetric_key *skey)
 309 #endif
 310 {   unsigned char a, b, c, d, e, f, g, h, t;
 311     unsigned int round;
 312     unsigned char *key;
 313
 314     LTC_ARGCHK(block_in != NULL);
 315     LTC_ARGCHK(block_out != NULL);
 316     LTC_ARGCHK(skey != NULL);
 317
 318     key = skey->safer.key;
 319     a = block_in[0]; b = block_in[1]; c = block_in[2]; d = block_in[3];
 320     e = block_in[4]; f = block_in[5]; g = block_in[6]; h = block_in[7];
 321     if (LTC_SAFER_MAX_NOF_ROUNDS < (round = *key)) round = LTC_SAFER_MAX_NOF_ROUNDS;
 322     key += LTC_SAFER_BLOCK_LEN * (1 + 2 * round);
 323     h ^= *key; g -= *--key; f -= *--key; e ^= *--key;
 324     d ^= *--key; c -= *--key; b -= *--key; a ^= *--key;
 325     while (round--)
 326     {
 327         t = e; e = b; b = c; c = t; t = f; f = d; d = g; g = t;
 328         IPHT(a, e); IPHT(b, f); IPHT(c, g); IPHT(d, h);
 329         IPHT(a, c); IPHT(e, g); IPHT(b, d); IPHT(f, h);
 330         IPHT(a, b); IPHT(c, d); IPHT(e, f); IPHT(g, h);
 331         h -= *--key; g ^= *--key; f ^= *--key; e -= *--key;
 332         d -= *--key; c ^= *--key; b ^= *--key; a -= *--key;
 333         h = LOG(h) ^ *--key; g = EXP(g) - *--key;
 334         f = EXP(f) - *--key; e = LOG(e) ^ *--key;
 335         d = LOG(d) ^ *--key; c = EXP(c) - *--key;
 336         b = EXP(b) - *--key; a = LOG(a) ^ *--key;
 337     }
 338     block_out[0] = a & 0xFF; block_out[1] = b & 0xFF;
 339     block_out[2] = c & 0xFF; block_out[3] = d & 0xFF;
 340     block_out[4] = e & 0xFF; block_out[5] = f & 0xFF;
 341     block_out[6] = g & 0xFF; block_out[7] = h & 0xFF;
 342     return CRYPT_OK;
 343 }
 344
 345 #ifdef LTC_CLEAN_STACK
 346 int safer_ecb_decrypt(const unsigned char *block_in,
 347                              unsigned char *block_out,
 348                              symmetric_key *skey)
 349 {
 350     int err = _safer_ecb_decrypt(block_in, block_out, skey);
 351     burn_stack(sizeof(unsigned char) * 9 + sizeof(unsigned int) + sizeof(unsigned char *));
 352     return err;
 353 }
 354 #endif
 355
 356 int safer_64_keysize(int *keysize)
 357 {
 358    LTC_ARGCHK(keysize != NULL);
 359    if (*keysize < 8) {
 360       return CRYPT_INVALID_KEYSIZE;
 361    } else {
 362       *keysize = 8;
 363       return CRYPT_OK;
 364    }
 365 }
 366
 367 int safer_128_keysize(int *keysize)
 368 {
 369    LTC_ARGCHK(keysize != NULL);
 370    if (*keysize < 16) {
 371       return CRYPT_INVALID_KEYSIZE;
 372    } else {
 373       *keysize = 16;
 374       return CRYPT_OK;
 375    }
 376 }
 377
 378 int safer_k64_test(void)
 379 {
 380  #ifndef LTC_TEST
 381     return CRYPT_NOP;
 382  #else
 383    static const unsigned char k64_pt[]  = { 1, 2, 3, 4, 5, 6, 7, 8 },
 384                               k64_key[] = { 8, 7, 6, 5, 4, 3, 2, 1 },
 385                               k64_ct[]  = { 200, 242, 156, 221, 135, 120, 62, 217 };
 386
 387    symmetric_key skey;
 388    unsigned char buf[2][8];
 389    int err;
 390
 391    /* test K64 */
 392    if ((err = safer_k64_setup(k64_key, 8, 6, &skey)) != CRYPT_OK) {
 393       return err;
 394    }
 395    safer_ecb_encrypt(k64_pt, buf[0], &skey);
 396    safer_ecb_decrypt(buf[0], buf[1], &skey);
 397
 398    if (compare_testvector(buf[0], 8, k64_ct, 8, "Safer K64 Encrypt", 0) != 0 ||
 399          compare_testvector(buf[1], 8, k64_pt, 8, "Safer K64 Decrypt", 0) != 0) {
 400       return CRYPT_FAIL_TESTVECTOR;
 401    }
 402
 403    return CRYPT_OK;
 404  #endif
 405 }
 406
 407
 408 int safer_sk64_test(void)
 409 {
 410  #ifndef LTC_TEST
 411     return CRYPT_NOP;
 412  #else
 413    static const unsigned char sk64_pt[]  = { 1, 2, 3, 4, 5, 6, 7, 8 },
 414                               sk64_key[] = { 1, 2, 3, 4, 5, 6, 7, 8 },
 415                               sk64_ct[]  = { 95, 206, 155, 162, 5, 132, 56, 199 };
 416
 417    symmetric_key skey;
 418    unsigned char buf[2][8];
 419    int err, y;
 420
 421    /* test SK64 */
 422    if ((err = safer_sk64_setup(sk64_key, 8, 6, &skey)) != CRYPT_OK) {
 423       return err;
 424    }
 425
 426    safer_ecb_encrypt(sk64_pt, buf[0], &skey);
 427    safer_ecb_decrypt(buf[0], buf[1], &skey);
 428
 429    if (compare_testvector(buf[0], 8, sk64_ct, 8, "Safer SK64 Encrypt", 0) != 0 ||
 430          compare_testvector(buf[1], 8, sk64_pt, 8, "Safer SK64 Decrypt", 0) != 0) {
 431       return CRYPT_FAIL_TESTVECTOR;
 432    }
 433
 434    /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
 435    for (y = 0; y < 8; y++) buf[0][y] = 0;
 436    for (y = 0; y < 1000; y++) safer_ecb_encrypt(buf[0], buf[0], &skey);
 437    for (y = 0; y < 1000; y++) safer_ecb_decrypt(buf[0], buf[0], &skey);
 438    for (y = 0; y < 8; y++) if (buf[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
 439
 440    return CRYPT_OK;
 441   #endif
 442 }
 443
 444 /** Terminate the context
 445    @param skey    The scheduled key
 446 */
 447 void safer_done(symmetric_key *skey)
 448 {
 449   LTC_UNUSED_PARAM(skey);
 450 }
 451
 452 int safer_sk128_test(void)
 453 {
 454  #ifndef LTC_TEST
 455     return CRYPT_NOP;
 456  #else
 457    static const unsigned char sk128_pt[]  = { 1, 2, 3, 4, 5, 6, 7, 8 },
 458                               sk128_key[] = { 1, 2, 3, 4, 5, 6, 7, 8,
 459                                               0, 0, 0, 0, 0, 0, 0, 0 },
 460                               sk128_ct[]  = { 255, 120, 17, 228, 179, 167, 46, 113 };
 461
 462    symmetric_key skey;
 463    unsigned char buf[2][8];
 464    int err, y;
 465
 466    /* test SK128 */
 467    if ((err = safer_sk128_setup(sk128_key, 16, 0, &skey)) != CRYPT_OK) {
 468       return err;
 469    }
 470    safer_ecb_encrypt(sk128_pt, buf[0], &skey);
 471    safer_ecb_decrypt(buf[0], buf[1], &skey);
 472
 473    if (compare_testvector(buf[0], 8, sk128_ct, 8, "Safer SK128 Encrypt", 0) != 0 ||
 474          compare_testvector(buf[1], 8, sk128_pt, 8, "Safer SK128 Decrypt", 0) != 0) {
 475       return CRYPT_FAIL_TESTVECTOR;
 476    }
 477
 478    /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
 479    for (y = 0; y < 8; y++) buf[0][y] = 0;
 480    for (y = 0; y < 1000; y++) safer_ecb_encrypt(buf[0], buf[0], &skey);
 481    for (y = 0; y < 1000; y++) safer_ecb_decrypt(buf[0], buf[0], &skey);
 482    for (y = 0; y < 8; y++) if (buf[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
 483
 484    return CRYPT_OK;
 485  #endif
 486 }
 487
 488 #endif
 489
 490
 491
 492
 493 /* ref:         $Format:%D$ */
 494 /* git commit:  $Format:%H$ */
 495 /* commit time: $Format:%ai$ */