8 #include <botan/cast256.h>     9 #include <botan/loadstor.h>    10 #include <botan/rotate.h>    53    for(
size_t i = 0; i != blocks; ++i)
    60       round1(C, D, MK[ 0], RK[ 0]); round2(B, C, MK[ 1], RK[ 1]);
    61       round3(A, B, MK[ 2], RK[ 2]); round1(D, A, MK[ 3], RK[ 3]);
    62       round1(C, D, MK[ 4], RK[ 4]); round2(B, C, MK[ 5], RK[ 5]);
    63       round3(A, B, MK[ 6], RK[ 6]); round1(D, A, MK[ 7], RK[ 7]);
    64       round1(C, D, MK[ 8], RK[ 8]); round2(B, C, MK[ 9], RK[ 9]);
    65       round3(A, B, MK[10], RK[10]); round1(D, A, MK[11], RK[11]);
    66       round1(C, D, MK[12], RK[12]); round2(B, C, MK[13], RK[13]);
    67       round3(A, B, MK[14], RK[14]); round1(D, A, MK[15], RK[15]);
    68       round1(C, D, MK[16], RK[16]); round2(B, C, MK[17], RK[17]);
    69       round3(A, B, MK[18], RK[18]); round1(D, A, MK[19], RK[19]);
    70       round1(C, D, MK[20], RK[20]); round2(B, C, MK[21], RK[21]);
    71       round3(A, B, MK[22], RK[22]); round1(D, A, MK[23], RK[23]);
    72       round1(D, A, MK[27], RK[27]); round3(A, B, MK[26], RK[26]);
    73       round2(B, C, MK[25], RK[25]); round1(C, D, MK[24], RK[24]);
    74       round1(D, A, MK[31], RK[31]); round3(A, B, MK[30], RK[30]);
    75       round2(B, C, MK[29], RK[29]); round1(C, D, MK[28], RK[28]);
    76       round1(D, A, MK[35], RK[35]); round3(A, B, MK[34], RK[34]);
    77       round2(B, C, MK[33], RK[33]); round1(C, D, MK[32], RK[32]);
    78       round1(D, A, MK[39], RK[39]); round3(A, B, MK[38], RK[38]);
    79       round2(B, C, MK[37], RK[37]); round1(C, D, MK[36], RK[36]);
    80       round1(D, A, MK[43], RK[43]); round3(A, B, MK[42], RK[42]);
    81       round2(B, C, MK[41], RK[41]); round1(C, D, MK[40], RK[40]);
    82       round1(D, A, MK[47], RK[47]); round3(A, B, MK[46], RK[46]);
    83       round2(B, C, MK[45], RK[45]); round1(C, D, MK[44], RK[44]);
    97    for(
size_t i = 0; i != blocks; ++i)
   104       round1(C, D, MK[44], RK[44]); round2(B, C, MK[45], RK[45]);
   105       round3(A, B, MK[46], RK[46]); round1(D, A, MK[47], RK[47]);
   106       round1(C, D, MK[40], RK[40]); round2(B, C, MK[41], RK[41]);
   107       round3(A, B, MK[42], RK[42]); round1(D, A, MK[43], RK[43]);
   108       round1(C, D, MK[36], RK[36]); round2(B, C, MK[37], RK[37]);
   109       round3(A, B, MK[38], RK[38]); round1(D, A, MK[39], RK[39]);
   110       round1(C, D, MK[32], RK[32]); round2(B, C, MK[33], RK[33]);
   111       round3(A, B, MK[34], RK[34]); round1(D, A, MK[35], RK[35]);
   112       round1(C, D, MK[28], RK[28]); round2(B, C, MK[29], RK[29]);
   113       round3(A, B, MK[30], RK[30]); round1(D, A, MK[31], RK[31]);
   114       round1(C, D, MK[24], RK[24]); round2(B, C, MK[25], RK[25]);
   115       round3(A, B, MK[26], RK[26]); round1(D, A, MK[27], RK[27]);
   116       round1(D, A, MK[23], RK[23]); round3(A, B, MK[22], RK[22]);
   117       round2(B, C, MK[21], RK[21]); round1(C, D, MK[20], RK[20]);
   118       round1(D, A, MK[19], RK[19]); round3(A, B, MK[18], RK[18]);
   119       round2(B, C, MK[17], RK[17]); round1(C, D, MK[16], RK[16]);
   120       round1(D, A, MK[15], RK[15]); round3(A, B, MK[14], RK[14]);
   121       round2(B, C, MK[13], RK[13]); round1(C, D, MK[12], RK[12]);
   122       round1(D, A, MK[11], RK[11]); round3(A, B, MK[10], RK[10]);
   123       round2(B, C, MK[ 9], RK[ 9]); round1(C, D, MK[ 8], RK[ 8]);
   124       round1(D, A, MK[ 7], RK[ 7]); round3(A, B, MK[ 6], RK[ 6]);
   125       round2(B, C, MK[ 5], RK[ 5]); round1(C, D, MK[ 4], RK[ 4]);
   126       round1(D, A, MK[ 3], RK[ 3]); round3(A, B, MK[ 2], RK[ 2]);
   127       round2(B, C, MK[ 1], RK[ 1]); round1(C, D, MK[ 0], RK[ 0]);
   139 void CAST_256::key_schedule(
const byte key[], 
size_t length)
   142    for(
size_t j = 0; j != length; ++j)
   143       K[j/4] = (K[j/4] << 8) + key[j];
   145    u32bit A = K[0], B = K[1], C = K[2], D = K[3],
   146           E = K[4], F = K[5], G = K[6], H = K[7];
   148    for(
size_t j = 0; j != 48; j += 4)
   150       round1(G, H, KEY_MASK[4*j+ 0], KEY_ROT[(4*j+ 0) % 32]);
   151       round2(F, G, KEY_MASK[4*j+ 1], KEY_ROT[(4*j+ 1) % 32]);
   152       round3(E, F, KEY_MASK[4*j+ 2], KEY_ROT[(4*j+ 2) % 32]);
   153       round1(D, E, KEY_MASK[4*j+ 3], KEY_ROT[(4*j+ 3) % 32]);
   154       round2(C, D, KEY_MASK[4*j+ 4], KEY_ROT[(4*j+ 4) % 32]);
   155       round3(B, C, KEY_MASK[4*j+ 5], KEY_ROT[(4*j+ 5) % 32]);
   156       round1(A, B, KEY_MASK[4*j+ 6], KEY_ROT[(4*j+ 6) % 32]);
   157       round2(H, A, KEY_MASK[4*j+ 7], KEY_ROT[(4*j+ 7) % 32]);
   158       round1(G, H, KEY_MASK[4*j+ 8], KEY_ROT[(4*j+ 8) % 32]);
   159       round2(F, G, KEY_MASK[4*j+ 9], KEY_ROT[(4*j+ 9) % 32]);
   160       round3(E, F, KEY_MASK[4*j+10], KEY_ROT[(4*j+10) % 32]);
   161       round1(D, E, KEY_MASK[4*j+11], KEY_ROT[(4*j+11) % 32]);
   162       round2(C, D, KEY_MASK[4*j+12], KEY_ROT[(4*j+12) % 32]);
   163       round3(B, C, KEY_MASK[4*j+13], KEY_ROT[(4*j+13) % 32]);
   164       round1(A, B, KEY_MASK[4*j+14], KEY_ROT[(4*j+14) % 32]);
   165       round2(H, A, KEY_MASK[4*j+15], KEY_ROT[(4*j+15) % 32]);
 const u32bit CAST_SBOX2[256]
const u32bit CAST_SBOX1[256]
T rotate_left(T input, size_t rot)
byte get_byte(size_t byte_num, T input)
void decrypt_n(const byte in[], byte out[], size_t blocks) const
const u32bit CAST_SBOX4[256]
u32bit load_be< u32bit >(const byte in[], size_t off)
void store_be(u16bit in, byte out[2])
void encrypt_n(const byte in[], byte out[], size_t blocks) const
const u32bit CAST_SBOX3[256]