lib/silccrypt/ciphers_def.h

   1 /*
   2
   3   ciphers_def.h
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1999 - 2008 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19
  20 #ifndef CIPHERS_DEF_H
  21 #define CIPHERS_DEF_H
  22
  23
  24 #include "silclog.h"
  25
  26 /* General definitions for algorithms */
  27 typedef unsigned char u1byte;
  28 typedef SilcUInt32 u4byte;
  29 typedef SilcUInt32 u32;
  30 typedef SilcUInt32 uint_32t;
  31 typedef SilcUInt8 uint_8t;
  32
  33 #define rotr(x, nr) silc_ror(x, nr)
  34 #define rotl(x, nr) silc_rol(x, nr)
  35 #define byte(x, nr) ((x) >> (nr * 8) & 255)
  36
  37 /* Byte key to words */
  38 #define SILC_GET_WORD_KEY(s, d, len)            \
  39 do {                                            \
  40   int _i;                                       \
  41   for (_i = 0; _i < (len / 8) / 4; _i++)        \
  42     SILC_GET32_LSB(d[_i], s + (_i * 4));        \
  43 } while(0);
  44
  45 /* CBC mode 128-bit block, LSB, 32-bit block argument must be encrypted */
  46
  47 #define SILC_CBC_ENC_LSB_128_32(len, iv, block, src, dst, i, enc)       \
  48 do {                                                                    \
  49   SILC_ASSERT((len & (16 - 1)) == 0);                                   \
  50   if (len & (16 - 1))                                                   \
  51     return FALSE;                                                       \
  52                                                                         \
  53   SILC_GET32_LSB(block[0], &iv[0]);                                     \
  54   SILC_GET32_LSB(block[1], &iv[4]);                                     \
  55   SILC_GET32_LSB(block[2], &iv[8]);                                     \
  56   SILC_GET32_LSB(block[3], &iv[12]);                                    \
  57                                                                         \
  58   for (i = 0; i < len; i += 16) {                                       \
  59     SILC_GET32_X_LSB(block[0], &src[0]);                                \
  60     SILC_GET32_X_LSB(block[1], &src[4]);                                \
  61     SILC_GET32_X_LSB(block[2], &src[8]);                                \
  62     SILC_GET32_X_LSB(block[3], &src[12]);                               \
  63                                                                         \
  64     enc;                                                                \
  65                                                                         \
  66     SILC_PUT32_LSB(block[0], &dst[0]);                                  \
  67     SILC_PUT32_LSB(block[1], &dst[4]);                                  \
  68     SILC_PUT32_LSB(block[2], &dst[8]);                                  \
  69     SILC_PUT32_LSB(block[3], &dst[12]);                                 \
  70                                                                         \
  71     dst += 16;                                                          \
  72     src += 16;                                                          \
  73   }                                                                     \
  74                                                                         \
  75   SILC_PUT32_LSB(block[0], &iv[0]);                                     \
  76   SILC_PUT32_LSB(block[1], &iv[4]);                                     \
  77   SILC_PUT32_LSB(block[2], &iv[8]);                                     \
  78   SILC_PUT32_LSB(block[3], &iv[12]);                                    \
  79 } while(0)
  80
  81 /* CBC mode 128-bit block, LSB, decrypt block to block_dec. */
  82
  83 #define SILC_CBC_DEC_LSB_128_32(len, iv, block_prev, block,             \
  84                                 block_dec, src, dst, i, dec)            \
  85 do {                                                                    \
  86   if (!len || len & (16 - 1))                                           \
  87     return FALSE;                                                       \
  88                                                                         \
  89   SILC_GET32_LSB(block_prev[0], &iv[0]);                                \
  90   SILC_GET32_LSB(block_prev[1], &iv[4]);                                \
  91   SILC_GET32_LSB(block_prev[2], &iv[8]);                                \
  92   SILC_GET32_LSB(block_prev[3], &iv[12]);                               \
  93                                                                         \
  94   for (i = 0; i < len; i += 16) {                                       \
  95     SILC_GET32_LSB(block[0], &src[0]);                                  \
  96     SILC_GET32_LSB(block[1], &src[4]);                                  \
  97     SILC_GET32_LSB(block[2], &src[8]);                                  \
  98     SILC_GET32_LSB(block[3], &src[12]);                                 \
  99                                                                         \
 100     dec;                                                                \
 101                                                                         \
 102     block_dec[0] ^= block_prev[0];                                      \
 103     block_dec[1] ^= block_prev[1];                                      \
 104     block_dec[2] ^= block_prev[2];                                      \
 105     block_dec[3] ^= block_prev[3];                                      \
 106                                                                         \
 107     SILC_PUT32_LSB(block_dec[0], &dst[0]);                              \
 108     SILC_PUT32_LSB(block_dec[1], &dst[4]);                              \
 109     SILC_PUT32_LSB(block_dec[2], &dst[8]);                              \
 110     SILC_PUT32_LSB(block_dec[3], &dst[12]);                             \
 111                                                                         \
 112     block_prev[0] = block[0];                                           \
 113     block_prev[1] = block[1];                                           \
 114     block_prev[2] = block[2];                                           \
 115     block_prev[3] = block[3];                                           \
 116                                                                         \
 117     dst += 16;                                                          \
 118     src += 16;                                                          \
 119   }                                                                     \
 120                                                                         \
 121   SILC_PUT32_LSB(block[0], &iv[0]);                                     \
 122   SILC_PUT32_LSB(block[1], &iv[4]);                                     \
 123   SILC_PUT32_LSB(block[2], &iv[8]);                                     \
 124   SILC_PUT32_LSB(block[3], &iv[12]);                                    \
 125 } while(0)
 126
 127 /* CBC mode 128-bit block, MSB, 32-bit block argument must be encrypted */
 128
 129 #define SILC_CBC_ENC_MSB_128_32(len, iv, block, src, dst, i, enc)       \
 130 do {                                                                    \
 131   SILC_ASSERT((len & (16 - 1)) == 0);                                   \
 132   if (len & (16 - 1))                                                   \
 133     return FALSE;                                                       \
 134                                                                         \
 135   SILC_GET32_MSB(block[0], &iv[0]);                                     \
 136   SILC_GET32_MSB(block[1], &iv[4]);                                     \
 137   SILC_GET32_MSB(block[2], &iv[8]);                                     \
 138   SILC_GET32_MSB(block[3], &iv[12]);                                    \
 139                                                                         \
 140   for (i = 0; i < len; i += 16) {                                       \
 141     SILC_GET32_X_MSB(block[0], &src[0]);                                \
 142     SILC_GET32_X_MSB(block[1], &src[4]);                                \
 143     SILC_GET32_X_MSB(block[2], &src[8]);                                \
 144     SILC_GET32_X_MSB(block[3], &src[12]);                               \
 145                                                                         \
 146     enc;                                                                \
 147                                                                         \
 148     SILC_PUT32_MSB(block[0], &dst[0]);                                  \
 149     SILC_PUT32_MSB(block[1], &dst[4]);                                  \
 150     SILC_PUT32_MSB(block[2], &dst[8]);                                  \
 151     SILC_PUT32_MSB(block[3], &dst[12]);                                 \
 152                                                                         \
 153     dst += 16;                                                          \
 154     src += 16;                                                          \
 155   }                                                                     \
 156                                                                         \
 157   SILC_PUT32_MSB(block[0], &iv[0]);                                     \
 158   SILC_PUT32_MSB(block[1], &iv[4]);                                     \
 159   SILC_PUT32_MSB(block[2], &iv[8]);                                     \
 160   SILC_PUT32_MSB(block[3], &iv[12]);                                    \
 161 } while(0)
 162
 163 /* CBC mode 128-bit block, MSB, decrypt block to block_dec. */
 164
 165 #define SILC_CBC_DEC_MSB_128_32(len, iv, block_prev, block,             \
 166                                 block_dec, src, dst, i, dec)            \
 167 do {                                                                    \
 168   if (!len || len & (16 - 1))                                           \
 169     return FALSE;                                                       \
 170                                                                         \
 171   SILC_GET32_MSB(block_prev[0], &iv[0]);                                \
 172   SILC_GET32_MSB(block_prev[1], &iv[4]);                                \
 173   SILC_GET32_MSB(block_prev[2], &iv[8]);                                \
 174   SILC_GET32_MSB(block_prev[3], &iv[12]);                               \
 175                                                                         \
 176   for (i = 0; i < len; i += 16) {                                       \
 177     SILC_GET32_MSB(block[0], &src[0]);                                  \
 178     SILC_GET32_MSB(block[1], &src[4]);                                  \
 179     SILC_GET32_MSB(block[2], &src[8]);                                  \
 180     SILC_GET32_MSB(block[3], &src[12]);                                 \
 181                                                                         \
 182     dec;                                                                \
 183                                                                         \
 184     block_dec[0] ^= block_prev[0];                                      \
 185     block_dec[1] ^= block_prev[1];                                      \
 186     block_dec[2] ^= block_prev[2];                                      \
 187     block_dec[3] ^= block_prev[3];                                      \
 188                                                                         \
 189     SILC_PUT32_MSB(block_dec[0], &dst[0]);                              \
 190     SILC_PUT32_MSB(block_dec[1], &dst[4]);                              \
 191     SILC_PUT32_MSB(block_dec[2], &dst[8]);                              \
 192     SILC_PUT32_MSB(block_dec[3], &dst[12]);                             \
 193                                                                         \
 194     block_prev[0] = block[0];                                           \
 195     block_prev[1] = block[1];                                           \
 196     block_prev[2] = block[2];                                           \
 197     block_prev[3] = block[3];                                           \
 198                                                                         \
 199     dst += 16;                                                          \
 200     src += 16;                                                          \
 201   }                                                                     \
 202                                                                         \
 203   SILC_PUT32_MSB(block[0], &iv[0]);                                     \
 204   SILC_PUT32_MSB(block[1], &iv[4]);                                     \
 205   SILC_PUT32_MSB(block[2], &iv[8]);                                     \
 206   SILC_PUT32_MSB(block[3], &iv[12]);                                    \
 207 } while(0)
 208
 209 /* CBC mode 64-bit block, MSB, 32-bit block argument must be encrypted */
 210
 211 #define SILC_CBC_ENC_MSB_64_32(len, iv, block, src, dst, i, enc)        \
 212 do {                                                                    \
 213   SILC_ASSERT((len & (8 - 1)) == 0);                                    \
 214   if (len & (8 - 1))                                                    \
 215     return FALSE;                                                       \
 216                                                                         \
 217   SILC_GET32_MSB(block[0], &iv[0]);                                     \
 218   SILC_GET32_MSB(block[1], &iv[4]);                                     \
 219                                                                         \
 220   for (i = 0; i < len; i += 8) {                                        \
 221     SILC_GET32_X_MSB(block[0], &src[0]);                                \
 222     SILC_GET32_X_MSB(block[1], &src[4]);                                \
 223                                                                         \
 224     enc;                                                                \
 225                                                                         \
 226     SILC_PUT32_MSB(block[0], &dst[0]);                                  \
 227     SILC_PUT32_MSB(block[1], &dst[4]);                                  \
 228                                                                         \
 229     dst += 8;                                                           \
 230     src += 8;                                                           \
 231   }                                                                     \
 232                                                                         \
 233   SILC_PUT32_MSB(block[0], &iv[0]);                                     \
 234   SILC_PUT32_MSB(block[1], &iv[4]);                                     \
 235 } while(0)
 236
 237 /* CBC mode 64-bit block, MSB, decrypt block to block_dec. */
 238
 239 #define SILC_CBC_DEC_MSB_64_32(len, iv, block_prev, block,              \
 240                                block_dec, src, dst, i, dec)             \
 241 do {                                                                    \
 242   if (!len || len & (8 - 1))                                            \
 243     return FALSE;                                                       \
 244                                                                         \
 245   SILC_GET32_MSB(block_prev[0], &iv[0]);                                \
 246   SILC_GET32_MSB(block_prev[1], &iv[4]);                                \
 247                                                                         \
 248   for (i = 0; i < len; i += 8) {                                        \
 249     SILC_GET32_MSB(block[0], &src[0]);                                  \
 250     SILC_GET32_MSB(block[1], &src[4]);                                  \
 251                                                                         \
 252     dec;                                                                \
 253                                                                         \
 254     block_dec[0] ^= block_prev[0];                                      \
 255     block_dec[1] ^= block_prev[1];                                      \
 256                                                                         \
 257     SILC_PUT32_MSB(block_dec[0], &dst[0]);                              \
 258     SILC_PUT32_MSB(block_dec[1], &dst[4]);                              \
 259                                                                         \
 260     block_prev[0] = block[0];                                           \
 261     block_prev[1] = block[1];                                           \
 262                                                                         \
 263     dst += 8;                                                           \
 264     src += 8;                                                           \
 265   }                                                                     \
 266                                                                         \
 267   SILC_PUT32_MSB(block[0], &iv[0]);                                     \
 268   SILC_PUT32_MSB(block[1], &iv[4]);                                     \
 269 } while(0)
 270
 271 #ifndef WORDS_BIGENDIAN
 272
 273 /* CTR mode 128-bit block, MSB, MSB counter, the 8-bit ctr argument must
 274    be encrypted to enc_ctr */
 275
 276 #define SILC_CTR_MSB_128_8(ctr, enc_ctr, pad, src, dst, enc)            \
 277 do {                                                                    \
 278   while (len > 0) {                                                     \
 279     if (pad == 16) {                                                    \
 280       for (i = 15; i >= 0; i--)                                         \
 281         if (++ctr[i])                                                   \
 282           break;                                                        \
 283                                                                         \
 284       enc;                                                              \
 285                                                                         \
 286       if (len >= 16) {                                                  \
 287         *(SilcUInt64 *)dst = *(SilcUInt64 *)src ^ *(SilcUInt64 *)enc_ctr; \
 288         *(SilcUInt64 *)(dst + 8) = *(SilcUInt64 *)(src + 8) ^           \
 289           *(SilcUInt64 *)(enc_ctr + 8);                                 \
 290         src += 16;                                                      \
 291         dst += 16;                                                      \
 292         len -= 16;                                                      \
 293         silc_prefetch((void *)src, 0, 0);                               \
 294         continue;                                                       \
 295       }                                                                 \
 296       pad = 0;                                                          \
 297     }                                                                   \
 298     *dst++ = *src++ ^ enc_ctr[pad++];                                   \
 299     len--;                                                              \
 300   }                                                                     \
 301 } while(0)
 302
 303 #else /* WORDS_BIGENDIAN */
 304
 305 #define SILC_CTR_MSB_128_8(ctr, enc_ctr, pad, src, dst, enc)            \
 306 do {                                                                    \
 307   while (len-- > 0) {                                                   \
 308     if (pad == 16) {                                                    \
 309       for (i = 15; i >= 0; i--)                                         \
 310         if (++ctr[i])                                                   \
 311           break;                                                        \
 312                                                                         \
 313       enc;                                                              \
 314       pad = 0;                                                          \
 315     }                                                                   \
 316     *dst++ = *src++ ^ enc_ctr[pad++];                                   \
 317   }                                                                     \
 318 } while(0)
 319
 320 #endif /* !WORDS_BIGENDIAN */
 321
 322 /* CTR mode 128-bit block, LSB, MSB counter, the 32-bit tmp argument
 323    must be encrypted, enc_ctr must have the encrypted data too.  */
 324
 325 #define SILC_CTR_LSB_128_32(ctr, tmp, enc_ctr, pad, src, dst, enc)      \
 326 do {                                                                    \
 327   while (len-- > 0) {                                                   \
 328     if (pad == 16) {                                                    \
 329       for (i = 15; i >= 0; i--)                                         \
 330         if (++ctr[i])                                                   \
 331           break;                                                        \
 332                                                                         \
 333       SILC_GET32_LSB(tmp[0], ctr);                                      \
 334       SILC_GET32_LSB(tmp[1], ctr + 4);                                  \
 335       SILC_GET32_LSB(tmp[2], ctr + 8);                                  \
 336       SILC_GET32_LSB(tmp[3], ctr + 12);                                 \
 337       enc;                                                              \
 338       SILC_PUT32_LSB(tmp[0], enc_ctr);                                  \
 339       SILC_PUT32_LSB(tmp[1], enc_ctr + 4);                              \
 340       SILC_PUT32_LSB(tmp[2], enc_ctr + 8);                              \
 341       SILC_PUT32_LSB(tmp[3], enc_ctr + 12);                             \
 342       pad = 0;                                                          \
 343     }                                                                   \
 344     *dst++ = *src++ ^ enc_ctr[pad++];                                   \
 345   }                                                                     \
 346 } while(0)
 347
 348 /* CTR mode 128-bit block, LSB, MSB counter, the 32-bit tmp argument
 349    must be encrypted, enc_ctr must have the encrypted data too.  */
 350
 351 #define SILC_CTR_MSB_64_32(ctr, tmp, enc_ctr, pad, src, dst, enc)       \
 352 do {                                                                    \
 353   while (len-- > 0) {                                                   \
 354     if (pad == 8) {                                                     \
 355       for (i = 7; i >= 0; i--)                                          \
 356         if (++ctr[i])                                                   \
 357           break;                                                        \
 358                                                                         \
 359       SILC_GET32_MSB(tmp[0], ctr);                                      \
 360       SILC_GET32_MSB(tmp[1], ctr + 4);                                  \
 361       enc;                                                              \
 362       SILC_PUT32_MSB(tmp[0], enc_ctr);                                  \
 363       SILC_PUT32_MSB(tmp[1], enc_ctr + 4);                              \
 364       pad = 0;                                                          \
 365     }                                                                   \
 366     *dst++ = *src++ ^ enc_ctr[pad++];                                   \
 367   }                                                                     \
 368 } while(0)
 369
 370 /* CFB 128-bit block, LSB, the 32-bit cfb argument must be encrypted. */
 371
 372 #define SILC_CFB_ENC_LSB_128_32(iv, cfb, pad, src, dst, enc)            \
 373 do {                                                                    \
 374   while (len-- > 0) {                                                   \
 375     if (pad == 16) {                                                    \
 376       SILC_GET32_LSB(cfb[0], iv);                                       \
 377       SILC_GET32_LSB(cfb[1], iv + 4);                                   \
 378       SILC_GET32_LSB(cfb[2], iv + 8);                                   \
 379       SILC_GET32_LSB(cfb[3], iv + 12);                                  \
 380                                                                         \
 381       enc;                                                              \
 382                                                                         \
 383       SILC_PUT32_LSB(cfb[0], iv);                                       \
 384       SILC_PUT32_LSB(cfb[1], iv + 4);                                   \
 385       SILC_PUT32_LSB(cfb[2], iv + 8);                                   \
 386       SILC_PUT32_LSB(cfb[3], iv + 12);                                  \
 387       pad = 0;                                                          \
 388     }                                                                   \
 389     iv[pad] = (*dst = *src ^ iv[pad]);                                  \
 390     dst++;                                                              \
 391     src++;                                                              \
 392     pad++;                                                              \
 393   }                                                                     \
 394 } while(0)
 395
 396 /* CFB 128-bit block, LSB, the 32-bit cfb argument must be decrypted. */
 397
 398 #define SILC_CFB_DEC_LSB_128_32(iv, cfb, pad, src, dst, dec)            \
 399 do {                                                                    \
 400   unsigned char temp;                                                   \
 401   while (len-- > 0) {                                                   \
 402     if (pad == 16) {                                                    \
 403       SILC_GET32_LSB(cfb[0], iv);                                       \
 404       SILC_GET32_LSB(cfb[1], iv + 4);                                   \
 405       SILC_GET32_LSB(cfb[2], iv + 8);                                   \
 406       SILC_GET32_LSB(cfb[3], iv + 12);                                  \
 407                                                                         \
 408       dec;                                                              \
 409                                                                         \
 410       SILC_PUT32_LSB(cfb[0], iv);                                       \
 411       SILC_PUT32_LSB(cfb[1], iv + 4);                                   \
 412       SILC_PUT32_LSB(cfb[2], iv + 8);                                   \
 413       SILC_PUT32_LSB(cfb[3], iv + 12);                                  \
 414       pad = 0;                                                          \
 415     }                                                                   \
 416     temp = *src;                                                        \
 417     *dst = temp ^ iv[pad];                                              \
 418     iv[pad++] = temp;                                                   \
 419     dst++;                                                              \
 420     src++;                                                              \
 421   }                                                                     \
 422 } while(0)
 423
 424 /* CFB 128-bit block, MSB, the 32-bit cfb argument must be encrypted. */
 425
 426 #define SILC_CFB_ENC_MSB_128_32(iv, cfb, pad, src, dst, enc)            \
 427 do {                                                                    \
 428   while (len-- > 0) {                                                   \
 429     if (pad == 16) {                                                    \
 430       SILC_GET32_MSB(cfb[0], iv);                                       \
 431       SILC_GET32_MSB(cfb[1], iv + 4);                                   \
 432       SILC_GET32_MSB(cfb[2], iv + 8);                                   \
 433       SILC_GET32_MSB(cfb[3], iv + 12);                                  \
 434                                                                         \
 435       enc;                                                              \
 436                                                                         \
 437       SILC_PUT32_MSB(cfb[0], iv);                                       \
 438       SILC_PUT32_MSB(cfb[1], iv + 4);                                   \
 439       SILC_PUT32_MSB(cfb[2], iv + 8);                                   \
 440       SILC_PUT32_MSB(cfb[3], iv + 12);                                  \
 441       pad = 0;                                                          \
 442     }                                                                   \
 443     iv[pad] = (*dst = *src ^ iv[pad]);                                  \
 444     dst++;                                                              \
 445     src++;                                                              \
 446     pad++;                                                              \
 447   }                                                                     \
 448 } while(0)
 449
 450 /* CFB 128-bit block, MSB, the 32-bit cfb argument must be decrypted. */
 451
 452 #define SILC_CFB_DEC_MSB_128_32(iv, cfb, pad, src, dst, dec)            \
 453 do {                                                                    \
 454   unsigned char temp;                                                   \
 455   while (len-- > 0) {                                                   \
 456     if (pad == 16) {                                                    \
 457       SILC_GET32_MSB(cfb[0], iv);                                       \
 458       SILC_GET32_MSB(cfb[1], iv + 4);                                   \
 459       SILC_GET32_MSB(cfb[2], iv + 8);                                   \
 460       SILC_GET32_MSB(cfb[3], iv + 12);                                  \
 461                                                                         \
 462       dec;                                                              \
 463                                                                         \
 464       SILC_PUT32_MSB(cfb[0], iv);                                       \
 465       SILC_PUT32_MSB(cfb[1], iv + 4);                                   \
 466       SILC_PUT32_MSB(cfb[2], iv + 8);                                   \
 467       SILC_PUT32_MSB(cfb[3], iv + 12);                                  \
 468       pad = 0;                                                          \
 469     }                                                                   \
 470     temp = *src;                                                        \
 471     *dst = temp ^ iv[pad];                                              \
 472     iv[pad++] = temp;                                                   \
 473     dst++;                                                              \
 474     src++;                                                              \
 475   }                                                                     \
 476 } while(0)
 477
 478 /* CFB 64-bit block, MSB, the 32-bit cfb argument must be encrypted. */
 479
 480 #define SILC_CFB_ENC_MSB_64_32(iv, cfb, pad, src, dst, enc)             \
 481 do {                                                                    \
 482   while (len-- > 0) {                                                   \
 483     if (pad == 8) {                                                     \
 484       SILC_GET32_MSB(cfb[0], iv);                                       \
 485       SILC_GET32_MSB(cfb[1], iv + 4);                                   \
 486                                                                         \
 487       enc;                                                              \
 488                                                                         \
 489       SILC_PUT32_MSB(cfb[0], iv);                                       \
 490       SILC_PUT32_MSB(cfb[1], iv + 4);                                   \
 491       pad = 0;                                                          \
 492     }                                                                   \
 493     iv[pad] = (*dst = *src ^ iv[pad]);                                  \
 494     dst++;                                                              \
 495     src++;                                                              \
 496     pad++;                                                              \
 497   }                                                                     \
 498 } while(0)
 499
 500 /* CFB 64-bit block, MSB, the 32-bit cfb argument must be decrypted. */
 501
 502 #define SILC_CFB_DEC_MSB_64_32(iv, cfb, pad, src, dst, dec)             \
 503 do {                                                                    \
 504   unsigned char temp;                                                   \
 505   while (len-- > 0) {                                                   \
 506     if (pad == 8) {                                                     \
 507       SILC_GET32_MSB(cfb[0], iv);                                       \
 508       SILC_GET32_MSB(cfb[1], iv + 4);                                   \
 509                                                                         \
 510       dec;                                                              \
 511                                                                         \
 512       SILC_PUT32_MSB(cfb[0], iv);                                       \
 513       SILC_PUT32_MSB(cfb[1], iv + 4);                                   \
 514       pad = 0;                                                          \
 515     }                                                                   \
 516     temp = *src;                                                        \
 517     *dst = temp ^ iv[pad];                                              \
 518     iv[pad++] = temp;                                                   \
 519     dst++;                                                              \
 520     src++;                                                              \
 521   }                                                                     \
 522 } while(0)
 523
 524 /* CFB 128-bit block, MSB, the 8-bit iv argument must be encrypted. */
 525
 526 #define SILC_CFB_ENC_MSB_128_8(iv, pad, src, dst, enc)                  \
 527 do {                                                                    \
 528   while (len-- > 0) {                                                   \
 529     if (pad == 16) {                                                    \
 530       enc;                                                              \
 531       pad = 0;                                                          \
 532     }                                                                   \
 533     iv[pad] = (*dst = *src ^ iv[pad]);                                  \
 534     dst++;                                                              \
 535     src++;                                                              \
 536     pad++;                                                              \
 537   }                                                                     \
 538 } while(0)
 539
 540 /* CFB 128-bit block, MSB, the 8-bit iv argument must be decrypted. */
 541
 542 #define SILC_CFB_DEC_MSB_128_8(iv, pad, src, dst, dec)                  \
 543 do {                                                                    \
 544   unsigned char temp;                                                   \
 545   while (len-- > 0) {                                                   \
 546     if (pad == 16) {                                                    \
 547       dec;                                                              \
 548       pad = 0;                                                          \
 549     }                                                                   \
 550     temp = *src;                                                        \
 551     *dst = temp ^ iv[pad];                                              \
 552     iv[pad++] = temp;                                                   \
 553     dst++;                                                              \
 554     src++;                                                              \
 555   }                                                                     \
 556 } while(0)
 557
 558 #endif