pd.if.org Git - zpackage/blob - libtomcrypt/src/ciphers/skipjack.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   @file skipjack.c
  12   Skipjack Implementation by Tom St Denis
  13 */
  14 #include "tomcrypt.h"
  15
  16 #ifdef LTC_SKIPJACK
  17
  18 const struct ltc_cipher_descriptor skipjack_desc =
  19 {
  20     "skipjack",
  21     17,
  22     10, 10, 8, 32,
  23     &skipjack_setup,
  24     &skipjack_ecb_encrypt,
  25     &skipjack_ecb_decrypt,
  26     &skipjack_test,
  27     &skipjack_done,
  28     &skipjack_keysize,
  29     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  30 };
  31
  32 static const unsigned char sbox[256] = {
  33    0xa3,0xd7,0x09,0x83,0xf8,0x48,0xf6,0xf4,0xb3,0x21,0x15,0x78,0x99,0xb1,0xaf,0xf9,
  34    0xe7,0x2d,0x4d,0x8a,0xce,0x4c,0xca,0x2e,0x52,0x95,0xd9,0x1e,0x4e,0x38,0x44,0x28,
  35    0x0a,0xdf,0x02,0xa0,0x17,0xf1,0x60,0x68,0x12,0xb7,0x7a,0xc3,0xe9,0xfa,0x3d,0x53,
  36    0x96,0x84,0x6b,0xba,0xf2,0x63,0x9a,0x19,0x7c,0xae,0xe5,0xf5,0xf7,0x16,0x6a,0xa2,
  37    0x39,0xb6,0x7b,0x0f,0xc1,0x93,0x81,0x1b,0xee,0xb4,0x1a,0xea,0xd0,0x91,0x2f,0xb8,
  38    0x55,0xb9,0xda,0x85,0x3f,0x41,0xbf,0xe0,0x5a,0x58,0x80,0x5f,0x66,0x0b,0xd8,0x90,
  39    0x35,0xd5,0xc0,0xa7,0x33,0x06,0x65,0x69,0x45,0x00,0x94,0x56,0x6d,0x98,0x9b,0x76,
  40    0x97,0xfc,0xb2,0xc2,0xb0,0xfe,0xdb,0x20,0xe1,0xeb,0xd6,0xe4,0xdd,0x47,0x4a,0x1d,
  41    0x42,0xed,0x9e,0x6e,0x49,0x3c,0xcd,0x43,0x27,0xd2,0x07,0xd4,0xde,0xc7,0x67,0x18,
  42    0x89,0xcb,0x30,0x1f,0x8d,0xc6,0x8f,0xaa,0xc8,0x74,0xdc,0xc9,0x5d,0x5c,0x31,0xa4,
  43    0x70,0x88,0x61,0x2c,0x9f,0x0d,0x2b,0x87,0x50,0x82,0x54,0x64,0x26,0x7d,0x03,0x40,
  44    0x34,0x4b,0x1c,0x73,0xd1,0xc4,0xfd,0x3b,0xcc,0xfb,0x7f,0xab,0xe6,0x3e,0x5b,0xa5,
  45    0xad,0x04,0x23,0x9c,0x14,0x51,0x22,0xf0,0x29,0x79,0x71,0x7e,0xff,0x8c,0x0e,0xe2,
  46    0x0c,0xef,0xbc,0x72,0x75,0x6f,0x37,0xa1,0xec,0xd3,0x8e,0x62,0x8b,0x86,0x10,0xe8,
  47    0x08,0x77,0x11,0xbe,0x92,0x4f,0x24,0xc5,0x32,0x36,0x9d,0xcf,0xf3,0xa6,0xbb,0xac,
  48    0x5e,0x6c,0xa9,0x13,0x57,0x25,0xb5,0xe3,0xbd,0xa8,0x3a,0x01,0x05,0x59,0x2a,0x46
  49 };
  50
  51 /* simple x + 1 (mod 10) in one step. */
  52 static const int keystep[] =  { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
  53
  54 /* simple x - 1 (mod 10) in one step */
  55 static const int ikeystep[] = { 9, 0, 1, 2, 3, 4, 5, 6, 7, 8 };
  56
  57  /**
  58     Initialize the Skipjack block cipher
  59     @param key The symmetric key you wish to pass
  60     @param keylen The key length in bytes
  61     @param num_rounds The number of rounds desired (0 for default)
  62     @param skey The key in as scheduled by this function.
  63     @return CRYPT_OK if successful
  64  */
  65 int skipjack_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey)
  66 {
  67    int x;
  68
  69    LTC_ARGCHK(key  != NULL);
  70    LTC_ARGCHK(skey != NULL);
  71
  72    if (keylen != 10) {
  73       return CRYPT_INVALID_KEYSIZE;
  74    }
  75
  76    if (num_rounds != 32 && num_rounds != 0) {
  77       return CRYPT_INVALID_ROUNDS;
  78    }
  79
  80    /* make sure the key is in range for platforms where CHAR_BIT != 8 */
  81    for (x = 0; x < 10; x++) {
  82        skey->skipjack.key[x] = key[x] & 255;
  83    }
  84
  85    return CRYPT_OK;
  86 }
  87
  88 #define RULE_A \
  89    tmp = g_func(w1, &kp, skey->skipjack.key);      \
  90    w1  = tmp ^ w4 ^ x;                            \
  91    w4  = w3; w3 = w2;                             \
  92    w2  = tmp;
  93
  94 #define RULE_B \
  95    tmp  = g_func(w1, &kp, skey->skipjack.key);     \
  96    tmp1 = w4; w4  = w3;                           \
  97    w3   = w1 ^ w2 ^ x;                            \
  98    w1   = tmp1; w2 = tmp;
  99
 100 #define RULE_A1 \
 101    tmp = w1 ^ w2 ^ x;                             \
 102    w1  = ig_func(w2, &kp, skey->skipjack.key);     \
 103    w2  = w3; w3 = w4; w4 = tmp;
 104
 105 #define RULE_B1 \
 106    tmp = ig_func(w2, &kp, skey->skipjack.key);     \
 107    w2  = tmp ^ w3 ^ x;                            \
 108    w3  = w4; w4 = w1; w1 = tmp;
 109
 110 static unsigned g_func(unsigned w, int *kp, unsigned char *key)
 111 {
 112    unsigned char g1,g2;
 113
 114    g1 = (w >> 8) & 255; g2 = w & 255;
 115    g1 ^= sbox[g2^key[*kp]]; *kp = keystep[*kp];
 116    g2 ^= sbox[g1^key[*kp]]; *kp = keystep[*kp];
 117    g1 ^= sbox[g2^key[*kp]]; *kp = keystep[*kp];
 118    g2 ^= sbox[g1^key[*kp]]; *kp = keystep[*kp];
 119    return ((unsigned)g1<<8)|(unsigned)g2;
 120 }
 121
 122 static unsigned ig_func(unsigned w, int *kp, unsigned char *key)
 123 {
 124    unsigned char g1,g2;
 125
 126    g1 = (w >> 8) & 255; g2 = w & 255;
 127    *kp = ikeystep[*kp]; g2 ^= sbox[g1^key[*kp]];
 128    *kp = ikeystep[*kp]; g1 ^= sbox[g2^key[*kp]];
 129    *kp = ikeystep[*kp]; g2 ^= sbox[g1^key[*kp]];
 130    *kp = ikeystep[*kp]; g1 ^= sbox[g2^key[*kp]];
 131    return ((unsigned)g1<<8)|(unsigned)g2;
 132 }
 133
 134 /**
 135   Encrypts a block of text with Skipjack
 136   @param pt The input plaintext (8 bytes)
 137   @param ct The output ciphertext (8 bytes)
 138   @param skey The key as scheduled
 139   @return CRYPT_OK if successful
 140 */
 141 #ifdef LTC_CLEAN_STACK
 142 static int _skipjack_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey)
 143 #else
 144 int skipjack_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey)
 145 #endif
 146 {
 147    unsigned w1,w2,w3,w4,tmp,tmp1;
 148    int x, kp;
 149
 150    LTC_ARGCHK(pt   != NULL);
 151    LTC_ARGCHK(ct   != NULL);
 152    LTC_ARGCHK(skey != NULL);
 153
 154    /* load block */
 155    w1 = ((unsigned)pt[0]<<8)|pt[1];
 156    w2 = ((unsigned)pt[2]<<8)|pt[3];
 157    w3 = ((unsigned)pt[4]<<8)|pt[5];
 158    w4 = ((unsigned)pt[6]<<8)|pt[7];
 159
 160    /* 8 rounds of RULE A */
 161    for (x = 1, kp = 0; x < 9; x++) {
 162        RULE_A;
 163    }
 164
 165    /* 8 rounds of RULE B */
 166    for (; x < 17; x++) {
 167        RULE_B;
 168    }
 169
 170    /* 8 rounds of RULE A */
 171    for (; x < 25; x++) {
 172        RULE_A;
 173    }
 174
 175    /* 8 rounds of RULE B */
 176    for (; x < 33; x++) {
 177        RULE_B;
 178    }
 179
 180    /* store block */
 181    ct[0] = (w1>>8)&255; ct[1] = w1&255;
 182    ct[2] = (w2>>8)&255; ct[3] = w2&255;
 183    ct[4] = (w3>>8)&255; ct[5] = w3&255;
 184    ct[6] = (w4>>8)&255; ct[7] = w4&255;
 185
 186    return CRYPT_OK;
 187 }
 188
 189 #ifdef LTC_CLEAN_STACK
 190 int skipjack_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey)
 191 {
 192    int err = _skipjack_ecb_encrypt(pt, ct, skey);
 193    burn_stack(sizeof(unsigned) * 8 + sizeof(int) * 2);
 194    return err;
 195 }
 196 #endif
 197
 198 /**
 199   Decrypts a block of text with Skipjack
 200   @param ct The input ciphertext (8 bytes)
 201   @param pt The output plaintext (8 bytes)
 202   @param skey The key as scheduled
 203   @return CRYPT_OK if successful
 204 */
 205 #ifdef LTC_CLEAN_STACK
 206 static int _skipjack_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey)
 207 #else
 208 int skipjack_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey)
 209 #endif
 210 {
 211    unsigned w1,w2,w3,w4,tmp;
 212    int x, kp;
 213
 214    LTC_ARGCHK(pt   != NULL);
 215    LTC_ARGCHK(ct   != NULL);
 216    LTC_ARGCHK(skey != NULL);
 217
 218    /* load block */
 219    w1 = ((unsigned)ct[0]<<8)|ct[1];
 220    w2 = ((unsigned)ct[2]<<8)|ct[3];
 221    w3 = ((unsigned)ct[4]<<8)|ct[5];
 222    w4 = ((unsigned)ct[6]<<8)|ct[7];
 223
 224    /* 8 rounds of RULE B^-1
 225
 226       Note the value "kp = 8" comes from "kp = (32 * 4) mod 10" where 32*4 is 128 which mod 10 is 8
 227     */
 228    for (x = 32, kp = 8; x > 24; x--) {
 229        RULE_B1;
 230    }
 231
 232    /* 8 rounds of RULE A^-1 */
 233    for (; x > 16; x--) {
 234        RULE_A1;
 235    }
 236
 237
 238    /* 8 rounds of RULE B^-1 */
 239    for (; x > 8; x--) {
 240        RULE_B1;
 241    }
 242
 243    /* 8 rounds of RULE A^-1 */
 244    for (; x > 0; x--) {
 245        RULE_A1;
 246    }
 247
 248    /* store block */
 249    pt[0] = (w1>>8)&255; pt[1] = w1&255;
 250    pt[2] = (w2>>8)&255; pt[3] = w2&255;
 251    pt[4] = (w3>>8)&255; pt[5] = w3&255;
 252    pt[6] = (w4>>8)&255; pt[7] = w4&255;
 253
 254    return CRYPT_OK;
 255 }
 256
 257 #ifdef LTC_CLEAN_STACK
 258 int skipjack_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey)
 259 {
 260    int err = _skipjack_ecb_decrypt(ct, pt, skey);
 261    burn_stack(sizeof(unsigned) * 7 + sizeof(int) * 2);
 262    return err;
 263 }
 264 #endif
 265
 266 /**
 267   Performs a self-test of the Skipjack block cipher
 268   @return CRYPT_OK if functional, CRYPT_NOP if self-test has been disabled
 269 */
 270 int skipjack_test(void)
 271 {
 272  #ifndef LTC_TEST
 273     return CRYPT_NOP;
 274  #else
 275    static const struct {
 276        unsigned char key[10], pt[8], ct[8];
 277    } tests[] = {
 278    {
 279        { 0x00, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 },
 280        { 0x33, 0x22, 0x11, 0x00, 0xdd, 0xcc, 0xbb, 0xaa },
 281        { 0x25, 0x87, 0xca, 0xe2, 0x7a, 0x12, 0xd3, 0x00 }
 282    }
 283    };
 284    unsigned char buf[2][8];
 285    int x, y, err;
 286    symmetric_key key;
 287
 288    for (x = 0; x < (int)(sizeof(tests) / sizeof(tests[0])); x++) {
 289       /* setup key */
 290       if ((err = skipjack_setup(tests[x].key, 10, 0, &key)) != CRYPT_OK) {
 291          return err;
 292       }
 293
 294       /* encrypt and decrypt */
 295       skipjack_ecb_encrypt(tests[x].pt, buf[0], &key);
 296       skipjack_ecb_decrypt(buf[0], buf[1], &key);
 297
 298       /* compare */
 299       if (compare_testvector(buf[0], 8, tests[x].ct, 8, "Skipjack Encrypt", x) != 0 ||
 300             compare_testvector(buf[1], 8, tests[x].pt, 8, "Skipjack Decrypt", x) != 0) {
 301          return CRYPT_FAIL_TESTVECTOR;
 302       }
 303
 304       /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
 305       for (y = 0; y < 8; y++) buf[0][y] = 0;
 306       for (y = 0; y < 1000; y++) skipjack_ecb_encrypt(buf[0], buf[0], &key);
 307       for (y = 0; y < 1000; y++) skipjack_ecb_decrypt(buf[0], buf[0], &key);
 308       for (y = 0; y < 8; y++) if (buf[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
 309    }
 310
 311    return CRYPT_OK;
 312   #endif
 313 }
 314
 315 /** Terminate the context
 316    @param skey    The scheduled key
 317 */
 318 void skipjack_done(symmetric_key *skey)
 319 {
 320   LTC_UNUSED_PARAM(skey);
 321 }
 322
 323 /**
 324   Gets suitable key size
 325   @param keysize [in/out] The length of the recommended key (in bytes).  This function will store the suitable size back in this variable.
 326   @return CRYPT_OK if the input key size is acceptable.
 327 */
 328 int skipjack_keysize(int *keysize)
 329 {
 330    LTC_ARGCHK(keysize != NULL);
 331    if (*keysize < 10) {
 332       return CRYPT_INVALID_KEYSIZE;
 333    } else if (*keysize > 10) {
 334       *keysize = 10;
 335    }
 336    return CRYPT_OK;
 337 }
 338
 339 #endif
 340
 341 /* ref:         $Format:%D$ */
 342 /* git commit:  $Format:%H$ */
 343 /* commit time: $Format:%ai$ */