pd.if.org Git - zpackage/blob - libtomcrypt/src/ciphers/rc5.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 rc5.c
  12    LTC_RC5 code by Tom St Denis
  13 */
  14
  15 #include "tomcrypt.h"
  16
  17 #ifdef LTC_RC5
  18
  19 const struct ltc_cipher_descriptor rc5_desc =
  20 {
  21     "rc5",
  22     2,
  23     8, 128, 8, 12,
  24     &rc5_setup,
  25     &rc5_ecb_encrypt,
  26     &rc5_ecb_decrypt,
  27     &rc5_test,
  28     &rc5_done,
  29     &rc5_keysize,
  30     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  31 };
  32
  33 static const ulong32 stab[50] = {
  34 0xb7e15163UL, 0x5618cb1cUL, 0xf45044d5UL, 0x9287be8eUL, 0x30bf3847UL, 0xcef6b200UL, 0x6d2e2bb9UL, 0x0b65a572UL,
  35 0xa99d1f2bUL, 0x47d498e4UL, 0xe60c129dUL, 0x84438c56UL, 0x227b060fUL, 0xc0b27fc8UL, 0x5ee9f981UL, 0xfd21733aUL,
  36 0x9b58ecf3UL, 0x399066acUL, 0xd7c7e065UL, 0x75ff5a1eUL, 0x1436d3d7UL, 0xb26e4d90UL, 0x50a5c749UL, 0xeedd4102UL,
  37 0x8d14babbUL, 0x2b4c3474UL, 0xc983ae2dUL, 0x67bb27e6UL, 0x05f2a19fUL, 0xa42a1b58UL, 0x42619511UL, 0xe0990ecaUL,
  38 0x7ed08883UL, 0x1d08023cUL, 0xbb3f7bf5UL, 0x5976f5aeUL, 0xf7ae6f67UL, 0x95e5e920UL, 0x341d62d9UL, 0xd254dc92UL,
  39 0x708c564bUL, 0x0ec3d004UL, 0xacfb49bdUL, 0x4b32c376UL, 0xe96a3d2fUL, 0x87a1b6e8UL, 0x25d930a1UL, 0xc410aa5aUL,
  40 0x62482413UL, 0x007f9dccUL
  41 };
  42
  43  /**
  44     Initialize the LTC_RC5 block cipher
  45     @param key The symmetric key you wish to pass
  46     @param keylen The key length in bytes
  47     @param num_rounds The number of rounds desired (0 for default)
  48     @param skey The key in as scheduled by this function.
  49     @return CRYPT_OK if successful
  50  */
  51 #ifdef LTC_CLEAN_STACK
  52 static int _rc5_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey)
  53 #else
  54 int rc5_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey)
  55 #endif
  56 {
  57     ulong32 L[64], *S, A, B, i, j, v, s, t, l;
  58
  59     LTC_ARGCHK(skey != NULL);
  60     LTC_ARGCHK(key  != NULL);
  61
  62     /* test parameters */
  63     if (num_rounds == 0) {
  64        num_rounds = rc5_desc.default_rounds;
  65     }
  66
  67     if (num_rounds < 12 || num_rounds > 24) {
  68        return CRYPT_INVALID_ROUNDS;
  69     }
  70
  71     /* key must be between 64 and 1024 bits */
  72     if (keylen < 8 || keylen > 128) {
  73        return CRYPT_INVALID_KEYSIZE;
  74     }
  75
  76     skey->rc5.rounds = num_rounds;
  77     S = skey->rc5.K;
  78
  79     /* copy the key into the L array */
  80     for (A = i = j = 0; i < (ulong32)keylen; ) {
  81         A = (A << 8) | ((ulong32)(key[i++] & 255));
  82         if ((i & 3) == 0) {
  83            L[j++] = BSWAP(A);
  84            A = 0;
  85         }
  86     }
  87
  88     if ((keylen & 3) != 0) {
  89        A <<= (ulong32)((8 * (4 - (keylen&3))));
  90        L[j++] = BSWAP(A);
  91     }
  92
  93     /* setup the S array */
  94     t = (ulong32)(2 * (num_rounds + 1));
  95     XMEMCPY(S, stab, t * sizeof(*S));
  96
  97     /* mix buffer */
  98     s = 3 * MAX(t, j);
  99     l = j;
 100     for (A = B = i = j = v = 0; v < s; v++) {
 101         A = S[i] = ROLc(S[i] + A + B, 3);
 102         B = L[j] = ROL(L[j] + A + B, (A+B));
 103         if (++i == t) { i = 0; }
 104         if (++j == l) { j = 0; }
 105     }
 106     return CRYPT_OK;
 107 }
 108
 109 #ifdef LTC_CLEAN_STACK
 110 int rc5_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey)
 111 {
 112    int x;
 113    x = _rc5_setup(key, keylen, num_rounds, skey);
 114    burn_stack(sizeof(ulong32) * 122 + sizeof(int));
 115    return x;
 116 }
 117 #endif
 118
 119 /**
 120   Encrypts a block of text with LTC_RC5
 121   @param pt The input plaintext (8 bytes)
 122   @param ct The output ciphertext (8 bytes)
 123   @param skey The key as scheduled
 124   @return CRYPT_OK if successful
 125 */
 126 #ifdef LTC_CLEAN_STACK
 127 static int _rc5_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey)
 128 #else
 129 int rc5_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey)
 130 #endif
 131 {
 132    ulong32 A, B, *K;
 133    int r;
 134    LTC_ARGCHK(skey != NULL);
 135    LTC_ARGCHK(pt   != NULL);
 136    LTC_ARGCHK(ct   != NULL);
 137
 138    LOAD32L(A, &pt[0]);
 139    LOAD32L(B, &pt[4]);
 140    A += skey->rc5.K[0];
 141    B += skey->rc5.K[1];
 142    K  = skey->rc5.K + 2;
 143
 144    if ((skey->rc5.rounds & 1) == 0) {
 145       for (r = 0; r < skey->rc5.rounds; r += 2) {
 146           A = ROL(A ^ B, B) + K[0];
 147           B = ROL(B ^ A, A) + K[1];
 148           A = ROL(A ^ B, B) + K[2];
 149           B = ROL(B ^ A, A) + K[3];
 150           K += 4;
 151       }
 152    } else {
 153       for (r = 0; r < skey->rc5.rounds; r++) {
 154           A = ROL(A ^ B, B) + K[0];
 155           B = ROL(B ^ A, A) + K[1];
 156           K += 2;
 157       }
 158    }
 159    STORE32L(A, &ct[0]);
 160    STORE32L(B, &ct[4]);
 161
 162    return CRYPT_OK;
 163 }
 164
 165 #ifdef LTC_CLEAN_STACK
 166 int rc5_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey)
 167 {
 168    int err = _rc5_ecb_encrypt(pt, ct, skey);
 169    burn_stack(sizeof(ulong32) * 2 + sizeof(int));
 170    return err;
 171 }
 172 #endif
 173
 174 /**
 175   Decrypts a block of text with LTC_RC5
 176   @param ct The input ciphertext (8 bytes)
 177   @param pt The output plaintext (8 bytes)
 178   @param skey The key as scheduled
 179   @return CRYPT_OK if successful
 180 */
 181 #ifdef LTC_CLEAN_STACK
 182 static int _rc5_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey)
 183 #else
 184 int rc5_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey)
 185 #endif
 186 {
 187    ulong32 A, B, *K;
 188    int r;
 189    LTC_ARGCHK(skey != NULL);
 190    LTC_ARGCHK(pt   != NULL);
 191    LTC_ARGCHK(ct   != NULL);
 192
 193    LOAD32L(A, &ct[0]);
 194    LOAD32L(B, &ct[4]);
 195    K = skey->rc5.K + (skey->rc5.rounds << 1);
 196
 197    if ((skey->rc5.rounds & 1) == 0) {
 198        K -= 2;
 199        for (r = skey->rc5.rounds - 1; r >= 0; r -= 2) {
 200           B = ROR(B - K[3], A) ^ A;
 201           A = ROR(A - K[2], B) ^ B;
 202           B = ROR(B - K[1], A) ^ A;
 203           A = ROR(A - K[0], B) ^ B;
 204           K -= 4;
 205         }
 206    } else {
 207       for (r = skey->rc5.rounds - 1; r >= 0; r--) {
 208           B = ROR(B - K[1], A) ^ A;
 209           A = ROR(A - K[0], B) ^ B;
 210           K -= 2;
 211       }
 212    }
 213    A -= skey->rc5.K[0];
 214    B -= skey->rc5.K[1];
 215    STORE32L(A, &pt[0]);
 216    STORE32L(B, &pt[4]);
 217
 218    return CRYPT_OK;
 219 }
 220
 221 #ifdef LTC_CLEAN_STACK
 222 int rc5_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey)
 223 {
 224    int err = _rc5_ecb_decrypt(ct, pt, skey);
 225    burn_stack(sizeof(ulong32) * 2 + sizeof(int));
 226    return err;
 227 }
 228 #endif
 229
 230 /**
 231   Performs a self-test of the LTC_RC5 block cipher
 232   @return CRYPT_OK if functional, CRYPT_NOP if self-test has been disabled
 233 */
 234 int rc5_test(void)
 235 {
 236  #ifndef LTC_TEST
 237     return CRYPT_NOP;
 238  #else
 239    static const struct {
 240        unsigned char key[16], pt[8], ct[8];
 241    } tests[] = {
 242    {
 243        { 0x91, 0x5f, 0x46, 0x19, 0xbe, 0x41, 0xb2, 0x51,
 244          0x63, 0x55, 0xa5, 0x01, 0x10, 0xa9, 0xce, 0x91 },
 245        { 0x21, 0xa5, 0xdb, 0xee, 0x15, 0x4b, 0x8f, 0x6d },
 246        { 0xf7, 0xc0, 0x13, 0xac, 0x5b, 0x2b, 0x89, 0x52 }
 247    },
 248    {
 249        { 0x78, 0x33, 0x48, 0xe7, 0x5a, 0xeb, 0x0f, 0x2f,
 250          0xd7, 0xb1, 0x69, 0xbb, 0x8d, 0xc1, 0x67, 0x87 },
 251        { 0xF7, 0xC0, 0x13, 0xAC, 0x5B, 0x2B, 0x89, 0x52 },
 252        { 0x2F, 0x42, 0xB3, 0xB7, 0x03, 0x69, 0xFC, 0x92 }
 253    },
 254    {
 255        { 0xDC, 0x49, 0xdb, 0x13, 0x75, 0xa5, 0x58, 0x4f,
 256          0x64, 0x85, 0xb4, 0x13, 0xb5, 0xf1, 0x2b, 0xaf },
 257        { 0x2F, 0x42, 0xB3, 0xB7, 0x03, 0x69, 0xFC, 0x92 },
 258        { 0x65, 0xc1, 0x78, 0xb2, 0x84, 0xd1, 0x97, 0xcc }
 259    }
 260    };
 261    unsigned char tmp[2][8];
 262    int x, y, err;
 263    symmetric_key key;
 264
 265    for (x = 0; x < (int)(sizeof(tests) / sizeof(tests[0])); x++) {
 266       /* setup key */
 267       if ((err = rc5_setup(tests[x].key, 16, 12, &key)) != CRYPT_OK) {
 268          return err;
 269       }
 270
 271       /* encrypt and decrypt */
 272       rc5_ecb_encrypt(tests[x].pt, tmp[0], &key);
 273       rc5_ecb_decrypt(tmp[0], tmp[1], &key);
 274
 275       /* compare */
 276       if (compare_testvector(tmp[0], 8, tests[x].ct, 8, "RC5 Encrypt", x) != 0 ||
 277             compare_testvector(tmp[1], 8, tests[x].pt, 8, "RC5 Decrypt", x) != 0) {
 278          return CRYPT_FAIL_TESTVECTOR;
 279       }
 280
 281       /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
 282       for (y = 0; y < 8; y++) tmp[0][y] = 0;
 283       for (y = 0; y < 1000; y++) rc5_ecb_encrypt(tmp[0], tmp[0], &key);
 284       for (y = 0; y < 1000; y++) rc5_ecb_decrypt(tmp[0], tmp[0], &key);
 285       for (y = 0; y < 8; y++) if (tmp[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
 286    }
 287    return CRYPT_OK;
 288   #endif
 289 }
 290
 291 /** Terminate the context
 292    @param skey    The scheduled key
 293 */
 294 void rc5_done(symmetric_key *skey)
 295 {
 296   LTC_UNUSED_PARAM(skey);
 297 }
 298
 299 /**
 300   Gets suitable key size
 301   @param keysize [in/out] The length of the recommended key (in bytes).  This function will store the suitable size back in this variable.
 302   @return CRYPT_OK if the input key size is acceptable.
 303 */
 304 int rc5_keysize(int *keysize)
 305 {
 306    LTC_ARGCHK(keysize != NULL);
 307    if (*keysize < 8) {
 308       return CRYPT_INVALID_KEYSIZE;
 309    } else if (*keysize > 128) {
 310       *keysize = 128;
 311    }
 312    return CRYPT_OK;
 313 }
 314
 315 #endif
 316
 317
 318
 319
 320 /* ref:         $Format:%D$ */
 321 /* git commit:  $Format:%H$ */
 322 /* commit time: $Format:%ai$ */