static void DES(char* Out, char* In, PSubKey pSubKey, int Type)
{
int i;
static char M[64], tmp[32], *Li=&M[0], *Ri=&M[32];
ByteToBit(M, In, 64);
Transform(M, M, IP_Table, 64);
if (Type==ENCRYPT)
{
for (i=0; i<16; ++i)
{
memcpy(tmp, Ri, 32);
F_func(Ri, (*pSubKey)[i]);
Xor(Ri, Li, 32);
memcpy(Li, tmp, 32);
}
}
else
{
for (i=15; i>=0; --i)
{
memcpy(tmp, Li, 32);
F_func(Li, (*pSubKey)[i]);
Xor(Li, Ri, 32);
memcpy(Ri, tmp, 32);
}
}
Transform(M, M, IPR_Table, 64);
BitToByte(Out, M, 64);
}
void test_64bit_magic(int *int_ptr, float *float_ptr)
{
F_func(int_ptr, 0xFFFFFFFFFFFFFFFFULL);
F_func(int_ptr, 0xFFFFFFFFULL); // expected-warning {{argument type 'int *' doesn't match specified 'f' type tag that requires 'float *'}}
F_func(float_ptr, 0xFFFFFFFFFFFFFFFFULL); // expected-warning {{argument type 'float *' doesn't match specified 'f' type tag that requires 'int *'}}
F_func(float_ptr, 0xFFFFFFFFULL);
}
static void
kuzn_expand_key(struct kuzn_ctx *ctx)
{
int i, j;
uint8_t *ptr;
uint8_t C[16];
ptr = ctx->keys + 32;
for (i = 0; i < 4; i++) {
memcpy(ptr, ptr - 32, 32);
for (j = 0; j < 8; j++) {
C_func(C, 8*i + j + 1, ctx);
F_func(ptr, ptr, C, ctx);
}
ptr += 32;
}
}
void essence_compress_512(uint64_t *Chaining_Variables,
BitSequence *input,
uint64_t input_size_in_512_bit_blocks,
uint64_t num_steps)
{
uint64_t r[8];
uint64_t r_orig[8];
uint64_t k[8];
uint64_t i,j;
uint64_t tmp_r, tmp_k, F_r, F_k;
#if (ESSENCE_DEBUG_LEVEL & 0x08)
printf("\n*** Entering 512-bit Compression Function ***\n");
for(i=0;i<8;i++)
{
printf("Chaining_Variables[%i] = 0x%.16llx\n",i,
Chaining_Variables[i]);
}
printf("input_size_in_512_bit_blocks = %lli\n",
input_size_in_512_bit_blocks);
printf("num_steps = %lli\n",
num_steps);
#endif
/*
* Load the chaining variables into r0-r7.
*/
for(i=0;i<8;i++)
{
r[i] = Chaining_Variables[i];
}
/*
* Main compression loop
*/
while(input_size_in_512_bit_blocks>0)
{
/*
* Read in the input
*/
#if (ESSENCE_DEBUG_LEVEL & 0x08)
printf("Next 64 bytes of input:");
for(i=0;i<8;i++)
{
printf("\n input bytes %2i - %2i: ",
(i*8),
(i*8+3));
for(j=0;j<8;j++)
{
printf("0x%.2x ",input[i*8+j]);
}
}
printf("\n\nBeginning compression loop\n\n");
fflush(stdout);
#endif
for(i=0;i<8;i++)
{
/*
* Here we go through some contortions to deal with Endian
* issues. Our standard defines the data as Little Endian,
* but we force it just in case we are on a Big Endian
* machine.
*/
tmp_k = ( (0x00000000000000ffLL & (uint64_t)(*input) ) |
(0x000000000000ff00LL & ((uint64_t)(*(input+1)) << 8 )) |
(0x0000000000ff0000LL & ((uint64_t)(*(input+2)) << 16)) |
(0x00000000ff000000LL & ((uint64_t)(*(input+3)) << 24)) |
(0x000000ff00000000LL & ((uint64_t)(*(input+4)) << 32)) |
(0x0000ff0000000000LL & ((uint64_t)(*(input+5)) << 40)) |
(0x00ff000000000000LL & ((uint64_t)(*(input+6)) << 48)) |
(0xff00000000000000LL & ((uint64_t)(*(input+7)) << 56)) );
input += 8;
k[i] = tmp_k;
}
/*
* Save r0-r7 for final xor
*/
for(i=0;i<8;i++)
{
r_orig[i] = r[i];
}
for(i=0;i<num_steps;i++)
{
tmp_r = r[0];
tmp_k = k[0];
/*
* This implements L_64 on r0 and k0
*/
tmp_r = L_64_table[tmp_r >> 56] ^ (tmp_r << 8);
tmp_k = L_64_table[tmp_k >> 56] ^ (tmp_k << 8);
tmp_r = L_64_table[tmp_r >> 56] ^ (tmp_r << 8);
tmp_k = L_64_table[tmp_k >> 56] ^ (tmp_k << 8);
tmp_r = L_64_table[tmp_r >> 56] ^ (tmp_r << 8);
tmp_k = L_64_table[tmp_k >> 56] ^ (tmp_k << 8);
tmp_r = L_64_table[tmp_r >> 56] ^ (tmp_r << 8);
tmp_k = L_64_table[tmp_k >> 56] ^ (tmp_k << 8);
tmp_r = L_64_table[tmp_r >> 56] ^ (tmp_r << 8);
tmp_k = L_64_table[tmp_k >> 56] ^ (tmp_k << 8);
tmp_r = L_64_table[tmp_r >> 56] ^ (tmp_r << 8);
tmp_k = L_64_table[tmp_k >> 56] ^ (tmp_k << 8);
tmp_r = L_64_table[tmp_r >> 56] ^ (tmp_r << 8);
tmp_k = L_64_table[tmp_k >> 56] ^ (tmp_k << 8);
tmp_r = L_64_table[tmp_r >> 56] ^ (tmp_r << 8);
tmp_k = L_64_table[tmp_k >> 56] ^ (tmp_k << 8);
/*
* Done with L_64.
*
* At this point:
*
* tmp_r = L_64(r[0])
* tmp_k = L_64(k[0])
*/
F_r = F_func(r[6],r[5],r[4],r[3],r[2],r[1],r[0]);
F_k = F_func(k[6],k[5],k[4],k[3],k[2],k[1],k[0]);
#if (ESSENCE_DEBUG_LEVEL & 0x08)
printf("\n--- Step number %i\n",i);
printf(" Values before stepping logic:\n");
for(j=0;j<8;j++)
{
printf(" k[%i] = 0x%.16llx\n",j,k[j]);
}
for(j=0;j<8;j++)
{
printf(" r[%i] = 0x%.16llx\n",j,r[j]);
}
printf(" F(k[6],k[5],k[4],k[3],k[2],k[1],k[0]) = 0x%.16llx\n",F_k);
printf(" F(r[6],r[5],r[4],r[3],r[2],r[1],r[0]) = 0x%.16llx\n",F_r);
printf(" L(k[0]) = 0x%.16llx\n",tmp_k);
printf(" L(r[0]) = 0x%.16llx\n",tmp_r);
#endif
tmp_r ^= F_r ^ r[7];
tmp_r ^= k[7];
tmp_k ^= F_k ^ k[7];
r[7] = r[6];
k[7] = k[6];
r[6] = r[5];
k[6] = k[5];
r[5] = r[4];
k[5] = k[4];
r[4] = r[3];
k[4] = k[3];
r[3] = r[2];
k[3] = k[2];
r[2] = r[1];
k[2] = k[1];
r[1] = r[0];
k[1] = k[0];
r[0] = tmp_r;
k[0] = tmp_k;
#if (ESSENCE_DEBUG_LEVEL & 0x08)
printf(" Values after stepping logic:\n");
for(j=0;j<8;j++)
{
printf(" k[%i] = 0x%.16llx\n",j,k[j]);
}
for(j=0;j<8;j++)
{
printf(" r[%i] = 0x%.16llx\n",j,r[j]);
}
#endif
}
/*
* Final xor
*/
for(i=0;i<8;i++)
{
r[i] ^= r_orig[i];
}
#if (ESSENCE_DEBUG_LEVEL & 0x08)
printf("\nEnd compression loop\n");
printf(" Values after final xor:\n");
for(j=0;j<8;j++)
{
printf(" r[%i] = 0x%.16llx\n",j,r[j]);
}
#endif
--input_size_in_512_bit_blocks;
}
/*
* Write out the chaining variables.
*/
for(i=0;i<8;i++)
{
Chaining_Variables[i] = r[i];
}
#if (ESSENCE_DEBUG_LEVEL & 0x08)
printf("\n*** Leaving 512-bit Compression Function ***\n");
for(i=0;i<8;i++)
{
printf("Chaining_Variables[%i] = 0x%.16llx\n",i,
Chaining_Variables[i]);
}
#endif
}
