userapps/opensource/sshd/libtomcrypt/safer+.c

   1 #include "mycrypt.h"
   2
   3 #ifdef SAFERP
   4
   5 const struct _cipher_descriptor saferp_desc =
   6 {
   7     "safer+",
   8     4,
   9     16, 32, 16, 8,
  10     &saferp_setup,
  11     &saferp_ecb_encrypt,
  12     &saferp_ecb_decrypt,
  13     &saferp_test,
  14     &saferp_keysize
  15 };
  16
  17 /* ROUND(b,i)
  18  *
  19  * This is one forward key application.  Note the basic form is
  20  * key addition, substitution, key addition.  The safer_ebox and safer_lbox
  21  * are the exponentiation box and logarithm boxes respectively.
  22  * The value of 'i' is the current round number which allows this
  23  * function to be unrolled massively.  Most of SAFER+'s speed
  24  * comes from not having to compute indirect accesses into the
  25  * array of 16 bytes b[0..15] which is the block of data
  26 */
  27
  28 extern const unsigned char safer_ebox[], safer_lbox[];
  29
  30 #define ROUND(b, i)                                                                        \
  31     b[0]  = (safer_ebox[(b[0] ^ skey->saferp.K[i][0]) & 255] + skey->saferp.K[i+1][0]) & 255;    \
  32     b[1]  = safer_lbox[(b[1] + skey->saferp.K[i][1]) & 255] ^ skey->saferp.K[i+1][1];            \
  33     b[2]  = safer_lbox[(b[2] + skey->saferp.K[i][2]) & 255] ^ skey->saferp.K[i+1][2];            \
  34     b[3]  = (safer_ebox[(b[3] ^ skey->saferp.K[i][3]) & 255] + skey->saferp.K[i+1][3]) & 255;    \
  35     b[4]  = (safer_ebox[(b[4] ^ skey->saferp.K[i][4]) & 255] + skey->saferp.K[i+1][4]) & 255;    \
  36     b[5]  = safer_lbox[(b[5] + skey->saferp.K[i][5]) & 255] ^ skey->saferp.K[i+1][5];            \
  37     b[6]  = safer_lbox[(b[6] + skey->saferp.K[i][6]) & 255] ^ skey->saferp.K[i+1][6];            \
  38     b[7]  = (safer_ebox[(b[7] ^ skey->saferp.K[i][7]) & 255] + skey->saferp.K[i+1][7]) & 255;    \
  39     b[8]  = (safer_ebox[(b[8] ^ skey->saferp.K[i][8]) & 255] + skey->saferp.K[i+1][8]) & 255;    \
  40     b[9]  = safer_lbox[(b[9] + skey->saferp.K[i][9]) & 255] ^ skey->saferp.K[i+1][9];            \
  41     b[10] = safer_lbox[(b[10] + skey->saferp.K[i][10]) & 255] ^ skey->saferp.K[i+1][10];         \
  42     b[11] = (safer_ebox[(b[11] ^ skey->saferp.K[i][11]) & 255] + skey->saferp.K[i+1][11]) & 255; \
  43     b[12] = (safer_ebox[(b[12] ^ skey->saferp.K[i][12]) & 255] + skey->saferp.K[i+1][12]) & 255; \
  44     b[13] = safer_lbox[(b[13] + skey->saferp.K[i][13]) & 255] ^ skey->saferp.K[i+1][13];         \
  45     b[14] = safer_lbox[(b[14] + skey->saferp.K[i][14]) & 255] ^ skey->saferp.K[i+1][14];         \
  46     b[15] = (safer_ebox[(b[15] ^ skey->saferp.K[i][15]) & 255] + skey->saferp.K[i+1][15]) & 255;
  47
  48 /* This is one inverse key application */
  49 #define iROUND(b, i)                                                                       \
  50     b[0]  = safer_lbox[(b[0] - skey->saferp.K[i+1][0]) & 255] ^ skey->saferp.K[i][0];            \
  51     b[1]  = (safer_ebox[(b[1] ^ skey->saferp.K[i+1][1]) & 255] - skey->saferp.K[i][1]) & 255;    \
  52     b[2]  = (safer_ebox[(b[2] ^ skey->saferp.K[i+1][2]) & 255] - skey->saferp.K[i][2]) & 255;    \
  53     b[3]  = safer_lbox[(b[3] - skey->saferp.K[i+1][3]) & 255] ^ skey->saferp.K[i][3];            \
  54     b[4]  = safer_lbox[(b[4] - skey->saferp.K[i+1][4]) & 255] ^ skey->saferp.K[i][4];            \
  55     b[5]  = (safer_ebox[(b[5] ^ skey->saferp.K[i+1][5]) & 255] - skey->saferp.K[i][5]) & 255;    \
  56     b[6]  = (safer_ebox[(b[6] ^ skey->saferp.K[i+1][6]) & 255] - skey->saferp.K[i][6]) & 255;    \
  57     b[7]  = safer_lbox[(b[7] - skey->saferp.K[i+1][7]) & 255] ^ skey->saferp.K[i][7];            \
  58     b[8]  = safer_lbox[(b[8] - skey->saferp.K[i+1][8]) & 255] ^ skey->saferp.K[i][8];            \
  59     b[9]  = (safer_ebox[(b[9] ^ skey->saferp.K[i+1][9]) & 255] - skey->saferp.K[i][9]) & 255;    \
  60     b[10] = (safer_ebox[(b[10] ^ skey->saferp.K[i+1][10]) & 255] - skey->saferp.K[i][10]) & 255; \
  61     b[11] = safer_lbox[(b[11] - skey->saferp.K[i+1][11]) & 255] ^ skey->saferp.K[i][11];         \
  62     b[12] = safer_lbox[(b[12] - skey->saferp.K[i+1][12]) & 255] ^ skey->saferp.K[i][12];         \
  63     b[13] = (safer_ebox[(b[13] ^ skey->saferp.K[i+1][13]) & 255] - skey->saferp.K[i][13]) & 255; \
  64     b[14] = (safer_ebox[(b[14] ^ skey->saferp.K[i+1][14]) & 255] - skey->saferp.K[i][14]) & 255; \
  65     b[15] = safer_lbox[(b[15] - skey->saferp.K[i+1][15]) & 255] ^ skey->saferp.K[i][15];
  66
  67 /* This is a forward single layer PHT transform.  */
  68 #define PHT(b)                                               \
  69     b[0]  = (b[0] + (b[1] = (b[0] + b[1]) & 255)) & 255;     \
  70     b[2]  = (b[2] + (b[3] = (b[3] + b[2]) & 255)) & 255;     \
  71     b[4]  = (b[4] + (b[5] = (b[5] + b[4]) & 255)) & 255;     \
  72     b[6]  = (b[6] + (b[7] = (b[7] + b[6]) & 255)) & 255;     \
  73     b[8]  = (b[8] + (b[9] = (b[9] + b[8]) & 255)) & 255;     \
  74     b[10] = (b[10] + (b[11] = (b[11] + b[10]) & 255)) & 255; \
  75     b[12] = (b[12] + (b[13] = (b[13] + b[12]) & 255)) & 255; \
  76     b[14] = (b[14] + (b[15] = (b[15] + b[14]) & 255)) & 255;
  77
  78 /* This is an inverse single layer PHT transform */
  79 #define iPHT(b)                                               \
  80     b[15] = (b[15] - (b[14] = (b[14] - b[15]) & 255)) & 255;  \
  81     b[13] = (b[13] - (b[12] = (b[12] - b[13]) & 255)) & 255;  \
  82     b[11] = (b[11] - (b[10] = (b[10] - b[11]) & 255)) & 255;  \
  83     b[9]  = (b[9] - (b[8] = (b[8] - b[9]) & 255)) & 255;      \
  84     b[7]  = (b[7] - (b[6] = (b[6] - b[7]) & 255)) & 255;      \
  85     b[5]  = (b[5] - (b[4] = (b[4] - b[5]) & 255)) & 255;      \
  86     b[3]  = (b[3] - (b[2] = (b[2] - b[3]) & 255)) & 255;      \
  87     b[1]  = (b[1] - (b[0] = (b[0] - b[1]) & 255)) & 255;      \
  88
  89 /* This is the "Armenian" Shuffle.  It takes the input from b and stores it in b2 */
  90 #define SHUF(b, b2)                                              \
  91     b2[0] = b[8]; b2[1] = b[11]; b2[2] = b[12]; b2[3] = b[15];   \
  92     b2[4] = b[2]; b2[5] = b[1]; b2[6] = b[6]; b2[7] = b[5];      \
  93     b2[8] = b[10]; b2[9] = b[9]; b2[10] = b[14]; b2[11] = b[13]; \
  94     b2[12] = b[0]; b2[13] = b[7]; b2[14] = b[4]; b2[15] = b[3];
  95
  96 /* This is the inverse shuffle.  It takes from b and gives to b2 */
  97 #define iSHUF(b, b2)                                               \
  98     b2[0] = b[12]; b2[1] = b[5]; b2[2] = b[4]; b2[3] = b[15];      \
  99     b2[4] = b[14]; b2[5] = b[7]; b2[6] = b[6]; b2[7] = b[13];      \
 100     b2[8] = b[0]; b2[9] = b[9]; b2[10] = b[8]; b2[11] = b[1];      \
 101     b2[12] = b[2]; b2[13] = b[11]; b2[14] = b[10]; b2[15] = b[3];
 102
 103 /* The complete forward Linear Transform layer.
 104  * Note that alternating usage of b and b2.
 105  * Each round of LT starts in 'b' and ends in 'b2'.
 106  */
 107 #define LT(b, b2)             \
 108     PHT(b);  SHUF(b, b2);     \
 109     PHT(b2); SHUF(b2, b);     \
 110     PHT(b);  SHUF(b, b2);     \
 111     PHT(b2);
 112
 113 /* This is the inverse linear transform layer.  */
 114 #define iLT(b, b2)            \
 115     iPHT(b);                  \
 116     iSHUF(b, b2); iPHT(b2);   \
 117     iSHUF(b2, b); iPHT(b);    \
 118     iSHUF(b, b2); iPHT(b2);
 119
 120 #ifdef SMALL_CODE
 121
 122 static void _round(unsigned char *b, int i, symmetric_key *skey)
 123 {
 124    ROUND(b, i);
 125 }
 126
 127 static void _iround(unsigned char *b, int i, symmetric_key *skey)
 128 {
 129    iROUND(b, i);
 130 }
 131
 132 static void _lt(unsigned char *b, unsigned char *b2)
 133 {
 134    LT(b, b2);
 135 }
 136
 137 static void _ilt(unsigned char *b, unsigned char *b2)
 138 {
 139    iLT(b, b2);
 140 }
 141
 142 #undef ROUND
 143 #define ROUND(b, i) _round(b, i, skey)
 144
 145 #undef iROUND
 146 #define iROUND(b, i) _iround(b, i, skey)
 147
 148 #undef LT
 149 #define LT(b, b2) _lt(b, b2)
 150
 151 #undef iLT
 152 #define iLT(b, b2) _ilt(b, b2)
 153
 154 #endif
 155
 156 /* These are the 33, 128-bit bias words for the key schedule */
 157 static const unsigned char safer_bias[33][16] = {
 158 {  70, 151, 177, 186, 163, 183,  16,  10, 197,  55, 179, 201,  90,  40, 172, 100},
 159 { 236, 171, 170, 198, 103, 149,  88,  13, 248, 154, 246, 110, 102, 220,   5,  61},
 160 { 138, 195, 216, 137, 106, 233,  54,  73,  67, 191, 235, 212, 150, 155, 104, 160},
 161 {  93,  87, 146,  31, 213, 113,  92, 187,  34, 193, 190, 123, 188, 153,  99, 148},
 162 {  42,  97, 184,  52,  50,  25, 253, 251,  23,  64, 230,  81,  29,  65,  68, 143},
 163 { 221,   4, 128, 222, 231,  49, 214, 127,   1, 162, 247,  57, 218, 111,  35, 202},
 164 {  58, 208,  28, 209,  48,  62,  18, 161, 205,  15, 224, 168, 175, 130,  89,  44},
 165 { 125, 173, 178, 239, 194, 135, 206, 117,   6,  19,   2, 144,  79,  46, 114,  51},
 166 { 192, 141, 207, 169, 129, 226, 196,  39,  47, 108, 122, 159,  82, 225,  21,  56},
 167 { 252,  32,  66, 199,   8, 228,   9,  85,  94, 140,  20, 118,  96, 255, 223, 215},
 168 { 250,  11,  33,   0,  26, 249, 166, 185, 232, 158,  98,  76, 217, 145,  80, 210},
 169 {  24, 180,   7, 132, 234,  91, 164, 200,  14, 203,  72, 105,  75,  78, 156,  53},
 170 {  69,  77,  84, 229,  37,  60,  12,  74, 139,  63, 204, 167, 219, 107, 174, 244},
 171 {  45, 243, 124, 109, 157, 181,  38, 116, 242, 147,  83, 176, 240,  17, 237, 131},
 172 { 182,   3,  22, 115,  59,  30, 142, 112, 189, 134,  27,  71, 126,  36,  86, 241},
 173 { 136,  70, 151, 177, 186, 163, 183,  16,  10, 197,  55, 179, 201,  90,  40, 172},
 174 { 220, 134, 119, 215, 166,  17, 251, 244, 186, 146, 145, 100, 131, 241,  51, 239},
 175 {  44, 181, 178,  43, 136, 209, 153, 203, 140, 132,  29,  20, 129, 151, 113, 202},
 176 { 163, 139,  87,  60, 130, 196,  82,  92,  28, 232, 160,   4, 180, 133,  74, 246},
 177 {  84, 182, 223,  12,  26, 142, 222, 224,  57, 252,  32, 155,  36,  78, 169, 152},
 178 { 171, 242,  96, 208, 108, 234, 250, 199, 217,   0, 212,  31, 110,  67, 188, 236},
 179 { 137, 254, 122,  93,  73, 201,  50, 194, 249, 154, 248, 109,  22, 219,  89, 150},
 180 { 233, 205, 230,  70,  66, 143,  10, 193, 204, 185, 101, 176, 210, 198, 172,  30},
 181 {  98,  41,  46,  14, 116,  80,   2,  90, 195,  37, 123, 138,  42,  91, 240,   6},
 182 {  71, 111, 112, 157, 126,  16, 206,  18,  39, 213,  76,  79, 214, 121,  48, 104},
 183 { 117, 125, 228, 237, 128, 106, 144,  55, 162,  94, 118, 170, 197, 127,  61, 175},
 184 { 229,  25,  97, 253,  77, 124, 183,  11, 238, 173,  75,  34, 245, 231, 115,  35},
 185 { 200,   5, 225, 102, 221, 179,  88, 105,  99,  86,  15, 161,  49, 149,  23,   7},
 186 {  40,   1,  45, 226, 147, 190,  69,  21, 174, 120,   3, 135, 164, 184,  56, 207},
 187 {   8, 103,   9, 148, 235,  38, 168, 107, 189,  24,  52,  27, 187, 191, 114, 247},
 188 {  53,  72, 156,  81,  47,  59,  85, 227, 192, 159, 216, 211, 243, 141, 177, 255},
 189 {  62, 220, 134, 119, 215, 166,  17, 251, 244, 186, 146, 145, 100, 131, 241,  51}};
 190
 191 int saferp_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey)
 192 {
 193    unsigned x, y;
 194    unsigned char t[33];
 195    static const int rounds[3] = { 8, 12, 16 };
 196
 197    _ARGCHK(key != NULL);
 198    _ARGCHK(skey != NULL);
 199
 200    /* check arguments */
 201    if (keylen != 16 && keylen != 24 && keylen != 32) {
 202       return CRYPT_INVALID_KEYSIZE;
 203    }
 204
 205    /* Is the number of rounds valid?  Either use zero for default or
 206     * 8,12,16 rounds for 16,24,32 byte keys
 207     */
 208    if (num_rounds != 0 && num_rounds != rounds[(keylen/8)-2]) {
 209       return CRYPT_INVALID_ROUNDS;
 210    }
 211
 212    /* 128 bit key version */
 213    if (keylen == 16) {
 214        /* copy key into t */
 215        for (x = y = 0; x < 16; x++) {
 216            t[x] = key[x];
 217            y ^= key[x];
 218        }
 219        t[16] = y;
 220
 221        /* make round keys */
 222        for (x = 0; x < 16; x++) {
 223            skey->saferp.K[0][x] = t[x];
 224        }
 225
 226        /* make the 16 other keys as a transformation of the first key */
 227        for (x = 1; x < 17; x++) {
 228            /* rotate 3 bits each */
 229            for (y = 0; y < 17; y++) {
 230                t[y] = ((t[y]<<3)|(t[y]>>5)) & 255;
 231            }
 232
 233            /* select and add */
 234            for (y = 0; y < 16; y++) {
 235                skey->saferp.K[x][y] = (t[(x+y)%17] + safer_bias[x-1][y]) & 255;
 236            }
 237        }
 238        skey->saferp.rounds = 8;
 239    } else if (keylen == 24) {
 240        /* copy key into t */
 241        for (x = y = 0; x < 24; x++) {
 242            t[x] = key[x];
 243            y ^= key[x];
 244        }
 245        t[24] = y;
 246
 247        /* make round keys */
 248        for (x = 0; x < 16; x++) {
 249            skey->saferp.K[0][x] = t[x];
 250        }
 251
 252        for (x = 1; x < 25; x++) {
 253            /* rotate 3 bits each */
 254            for (y = 0; y < 25; y++) {
 255                t[y] = ((t[y]<<3)|(t[y]>>5)) & 255;
 256            }
 257
 258            /* select and add */
 259            for (y = 0; y < 16; y++) {
 260                skey->saferp.K[x][y] = (t[(x+y)%25] + safer_bias[x-1][y]) & 255;
 261            }
 262        }
 263        skey->saferp.rounds = 12;
 264    } else {
 265        /* copy key into t */
 266        for (x = y = 0; x < 32; x++) {
 267            t[x] = key[x];
 268            y ^= key[x];
 269        }
 270        t[32] = y;
 271
 272        /* make round keys */
 273        for (x = 0; x < 16; x++) {
 274            skey->saferp.K[0][x] = t[x];
 275        }
 276
 277        for (x = 1; x < 33; x++) {
 278            /* rotate 3 bits each */
 279            for (y = 0; y < 33; y++) {
 280                t[y] = ((t[y]<<3)|(t[y]>>5)) & 255;
 281            }
 282
 283            /* select and add */
 284            for (y = 0; y < 16; y++) {
 285                skey->saferp.K[x][y] = (t[(x+y)%33] + safer_bias[x-1][y]) & 255;
 286            }
 287        }
 288        skey->saferp.rounds = 16;
 289    }
 290 #ifdef CLEAN_STACK
 291    zeromem(t, sizeof(t));
 292 #endif
 293    return CRYPT_OK;
 294 }
 295
 296 void saferp_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey)
 297 {
 298    unsigned char b[16];
 299    int x;
 300
 301    _ARGCHK(pt != NULL);
 302    _ARGCHK(ct != NULL);
 303    _ARGCHK(skey != NULL);
 304
 305    /* do eight rounds */
 306    for (x = 0; x < 16; x++) {
 307        b[x] = pt[x];
 308    }
 309    ROUND(b,  0);  LT(b, ct);
 310    ROUND(ct, 2);  LT(ct, b);
 311    ROUND(b,  4);  LT(b, ct);
 312    ROUND(ct, 6);  LT(ct, b);
 313    ROUND(b,  8);  LT(b, ct);
 314    ROUND(ct, 10); LT(ct, b);
 315    ROUND(b,  12); LT(b, ct);
 316    ROUND(ct, 14); LT(ct, b);
 317    /* 192-bit key? */
 318    if (skey->saferp.rounds > 8) {
 319       ROUND(b, 16);  LT(b, ct);
 320       ROUND(ct, 18); LT(ct, b);
 321       ROUND(b, 20);  LT(b, ct);
 322       ROUND(ct, 22); LT(ct, b);
 323    }
 324    /* 256-bit key? */
 325    if (skey->saferp.rounds > 12) {
 326       ROUND(b, 24);  LT(b, ct);
 327       ROUND(ct, 26); LT(ct, b);
 328       ROUND(b, 28);  LT(b, ct);
 329       ROUND(ct, 30); LT(ct, b);
 330    }
 331    ct[0] = b[0] ^ skey->saferp.K[skey->saferp.rounds*2][0];
 332    ct[1] = (b[1] + skey->saferp.K[skey->saferp.rounds*2][1]) & 255;
 333    ct[2] = (b[2] + skey->saferp.K[skey->saferp.rounds*2][2]) & 255;
 334    ct[3] = b[3] ^ skey->saferp.K[skey->saferp.rounds*2][3];
 335    ct[4] = b[4] ^ skey->saferp.K[skey->saferp.rounds*2][4];
 336    ct[5] = (b[5] + skey->saferp.K[skey->saferp.rounds*2][5]) & 255;
 337    ct[6] = (b[6] + skey->saferp.K[skey->saferp.rounds*2][6]) & 255;
 338    ct[7] = b[7] ^ skey->saferp.K[skey->saferp.rounds*2][7];
 339    ct[8] = b[8] ^ skey->saferp.K[skey->saferp.rounds*2][8];
 340    ct[9] = (b[9] + skey->saferp.K[skey->saferp.rounds*2][9]) & 255;
 341    ct[10] = (b[10] + skey->saferp.K[skey->saferp.rounds*2][10]) & 255;
 342    ct[11] = b[11] ^ skey->saferp.K[skey->saferp.rounds*2][11];
 343    ct[12] = b[12] ^ skey->saferp.K[skey->saferp.rounds*2][12];
 344    ct[13] = (b[13] + skey->saferp.K[skey->saferp.rounds*2][13]) & 255;
 345    ct[14] = (b[14] + skey->saferp.K[skey->saferp.rounds*2][14]) & 255;
 346    ct[15] = b[15] ^ skey->saferp.K[skey->saferp.rounds*2][15];
 347 #ifdef CLEAN_STACK
 348    zeromem(b, sizeof(b));
 349 #endif
 350 }
 351
 352 void saferp_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey)
 353 {
 354    unsigned char b[16];
 355    int x;
 356
 357    _ARGCHK(pt != NULL);
 358    _ARGCHK(ct != NULL);
 359    _ARGCHK(skey != NULL);
 360
 361    /* do eight rounds */
 362    b[0] = ct[0] ^ skey->saferp.K[skey->saferp.rounds*2][0];
 363    b[1] = (ct[1] - skey->saferp.K[skey->saferp.rounds*2][1]) & 255;
 364    b[2] = (ct[2] - skey->saferp.K[skey->saferp.rounds*2][2]) & 255;
 365    b[3] = ct[3] ^ skey->saferp.K[skey->saferp.rounds*2][3];
 366    b[4] = ct[4] ^ skey->saferp.K[skey->saferp.rounds*2][4];
 367    b[5] = (ct[5] - skey->saferp.K[skey->saferp.rounds*2][5]) & 255;
 368    b[6] = (ct[6] - skey->saferp.K[skey->saferp.rounds*2][6]) & 255;
 369    b[7] = ct[7] ^ skey->saferp.K[skey->saferp.rounds*2][7];
 370    b[8] = ct[8] ^ skey->saferp.K[skey->saferp.rounds*2][8];
 371    b[9] = (ct[9] - skey->saferp.K[skey->saferp.rounds*2][9]) & 255;
 372    b[10] = (ct[10] - skey->saferp.K[skey->saferp.rounds*2][10]) & 255;
 373    b[11] = ct[11] ^ skey->saferp.K[skey->saferp.rounds*2][11];
 374    b[12] = ct[12] ^ skey->saferp.K[skey->saferp.rounds*2][12];
 375    b[13] = (ct[13] - skey->saferp.K[skey->saferp.rounds*2][13]) & 255;
 376    b[14] = (ct[14] - skey->saferp.K[skey->saferp.rounds*2][14]) & 255;
 377    b[15] = ct[15] ^ skey->saferp.K[skey->saferp.rounds*2][15];
 378    /* 256-bit key? */
 379    if (skey->saferp.rounds > 12) {
 380       iLT(b, pt); iROUND(pt, 30);
 381       iLT(pt, b); iROUND(b, 28);
 382       iLT(b, pt); iROUND(pt, 26);
 383       iLT(pt, b); iROUND(b, 24);
 384    }
 385    /* 192-bit key? */
 386    if (skey->saferp.rounds > 8) {
 387       iLT(b, pt); iROUND(pt, 22);
 388       iLT(pt, b); iROUND(b, 20);
 389       iLT(b, pt); iROUND(pt, 18);
 390       iLT(pt, b); iROUND(b, 16);
 391    }
 392    iLT(b, pt); iROUND(pt, 14);
 393    iLT(pt, b); iROUND(b, 12);
 394    iLT(b, pt); iROUND(pt,10);
 395    iLT(pt, b); iROUND(b, 8);
 396    iLT(b, pt); iROUND(pt,6);
 397    iLT(pt, b); iROUND(b, 4);
 398    iLT(b, pt); iROUND(pt,2);
 399    iLT(pt, b); iROUND(b, 0);
 400    for (x = 0; x < 16; x++) {
 401        pt[x] = b[x];
 402    }
 403 #ifdef CLEAN_STACK
 404    zeromem(b, sizeof(b));
 405 #endif
 406 }
 407
 408 int saferp_test(void)
 409 {
 410  #ifndef LTC_TEST
 411     return CRYPT_NOP;
 412  #else
 413    static const struct {
 414        int keylen;
 415        unsigned char key[32], pt[16], ct[16];
 416    } tests[] = {
 417        {
 418            16,
 419            { 41, 35, 190, 132, 225, 108, 214, 174,
 420              82, 144, 73, 241, 241, 187, 233, 235 },
 421            { 179, 166, 219, 60, 135, 12, 62, 153,
 422              36, 94, 13, 28, 6, 183, 71, 222 },
 423            { 224, 31, 182, 10, 12, 255, 84, 70,
 424              127, 13, 89, 249, 9, 57, 165, 220 }
 425        }, {
 426            24,
 427            { 72, 211, 143, 117, 230, 217, 29, 42,
 428              229, 192, 247, 43, 120, 129, 135, 68,
 429              14, 95, 80, 0, 212, 97, 141, 190 },
 430            { 123, 5, 21, 7, 59, 51, 130, 31,
 431              24, 112, 146, 218, 100, 84, 206, 177 },
 432            { 92, 136, 4, 63, 57, 95, 100, 0,
 433              150, 130, 130, 16, 193, 111, 219, 133 }
 434        }, {
 435            32,
 436            { 243, 168, 141, 254, 190, 242, 235, 113,
 437              255, 160, 208, 59, 117, 6, 140, 126,
 438              135, 120, 115, 77, 208, 190, 130, 190,
 439              219, 194, 70, 65, 43, 140, 250, 48 },
 440            { 127, 112, 240, 167, 84, 134, 50, 149,
 441              170, 91, 104, 19, 11, 230, 252, 245 },
 442            { 88, 11, 25, 36, 172, 229, 202, 213,
 443              170, 65, 105, 153, 220, 104, 153, 138 }
 444        }
 445     };
 446
 447    unsigned char buf[2][16];
 448    symmetric_key skey;
 449    int err, i;
 450
 451    for (i = 0; i < (int)(sizeof(tests) / sizeof(tests[0])); i++) {
 452       if ((err = saferp_setup(tests[i].key, tests[i].keylen, 0, &skey)) != CRYPT_OK)  {
 453          return err;
 454       }
 455       saferp_ecb_encrypt(tests[i].pt, buf[0], &skey);
 456       saferp_ecb_decrypt(buf[0], buf[1], &skey);
 457
 458       /* compare */
 459       if (memcmp(buf[0], tests[i].ct, 16) || memcmp(buf[1], tests[i].pt, 16)) {
 460          return CRYPT_FAIL_TESTVECTOR;
 461       }
 462    }
 463
 464    return CRYPT_OK;
 465  #endif
 466 }
 467
 468 int saferp_keysize(int *desired_keysize)
 469 {
 470    _ARGCHK(desired_keysize != NULL);
 471
 472    if (*desired_keysize < 16)
 473       return CRYPT_INVALID_KEYSIZE;
 474    if (*desired_keysize < 24) {
 475       *desired_keysize = 16;
 476    } else if (*desired_keysize < 32) {
 477       *desired_keysize = 24;
 478    } else {
 479       *desired_keysize = 32;
 480    }
 481    return CRYPT_OK;
 482 }
 483
 484 #endif
 485
 486