tfenc.c

   1 #include "tfdef.h"
   2 #include "tfcore.h"
   3
   4 #if defined(TF_256BITS)
   5
   6 #define PROCESS_BLOCKP(x,k1,k2,k3,k4,k5,k6)                                             \
   7         do {                                                                            \
   8                 KE_MIX(Y, X, k1 + k2, k3, TFS_KS01);                                    \
   9                 KE_MIX(T, Z, k4 + x, k5 + k6, TFS_KS02);                                \
  10                                                                                         \
  11                 BE_MIX(X, T, TFS_BS01); BE_MIX(Z, Y, TFS_BS02);                         \
  12                 BE_MIX(X, Y, TFS_BS03); BE_MIX(Z, T, TFS_BS04);                         \
  13                 BE_MIX(X, T, TFS_BS05); BE_MIX(Z, Y, TFS_BS06);                         \
  14         } while (0)
  15
  16 #define PROCESS_BLOCKN(x,k1,k2,k3,k4,k5,k6)                                             \
  17         do {                                                                            \
  18                 KE_MIX(Y, X, k1 + k2, k3, TFS_KS03);                                    \
  19                 KE_MIX(T, Z, k4 + x, k5 + k6, TFS_KS04);                                \
  20                                                                                         \
  21                 BE_MIX(X, T, TFS_BS07); BE_MIX(Z, Y, TFS_BS08);                         \
  22                 BE_MIX(X, Y, TFS_BS09); BE_MIX(Z, T, TFS_BS10);                         \
  23                 BE_MIX(X, T, TFS_BS11); BE_MIX(Z, Y, TFS_BS12);                         \
  24         } while (0)
  25
  26 void tf_encrypt_rawblk(TF_UNIT_TYPE *O, const TF_UNIT_TYPE *I, const TF_UNIT_TYPE *K)
  27 {
  28         TF_UNIT_TYPE X, Y, Z, T;
  29         TF_UNIT_TYPE K0, K1, K2, K3;
  30         TF_UNIT_TYPE K4, T0, T1, T2;
  31
  32         X = I[0]; Y = I[1]; Z = I[2]; T = I[3];
  33
  34         K0 = K[0]; K1 = K[1]; K2 = K[2]; K3 = K[3];
  35         K4 = K[4]; T0 = K[5]; T1 = K[6]; T2 = K[7];
  36
  37         PROCESS_BLOCKP( 0,K1,T0,K0,K3,K2,T1);
  38         PROCESS_BLOCKN( 1,K2,T1,K1,K4,K3,T2);
  39         PROCESS_BLOCKP( 2,K3,T2,K2,K0,K4,T0);
  40         PROCESS_BLOCKN( 3,K4,T0,K3,K1,K0,T1);
  41
  42         PROCESS_BLOCKP( 4,K0,T1,K4,K2,K1,T2);
  43         PROCESS_BLOCKN( 5,K1,T2,K0,K3,K2,T0);
  44         PROCESS_BLOCKP( 6,K2,T0,K1,K4,K3,T1);
  45         PROCESS_BLOCKN( 7,K3,T1,K2,K0,K4,T2);
  46
  47         PROCESS_BLOCKP( 8,K4,T2,K3,K1,K0,T0);
  48         PROCESS_BLOCKN( 9,K0,T0,K4,K2,K1,T1);
  49         PROCESS_BLOCKP(10,K1,T1,K0,K3,K2,T2);
  50         PROCESS_BLOCKN(11,K2,T2,K1,K4,K3,T0);
  51
  52         PROCESS_BLOCKP(12,K3,T0,K2,K0,K4,T1);
  53         PROCESS_BLOCKN(13,K4,T1,K3,K1,K0,T2);
  54         PROCESS_BLOCKP(14,K0,T2,K4,K2,K1,T0);
  55         PROCESS_BLOCKN(15,K1,T0,K0,K3,K2,T1);
  56
  57         PROCESS_BLOCKP(16,K2,T1,K1,K4,K3,T2);
  58         PROCESS_BLOCKN(17,K3,T2,K2,K0,K4,T0);
  59
  60         O[0] = X + K3; O[1] = Y + K4 + T0; O[2] = Z + K0 + T1; O[3] = T + K1 + 18;
  61 }
  62
  63 #elif defined(TF_512BITS)
  64
  65 #define PROCESS_BLOCKP(x,k1,k2,k3,k4,k5,k6,k7,k8,k9,k10)                                \
  66         do {                                                                            \
  67                 KE_MIX(Y, X, k1, k2, TFS_KS01); KE_MIX(T, Z, k3, k4, TFS_KS02);         \
  68                 KE_MIX(W, E, k5 + k6, k7, TFS_KS03);                                    \
  69                 KE_MIX(N, V, k8 + x, k9 + k10, TFS_KS04);                               \
  70                                                                                         \
  71                 BE_MIX(Z, Y, TFS_BS01); BE_MIX(E, N, TFS_BS02);                         \
  72                 BE_MIX(V, W, TFS_BS03); BE_MIX(X, T, TFS_BS04);                         \
  73                 BE_MIX(E, Y, TFS_BS05); BE_MIX(V, T, TFS_BS06);                         \
  74                 BE_MIX(X, W, TFS_BS07); BE_MIX(Z, N, TFS_BS08);                         \
  75                 BE_MIX(V, Y, TFS_BS09); BE_MIX(X, N, TFS_BS10);                         \
  76                 BE_MIX(Z, W, TFS_BS11); BE_MIX(E, T, TFS_BS12);                         \
  77         } while (0)
  78
  79 #define PROCESS_BLOCKN(x,k1,k2,k3,k4,k5,k6,k7,k8,k9,k10)                                \
  80         do {                                                                            \
  81                 KE_MIX(Y, X, k1, k2, TFS_KS05); KE_MIX(T, Z, k3, k4, TFS_KS06);         \
  82                 KE_MIX(W, E, k5 + k6, k7, TFS_KS07);                                    \
  83                 KE_MIX(N, V, k8 + x, k9 + k10, TFS_KS08);                               \
  84                                                                                         \
  85                 BE_MIX(Z, Y, TFS_BS13); BE_MIX(E, N, TFS_BS14);                         \
  86                 BE_MIX(V, W, TFS_BS15); BE_MIX(X, T, TFS_BS16);                         \
  87                 BE_MIX(E, Y, TFS_BS17); BE_MIX(V, T, TFS_BS18);                         \
  88                 BE_MIX(X, W, TFS_BS19); BE_MIX(Z, N, TFS_BS20);                         \
  89                 BE_MIX(V, Y, TFS_BS21); BE_MIX(X, N, TFS_BS22);                         \
  90                 BE_MIX(Z, W, TFS_BS23); BE_MIX(E, T, TFS_BS24);                         \
  91         } while (0)
  92
  93 void tf_encrypt_rawblk(TF_UNIT_TYPE *O, const TF_UNIT_TYPE *I, const TF_UNIT_TYPE *K)
  94 {
  95         TF_UNIT_TYPE X, Y, Z, T;
  96         TF_UNIT_TYPE E, W, V, N;
  97         TF_UNIT_TYPE K0, K1, K2, K3;
  98         TF_UNIT_TYPE K4, K5, K6, K7;
  99         TF_UNIT_TYPE K8, T0, T1, T2;
 100
 101         X = I[0]; Y = I[1]; Z = I[2]; T = I[3];
 102         E = I[4]; W = I[5]; V = I[6]; N = I[7];
 103
 104         K0 = K[ 0]; K1 = K[ 1]; K2 = K[ 2]; K3 = K[ 3];
 105         K4 = K[ 4]; K5 = K[ 5]; K6 = K[ 6]; K7 = K[ 7];
 106         K8 = K[ 8]; T0 = K[ 9]; T1 = K[10]; T2 = K[11];
 107
 108         PROCESS_BLOCKP( 0,K1,K0,K3,K2,K5,T0,K4,K7,K6,T1);
 109         PROCESS_BLOCKN( 1,K2,K1,K4,K3,K6,T1,K5,K8,K7,T2);
 110         PROCESS_BLOCKP( 2,K3,K2,K5,K4,K7,T2,K6,K0,K8,T0);
 111         PROCESS_BLOCKN( 3,K4,K3,K6,K5,K8,T0,K7,K1,K0,T1);
 112
 113         PROCESS_BLOCKP( 4,K5,K4,K7,K6,K0,T1,K8,K2,K1,T2);
 114         PROCESS_BLOCKN( 5,K6,K5,K8,K7,K1,T2,K0,K3,K2,T0);
 115         PROCESS_BLOCKP( 6,K7,K6,K0,K8,K2,T0,K1,K4,K3,T1);
 116         PROCESS_BLOCKN( 7,K8,K7,K1,K0,K3,T1,K2,K5,K4,T2);
 117
 118         PROCESS_BLOCKP( 8,K0,K8,K2,K1,K4,T2,K3,K6,K5,T0);
 119         PROCESS_BLOCKN( 9,K1,K0,K3,K2,K5,T0,K4,K7,K6,T1);
 120         PROCESS_BLOCKP(10,K2,K1,K4,K3,K6,T1,K5,K8,K7,T2);
 121         PROCESS_BLOCKN(11,K3,K2,K5,K4,K7,T2,K6,K0,K8,T0);
 122
 123         PROCESS_BLOCKP(12,K4,K3,K6,K5,K8,T0,K7,K1,K0,T1);
 124         PROCESS_BLOCKN(13,K5,K4,K7,K6,K0,T1,K8,K2,K1,T2);
 125         PROCESS_BLOCKP(14,K6,K5,K8,K7,K1,T2,K0,K3,K2,T0);
 126         PROCESS_BLOCKN(15,K7,K6,K0,K8,K2,T0,K1,K4,K3,T1);
 127
 128         PROCESS_BLOCKP(16,K8,K7,K1,K0,K3,T1,K2,K5,K4,T2);
 129         PROCESS_BLOCKN(17,K0,K8,K2,K1,K4,T2,K3,K6,K5,T0);
 130
 131         O[0] = X + K0; O[1] = Y + K1; O[2] = Z + K2; O[3] = T + K3;
 132         O[4] = E + K4; O[5] = W + K5 + T0; O[6] = V + K6 + T1; O[7] = N + K7 + 18;
 133 }
 134
 135 #elif defined(TF_1024BITS)
 136
 137 #define PROCESS_BLOCKP(x,k1,k2,k3,k4,k5,k6,k7,k8,k9,k10,k11,k12,k13,k14,k15,k16,k17,k18)\
 138         do {                                                                            \
 139                 KE_MIX(Y, X, k1, k2, TFS_KS01); KE_MIX(T, Z, k3, k4, TFS_KS02);         \
 140                 KE_MIX(W, E, k5, k6, TFS_KS03); KE_MIX(N, V, k7, k8, TFS_KS04);         \
 141                 KE_MIX(U, P, k9, k10, TFS_KS05); KE_MIX(Q, M, k11, k12, TFS_KS06);      \
 142                 KE_MIX(B, A, k13 + k14, k15, TFS_KS07);                                 \
 143                 KE_MIX(L, H, k16 + x, k17 + k18, TFS_KS08);                             \
 144                                                                                         \
 145                 BE_MIX(X, U, TFS_BS01); BE_MIX(Z, B, TFS_BS02);                         \
 146                 BE_MIX(V, Q, TFS_BS03); BE_MIX(E, L, TFS_BS04);                         \
 147                 BE_MIX(M, N, TFS_BS05); BE_MIX(A, T, TFS_BS06);                         \
 148                 BE_MIX(H, W, TFS_BS07); BE_MIX(P, Y, TFS_BS08);                         \
 149                 BE_MIX(X, N, TFS_BS09); BE_MIX(Z, W, TFS_BS10);                         \
 150                 BE_MIX(E, T, TFS_BS11); BE_MIX(V, Y, TFS_BS12);                         \
 151                 BE_MIX(A, L, TFS_BS13); BE_MIX(H, B, TFS_BS14);                         \
 152                 BE_MIX(P, Q, TFS_BS15); BE_MIX(M, U, TFS_BS16);                         \
 153                 BE_MIX(X, L, TFS_BS17); BE_MIX(Z, Q, TFS_BS18);                         \
 154                 BE_MIX(V, B, TFS_BS19); BE_MIX(E, U, TFS_BS20);                         \
 155                 BE_MIX(H, Y, TFS_BS21); BE_MIX(P, W, TFS_BS22);                         \
 156                 BE_MIX(M, T, TFS_BS23); BE_MIX(A, N, TFS_BS24);                         \
 157         } while (0)
 158
 159 #define PROCESS_BLOCKN(x,k1,k2,k3,k4,k5,k6,k7,k8,k9,k10,k11,k12,k13,k14,k15,k16,k17,k18)\
 160         do {                                                                            \
 161                 KE_MIX(Y, X, k1, k2, TFS_KS09); KE_MIX(T, Z, k3, k4, TFS_KS10);         \
 162                 KE_MIX(W, E, k5, k6, TFS_KS11); KE_MIX(N, V, k7, k8, TFS_KS12);         \
 163                 KE_MIX(U, P, k9, k10, TFS_KS13); KE_MIX(Q, M, k11, k12, TFS_KS14);      \
 164                 KE_MIX(B, A, k13 + k14, k15, TFS_KS15);                                 \
 165                 KE_MIX(L, H, k16 + x, k17 + k18, TFS_KS16);                             \
 166                                                                                         \
 167                 BE_MIX(X, U, TFS_BS25); BE_MIX(Z, B, TFS_BS26);                         \
 168                 BE_MIX(V, Q, TFS_BS27); BE_MIX(E, L, TFS_BS28);                         \
 169                 BE_MIX(M, N, TFS_BS29); BE_MIX(A, T, TFS_BS30);                         \
 170                 BE_MIX(H, W, TFS_BS31); BE_MIX(P, Y, TFS_BS32);                         \
 171                 BE_MIX(X, N, TFS_BS33); BE_MIX(Z, W, TFS_BS34);                         \
 172                 BE_MIX(E, T, TFS_BS35); BE_MIX(V, Y, TFS_BS36);                         \
 173                 BE_MIX(A, L, TFS_BS37); BE_MIX(H, B, TFS_BS38);                         \
 174                 BE_MIX(P, Q, TFS_BS39); BE_MIX(M, U, TFS_BS40);                         \
 175                 BE_MIX(X, L, TFS_BS41); BE_MIX(Z, Q, TFS_BS42);                         \
 176                 BE_MIX(V, B, TFS_BS43); BE_MIX(E, U, TFS_BS44);                         \
 177                 BE_MIX(H, Y, TFS_BS45); BE_MIX(P, W, TFS_BS46);                         \
 178                 BE_MIX(M, T, TFS_BS47); BE_MIX(A, N, TFS_BS48);                         \
 179         } while (0)
 180
 181 void tf_encrypt_rawblk(TF_UNIT_TYPE *O, const TF_UNIT_TYPE *I, const TF_UNIT_TYPE *K)
 182 {
 183         TF_UNIT_TYPE X, Y, Z, T;
 184         TF_UNIT_TYPE E, W, V, N;
 185         TF_UNIT_TYPE P, U, M, Q;
 186         TF_UNIT_TYPE A, B, H, L;
 187         TF_UNIT_TYPE K0, K1, K2, K3;
 188         TF_UNIT_TYPE K4, K5, K6, K7;
 189         TF_UNIT_TYPE K8, K9, K10, K11;
 190         TF_UNIT_TYPE K12, K13, K14, K15;
 191         TF_UNIT_TYPE K16, T0, T1, T2;
 192
 193         X = I[ 0]; Y = I[ 1]; Z = I[ 2]; T = I[ 3];
 194         E = I[ 4]; W = I[ 5]; V = I[ 6]; N = I[ 7];
 195         P = I[ 8]; U = I[ 9]; M = I[10]; Q = I[11];
 196         A = I[12]; B = I[13]; H = I[14]; L = I[15];
 197
 198         K0  = K[ 0]; K1  = K[ 1]; K2  = K[ 2]; K3  = K[ 3];
 199         K4  = K[ 4]; K5  = K[ 5]; K6  = K[ 6]; K7  = K[ 7];
 200         K8  = K[ 8]; K9  = K[ 9]; K10 = K[10]; K11 = K[11];
 201         K12 = K[12]; K13 = K[13]; K14 = K[14]; K15 = K[15];
 202         K16 = K[16]; T0  = K[17]; T1  = K[18]; T2  = K[19];
 203
 204         PROCESS_BLOCKP( 0, K1, K0, K3, K2, K5, K4, K7, K6, K9, K8,K11,K10,K13, T0,K12,K15,K14, T1);
 205         PROCESS_BLOCKN( 1, K2, K1, K4, K3, K6, K5, K8, K7,K10, K9,K12,K11,K14, T1,K13,K16,K15, T2);
 206         PROCESS_BLOCKP( 2, K3, K2, K5, K4, K7, K6, K9, K8,K11,K10,K13,K12,K15, T2,K14, K0,K16, T0);
 207         PROCESS_BLOCKN( 3, K4, K3, K6, K5, K8, K7,K10, K9,K12,K11,K14,K13,K16, T0,K15, K1, K0, T1);
 208
 209         PROCESS_BLOCKP( 4, K5, K4, K7, K6, K9, K8,K11,K10,K13,K12,K15,K14, K0, T1,K16, K2, K1, T2);
 210         PROCESS_BLOCKN( 5, K6, K5, K8, K7,K10, K9,K12,K11,K14,K13,K16,K15, K1, T2, K0, K3, K2, T0);
 211         PROCESS_BLOCKP( 6, K7, K6, K9, K8,K11,K10,K13,K12,K15,K14, K0,K16, K2, T0, K1, K4, K3, T1);
 212         PROCESS_BLOCKN( 7, K8, K7,K10, K9,K12,K11,K14,K13,K16,K15, K1, K0, K3, T1, K2, K5, K4, T2);
 213
 214         PROCESS_BLOCKP( 8, K9, K8,K11,K10,K13,K12,K15,K14, K0,K16, K2, K1, K4, T2, K3, K6, K5, T0);
 215         PROCESS_BLOCKN( 9,K10, K9,K12,K11,K14,K13,K16,K15, K1, K0, K3, K2, K5, T0, K4, K7, K6, T1);
 216         PROCESS_BLOCKP(10,K11,K10,K13,K12,K15,K14, K0,K16, K2, K1, K4, K3, K6, T1, K5, K8, K7, T2);
 217         PROCESS_BLOCKN(11,K12,K11,K14,K13,K16,K15, K1, K0, K3, K2, K5, K4, K7, T2, K6, K9, K8, T0);
 218
 219         PROCESS_BLOCKP(12,K13,K12,K15,K14, K0,K16, K2, K1, K4, K3, K6, K5, K8, T0, K7,K10, K9, T1);
 220         PROCESS_BLOCKN(13,K14,K13,K16,K15, K1, K0, K3, K2, K5, K4, K7, K6, K9, T1, K8,K11,K10, T2);
 221         PROCESS_BLOCKP(14,K15,K14, K0,K16, K2, K1, K4, K3, K6, K5, K8, K7,K10, T2, K9,K12,K11, T0);
 222         PROCESS_BLOCKN(15,K16,K15, K1, K0, K3, K2, K5, K4, K7, K6, K9, K8,K11, T0,K10,K13,K12, T1);
 223
 224         PROCESS_BLOCKP(16, K0,K16, K2, K1, K4, K3, K6, K5, K8, K7,K10, K9,K12, T1,K11,K14,K13, T2);
 225         PROCESS_BLOCKN(17, K1, K0, K3, K2, K5, K4, K7, K6, K9, K8,K11,K10,K13, T2,K12,K15,K14, T0);
 226         PROCESS_BLOCKP(18, K2, K1, K4, K3, K6, K5, K8, K7,K10, K9,K12,K11,K14, T0,K13,K16,K15, T1);
 227         PROCESS_BLOCKN(19, K3, K2, K5, K4, K7, K6, K9, K8,K11,K10,K13,K12,K15, T1,K14, K0,K16, T2);
 228
 229         O[0] = X + K3; O[1] = Y + K4; O[2] = Z + K5; O[3] = T + K6;
 230         O[4] = E + K7; O[5] = W + K8; O[6] = V + K9; O[7] = N + K10;
 231         O[8] = P + K11; O[9] = U + K12; O[10] = M + K13; O[11] = Q + K14;
 232         O[12] = A + K15; O[13] = B + K16 + T2; O[14] = H + K0 + T0; O[15] = L + K1 + 20;
 233 }
 234
 235 #endif