internal int distanciaHamming(ref BETA pData1 , ref BETA pData2)
{
int dist = 0;
//Usamos la funcion completarString
/*Console.WriteLine("TEXTO CIFRADO");
Console.WriteLine("1.1__"+pData1.A+" "+pData1.B+" "+pData1.C+" "+pData1.D);
Console.WriteLine("2.1__"+pData2.A+" "+pData2.B+" "+pData2.C+" "+pData2.D);*/
res1 = completaString(ref pData1);
res2 = completaString(ref pData2);
/*Console.WriteLine("TRAS COMPLETAR STRINGS");
Console.WriteLine("1.2__"+res1.A+" "+res1.B+" "+res1.C+" "+res1.D);
Console.WriteLine("2.2__"+res2.A+" "+res2.B+" "+res2.C+" "+res2.D);*/
return dist = calcularDist(ref res1,ref res2);
}
internal auxiliar completaString(ref BETA pData)
{
int tamA = 0;
int tamB = 0;
int tamC = 0;
int tamD = 0;
t.A = pData.A.ToString();
t.B = pData.B.ToString();
t.C = pData.C.ToString();
t.D = pData.D.ToString();
tamA = t.A.Length;
tamB = t.B.Length;
tamC = t.C.Length;
tamD = t.D.Length;
int diffA = 10 - tamA;
int diffB = 10 - tamB;
int diffC = 10 - tamC;
int diffD = 10 - tamD;
switch (diffA)
{
case 1:
t.A = ZERO1 + t.A;
break;
case 2:
t.A = ZERO2 + t.A;
break;
case 3:
t.A = ZERO3 + t.A;
break;
case 4:
t.A = ZERO4 + t.A;
break;
case 5:
t.A = ZERO5 + t.A;
break;
case 6:
t.A = ZERO6 + t.A;
break;
case 7:
t.A = ZERO7 + t.A;
break;
case 8:
t.A = ZERO8 + t.A;
break;
case 9:
t.A = ZERO9 + t.A;
break;
}
switch (diffB)
{
case 1:
t.B = ZERO1 + t.B;
break;
case 2:
t.B = ZERO2 + t.B;
break;
case 3:
t.B = ZERO3 + t.B;
break;
case 4:
t.B = ZERO4 + t.B;
break;
case 5:
t.B = ZERO5 + t.B;
break;
case 6:
t.B = ZERO6 + t.B;
break;
case 7:
t.B = ZERO7 + t.B;
break;
case 8:
t.B = ZERO8 + t.B;
break;
case 9:
t.B = ZERO9 + t.B;
break;
}
switch (diffC)
{
case 1:
t.C = ZERO1 + t.C;
break;
case 2:
t.C = ZERO2 + t.C;
break;
case 3:
t.C = ZERO3 + t.C;
break;
case 4:
t.C = ZERO4 + t.C;
break;
case 5:
t.C = ZERO5 + t.C;
break;
case 6:
t.C = ZERO6 + t.C;
break;
case 7:
t.C = ZERO7 + t.C;
break;
case 8:
t.C = ZERO8 + t.C;
break;
case 9:
t.C = ZERO9 + t.C;
break;
}
switch (diffD)
{
case 1:
t.D = ZERO1 + t.D;
break;
case 2:
t.D = ZERO2 + t.D;
break;
case 3:
t.D = ZERO3 + t.D;
break;
case 4:
t.D = ZERO4 + t.D;
break;
case 5:
t.D = ZERO5 + t.D;
break;
case 6:
t.D = ZERO6 + t.D;
break;
case 7:
t.D = ZERO7 + t.D;
break;
case 8:
t.D = ZERO8 + t.D;
break;
case 9:
t.D = ZERO9 + t.D;
break;
}
return t;
}
// ========================================================================
// Initialize the mask and rotation round subkey sets from a given user key
// ------------------------------------------------------------------------
internal void CAST256KeyInit(BETA[] Kr, BETA[] Km, KAPPA userKey)
{
for (int i = 0; i < 12; i++)
{
userKey = W(2 * i, userKey, g_Tr, g_Tm);
userKey = W(2 * i + 1, userKey, g_Tr, g_Tm);
Kr[i].A = FIVE_LSB(userKey.A);
Kr[i].B = FIVE_LSB(userKey.C);
Kr[i].C = FIVE_LSB(userKey.E);
Kr[i].D = FIVE_LSB(userKey.G);
Km[i].A = userKey.H;
Km[i].B = userKey.F;
Km[i].C = userKey.D;
Km[i].D = userKey.B;
}
}
// ========================================================================
// Decrypt a 128bit block
// ------------------------------------------------------------------------
internal void CAST256Decrypt(BETA[] Kr, BETA[] Km, ref BETA pData)
{
for (int i = 11; i >= 6; i--)
pData = Q(i, pData, Kr, Km);
for (int i = 5; i >= 0; i--)
pData = QBAR(i, pData, Kr, Km);
}
// ========================================================================
// Encrypt a 128bit block
// ------------------------------------------------------------------------
internal void CAST256Encrypt(BETA[] Kr, BETA[] Km, ref BETA pData)
{
for (int i = 0; i < 6; i++)
pData = Q(i, pData, Kr, Km);
for (int i = 6; i < 12; i++)
pData = QBAR(i, pData, Kr, Km);
}
BETA QBAR(int round, BETA data, BETA[] Kr, BETA[] Km)
{
data.D = data.D ^ f1(data.A, Kr[round].D, Km[round].D);
data.A = data.A ^ f3(data.B, Kr[round].C, Km[round].C);
data.B = data.B ^ f2(data.C, Kr[round].B, Km[round].B);
data.C = data.C ^ f1(data.D, Kr[round].A, Km[round].A);
return data;
}
