static void DVBCSA_INLINE
dvbcsa_bs_stream_sbox3(dvbcsa_bs_word_t fa, dvbcsa_bs_word_t fb,
dvbcsa_bs_word_t fc, dvbcsa_bs_word_t fd,
dvbcsa_bs_word_t fe,
dvbcsa_bs_word_t *sa, dvbcsa_bs_word_t *sb)
{
dvbcsa_bs_word_t tmp0, tmp1, tmp2;
tmp0 = BS_XOR (fa, BS_XOR (fb, BS_XOR (BS_AND (fc, BS_OR (fa, fd)), fd)));
tmp1 = BS_XOR (BS_AND (fa, fc), BS_OR (BS_XOR (fa, fd), BS_XOR (BS_OR (fb, fc), BS_NOT (fd))));
tmp2 = BS_XOR (fa, BS_XOR (BS_AND (BS_XOR (fb, fc), fd), fc));
*sa = BS_XOR (tmp0, BS_AND (BS_NOT (fe), tmp1));
*sb = BS_XOR (tmp2, fe);
}
static AYCW_INLINE void aycw_bs_stream_sbox2(dvbcsa_bs_word_t *fa, dvbcsa_bs_word_t *fb,
dvbcsa_bs_word_t *fc, dvbcsa_bs_word_t *fd,
dvbcsa_bs_word_t *fe,
dvbcsa_bs_word_t *sa, dvbcsa_bs_word_t *sb)
{
dvbcsa_bs_word_t tmp0, tmp1, tmp2, tmp3;
tmp0 = BS_XOR (*fa, BS_XOR (BS_AND (*fb, BS_OR (*fc, *fd)), BS_XOR (*fc, BS_NOT (*fd))));
tmp1 = BS_OR (BS_AND (*fa, BS_XOR (*fb, *fd)), BS_AND (BS_OR (*fa, *fb), *fc));
tmp2 = BS_XOR (BS_AND (*fb, *fd), BS_OR (BS_AND (*fa, *fd), BS_XOR (*fb, BS_NOT (*fc))));
tmp3 = BS_OR (BS_AND (*fa, *fd), BS_XOR (*fa, BS_XOR (*fb, BS_AND (*fc, *fd))));
*sa = BS_XOR (tmp0, BS_AND (*fe, tmp1));
*sb = BS_XOR (tmp2, BS_AND (*fe, tmp3));
}
/****** execute round **************/
AYCW_INLINE void aycw__vRound(aycw_tstPQXYZ *stPQXYZ,
aycw_tstCDEF *stCDEF ,
aycw_tstRegister *stRegister,
dvbcsa_bs_word_t *BS_Streambit0,
dvbcsa_bs_word_t *BS_Streambit1)
{
uint8 k;
dvbcsa_bs_word_t tmp0,tmp4,tmp1,tmp3;
uint8 b;
dvbcsa_bs_word_t BS_TMP_B[5];
dvbcsa_bs_word_t BS_TMP_B_Result[4];
dvbcsa_bs_word_t BS_Bout[4];
dvbcsa_bs_word_t BS_Enew[4];
aycw__ShiftRegisterLeft( stRegister->A_BS, 4, 80);
for (k = 0; k < 4; k++)
{
stRegister->A_BS[k] = stRegister->A_BS[k+40];
BS_XOREQ(stRegister->A_BS[k], stPQXYZ->BS_X[k]);
}
for (k = 0; k < 4; k++)
{
//A: 0x0000000bb6510468
//B: 0x00000006baf6a610
// BS_ConverToDoubleArray(&tmpDoubleArray,B_BS,40);
BS_TMP_B[k] = BS_XOR(stRegister->B_BS[k+6*4], stRegister->B_BS[k+9*4]);
// BS_ConverToByteArray(&tmpByteArray,BS_TMP_B,4);
BS_TMP_B[k] = BS_XOR(BS_TMP_B[k], stPQXYZ->BS_Y[k]);
// BS_ConverToIntArray(tmpIntArray,B_BS,40);
#if Init
BS_TMP_B[k] = BS_TMP_B[k] ^ A_tBITVALUE(&u32IV, 0, k);
BS_ConverToIntArray(tmpIntArray,B_BS,40);
#endif
BS_TMP_B_Result[k] = BS_AND(BS_TMP_B[k], BS_NOT(stPQXYZ->BS_P)); //Die nicht zu rotierenden Daten zunächst zwischenspeichern.
// BS_ConverToIntArray(tmpIntArray,B_BS,40);
//B: 0x00000006baf6a617
}
for (k = 4; k > 0; k--)
{
BS_TMP_B[k] = BS_TMP_B[k-1];
}
BS_TMP_B[0] = BS_TMP_B[4];
aycw__ShiftRegisterLeft( stRegister->B_BS, 4, 80);
for ( k = 0; k < 4; k++)
{
stRegister->B_BS[k] = BS_OR(BS_AND(BS_TMP_B[k], stPQXYZ->BS_P), BS_TMP_B_Result[k]);
}
// BS_ConverToIntArray(tmpIntArray,B_BS,40);
// BS_ConverToDoubleArray(&tmpDoubleArray,B_BS,40);
/********** execute combiner calc **********/
/* calc of bout*/
/*
Bout 3 := b2,0 b5,1 b6,2 b8,3
Bout 2 := b5,0 b7,1 b2,3 b3,2
Bout 1 := b4,3 b7,2 b3,0 b4,1
Bout 0 := b8,2 b5,3 b2,1 b7,0
*/
/*12 25 30 37*/
/* 10000000 01000010000000000001000000000000 */
/*15 18 24 33*/
/* 00000010 00000001000001001000000000000000 */
/*16 21 23 34*/
/* 00000100 00000000101000010000000000000000 */
/*13 27 32 38*/
/* 01000001 00001000000000000010000000000000 */
/*8 21 26 35*/
/*extra_B[3] = BS_XOR (BS_XOR (BS_XOR (B[2][0], B[5][1]), B[6][2]), B[8][3]);
extra_B[2] = BS_XOR (BS_XOR (BS_XOR (B[5][0], B[7][1]), B[2][3]), B[3][2]);
extra_B[1] = BS_XOR (BS_XOR (BS_XOR (B[4][3], B[7][2]), B[3][0]), B[4][1]);
extra_B[0] = BS_XOR (BS_XOR (BS_XOR (B[8][2], B[5][3]), B[2][1]), B[7][0]);*/
/*
#define shiftB 4
BS_Bout[3] = stRegister->B_BS[2*4 + 0 + shiftB ] ^ stRegister->B_BS[5*4 + 1 + shiftB ] ^ stRegister->B_BS[6*4 + 2 + shiftB ] ^ stRegister->B_BS[8*4 + 3 + shiftB ] ;
BS_Bout[2] = stRegister->B_BS[5*4 + 0 + shiftB ] ^ stRegister->B_BS[7*4 + 1 + shiftB ] ^ stRegister->B_BS[2*4 + 3 + shiftB ] ^ stRegister->B_BS[3*4 + 2 + shiftB ] ;
BS_Bout[1] = stRegister->B_BS[4*4 + 3 + shiftB ] ^ stRegister->B_BS[7*4 + 2 + shiftB ] ^ stRegister->B_BS[3*4 + 0 + shiftB ] ^ stRegister->B_BS[4*4 + 1 + shiftB ] ;
BS_Bout[0] = stRegister->B_BS[8*4 + 2 + shiftB ] ^ stRegister->B_BS[5*4 + 3 + shiftB ] ^ stRegister->B_BS[2*4 + 1 + shiftB ] ^ stRegister->B_BS[7*4 + 0 + shiftB ] ;
*/
BS_Bout[3] = BS_XOR(BS_XOR(stRegister->B_BS[12], stRegister->B_BS[25]), BS_XOR(stRegister->B_BS[30], stRegister->B_BS[39]));
BS_Bout[2] = BS_XOR(BS_XOR(stRegister->B_BS[24], stRegister->B_BS[33]), BS_XOR(stRegister->B_BS[15], stRegister->B_BS[18]));
BS_Bout[1] = BS_XOR(BS_XOR(stRegister->B_BS[23], stRegister->B_BS[34]), BS_XOR(stRegister->B_BS[16], stRegister->B_BS[21]));
BS_Bout[0] = BS_XOR(BS_XOR(stRegister->B_BS[38], stRegister->B_BS[27]), BS_XOR(stRegister->B_BS[13], stRegister->B_BS[32]));
/*
Bout[3] = B_BS[1*4 + 0 ] ^ B_BS[4*4 + 1 ] ^ B_BS[5*4 + 2 ] ^ B_BS[7*4 + 3 ] ;
Bout[2] = B_BS[4*4 + 0 ] ^ B_BS[6*4 + 1 ] ^ B_BS[1*4 + 3 ] ^ B_BS[2*4 + 2 ] ;
Bout[1] = B_BS[3*4 + 3 ] ^ B_BS[6*4 + 2 ] ^ B_BS[2*4 + 0 ] ^ B_BS[3*4 + 1 ] ;
Bout[0] = B_BS[7*4 + 2 ] ^ B_BS[4*4 + 3 ] ^ B_BS[1*4 + 1 ] ^ B_BS[6*4 + 0 ] ;
*/
/* calc of D */
for (k = 0; k < 4; k++)
{
/* use old E????*/
stCDEF->BS_D[k] = BS_XOR(BS_XOR(BS_Bout[k], stCDEF->BS_E [k]), stPQXYZ->BS_Z[k]);
// BS_ConverToByteArray(&tmpByteArray,BS_E,4);
// BS_ConverToByteArray(&tmpByteArray,BS_Z,4);
}
// BS_ConverToByteArray(&tmpByteArray,BS_D,4);
for (b = 0; b < 4; b++)
BS_Enew[b] = stCDEF->BS_F[b];
tmp0 = BS_XOR (stPQXYZ->BS_Z[0], stCDEF->BS_E[0]);
tmp1 = BS_AND (stPQXYZ->BS_Z[0], stCDEF->BS_E[0]);
stCDEF->BS_F[0] = BS_XOR (stCDEF->BS_E[0], BS_AND (stPQXYZ->BS_Q, BS_XOR (stPQXYZ->BS_Z[0], stCDEF->BS_C)));
tmp3 = BS_AND (tmp0, stCDEF->BS_C);
tmp4 = BS_OR (tmp1, tmp3);
tmp0 = BS_XOR (stPQXYZ->BS_Z[1], stCDEF->BS_E[1]);
tmp1 = BS_AND (stPQXYZ->BS_Z[1], stCDEF->BS_E[1]);
stCDEF->BS_F[1] = BS_XOR (stCDEF->BS_E[1], BS_AND (stPQXYZ->BS_Q, BS_XOR (stPQXYZ->BS_Z[1], tmp4)));
tmp3 = BS_AND (tmp0, tmp4);
tmp4 = BS_OR (tmp1, tmp3);
tmp0 = BS_XOR (stPQXYZ->BS_Z[2], stCDEF->BS_E[2]);
tmp1 = BS_AND (stPQXYZ->BS_Z[2], stCDEF->BS_E[2]);
stCDEF->BS_F[2] = BS_XOR (stCDEF->BS_E[2], BS_AND (stPQXYZ->BS_Q, BS_XOR (stPQXYZ->BS_Z[2], tmp4)));
tmp3 = BS_AND (tmp0, tmp4);
tmp4 = BS_OR (tmp1, tmp3);
tmp0 = BS_XOR (stPQXYZ->BS_Z[3], stCDEF->BS_E[3]);
tmp1 = BS_AND (stPQXYZ->BS_Z[3], stCDEF->BS_E[3]);
stCDEF->BS_F[3] = BS_XOR (stCDEF->BS_E[3], BS_AND (stPQXYZ->BS_Q, BS_XOR (stPQXYZ->BS_Z[3], tmp4)));
tmp3 = BS_AND (tmp0, tmp4);
stCDEF->BS_C = BS_XOR (stCDEF->BS_C, BS_AND (stPQXYZ->BS_Q, BS_XOR (BS_OR (tmp1, tmp3), stCDEF->BS_C))); // ultimate carry
for (b = 0; b < 4; b++)
stCDEF->BS_E[b] = BS_Enew[b];
aycw__vCaculatePQXYZ(stRegister->A_BS, stPQXYZ);
/* calc stream bit */
*BS_Streambit0 = BS_XOR(stCDEF->BS_D[0], stCDEF->BS_D[1]);
*BS_Streambit1 = BS_XOR(stCDEF->BS_D[2], stCDEF->BS_D[3]);
}
/****** execute init round **************/
AYCW_INLINE void aycw__vInitRound(uint8 j, uint8 u8Byte,
aycw_tstPQXYZ * stPQXYZ ,
aycw_tstCDEF *stCDEF,
aycw_tstRegister *stRegister,
dvbcsa_bs_word_t *bs_data_sb0)
{
uint8 k;
dvbcsa_bs_word_t /*tmp,*/tmp0,tmp4,tmp1,tmp3;
uint8 b;
/*uint8 u32IV;*/
dvbcsa_bs_word_t BS_TMP_B[5];
dvbcsa_bs_word_t BS_TMP_B_Result[4];
dvbcsa_bs_word_t BS_Bout[4];
dvbcsa_bs_word_t BS_Enew[4];
/*
if (j & 0x1) // all odd
{
u32IV = (iv >> 4 | (iv << 4));
}
else
{
u32IV = iv;
}
*/
aycw__ShiftRegisterLeft( stRegister->A_BS, 4, 44);
for (k = 0; k < 4; k++)
{
stRegister->A_BS[k] = stRegister->A_BS[k+40];
BS_XOREQ(stRegister->A_BS[k],stPQXYZ->BS_X[k]);
BS_XOREQ(stRegister->A_BS[k],stCDEF->BS_D[k]); /* data, byte, bit */
BS_XOREQ(stRegister->A_BS[k],( (j & 0x1)?bs_data_sb0[k+u8Byte*8]:bs_data_sb0[k+4+u8Byte*8]));
}
for (k = 0; k < 4; k++)
{
BS_TMP_B[k] = BS_XOR(stRegister->B_BS[k+6*4], stRegister->B_BS[k+9*4]);
BS_TMP_B[k] = BS_XOR(BS_TMP_B[k], stPQXYZ->BS_Y[k]);
// OPTIMIZEME: optimizeable by using the upper A_tBITVALUE calculation
/*tmp = (j & 0x1)?bs_data_sb0[k+4+u8Byte*8]:bs_data_sb0[k+u8Byte*8];
tmp0 = aycw__BitExpandOfByteToBsWord(&u32IV, 0, k);
if (tmp0 != tmp)
return 0;*/
BS_TMP_B[k] = BS_XOR(BS_TMP_B[k], ( (j & 0x1)?bs_data_sb0[k+4+u8Byte*8]:bs_data_sb0[k+u8Byte*8]));
BS_TMP_B_Result[k] = BS_AND(BS_TMP_B[k], BS_NOT(stPQXYZ->BS_P)); //Die nicht zu rotierenden Daten zunächst zwischenspeichern.
}
/* yet rotate B */
/* OPTIMIZEME: write into B directly?? */
for (k = 4; k > 0; k--)
{
BS_TMP_B[k] = BS_TMP_B[k-1];
}
BS_TMP_B[0] = BS_TMP_B[4];
/* B must not be moved by 4 before handling is finished */
aycw__ShiftRegisterLeft(stRegister->B_BS, 4, 44);
/* now write the result, both rotated and unrotated */
for ( k = 0; k < 4; k++)
{ // rotated //not rotated
stRegister->B_BS[k] = BS_OR(BS_AND(BS_TMP_B[k], stPQXYZ->BS_P), BS_TMP_B_Result[k]);
}
/********** Combiner calculation **********/
/* calc bout
Bout 3 := b2,0 b5,1 b6,2 b8,3
Bout 2 := b5,0 b7,1 b2,3 b3,2
Bout 1 := b4,3 b7,2 b3,0 b4,1
Bout 0 := b8,2 b5,3 b2,1 b7,0
*/
/*
#define shiftB 4
BS_Bout[3] = stRegister->B_BS[2*4 + 0 + shiftB ] ^ stRegister->B_BS[5*4 + 1 + shiftB ] ^ stRegister->B_BS[6*4 + 2 + shiftB ] ^ stRegister->B_BS[8*4 + 3 + shiftB ] ;
BS_Bout[2] = stRegister->B_BS[5*4 + 0 + shiftB ] ^ stRegister->B_BS[7*4 + 1 + shiftB ] ^ stRegister->B_BS[2*4 + 3 + shiftB ] ^ stRegister->B_BS[3*4 + 2 + shiftB ] ;
BS_Bout[1] = stRegister->B_BS[4*4 + 3 + shiftB ] ^ stRegister->B_BS[7*4 + 2 + shiftB ] ^ stRegister->B_BS[3*4 + 0 + shiftB ] ^ stRegister->B_BS[4*4 + 1 + shiftB ] ;
BS_Bout[0] = stRegister->B_BS[8*4 + 2 + shiftB ] ^ stRegister->B_BS[5*4 + 3 + shiftB ] ^ stRegister->B_BS[2*4 + 1 + shiftB ] ^ stRegister->B_BS[7*4 + 0 + shiftB ] ;
*/
BS_Bout[3] = BS_XOR(BS_XOR(stRegister->B_BS[12], stRegister->B_BS[25]), BS_XOR(stRegister->B_BS[30], stRegister->B_BS[39]));
BS_Bout[2] = BS_XOR(BS_XOR(stRegister->B_BS[24], stRegister->B_BS[33]), BS_XOR(stRegister->B_BS[15], stRegister->B_BS[18]));
BS_Bout[1] = BS_XOR(BS_XOR(stRegister->B_BS[23], stRegister->B_BS[34]), BS_XOR(stRegister->B_BS[16], stRegister->B_BS[21]));
BS_Bout[0] = BS_XOR(BS_XOR(stRegister->B_BS[38], stRegister->B_BS[27]), BS_XOR(stRegister->B_BS[13], stRegister->B_BS[32]));
/* calc D */
for (k = 0; k < 4; k++)
{
stCDEF->BS_D[k] = BS_XOR(BS_XOR(BS_Bout[k], stCDEF->BS_E[k]), stPQXYZ->BS_Z[k]);
}
for (b = 0; b < 4; b++)
BS_Enew[b] = stCDEF->BS_F[b];
tmp0 = BS_XOR (stPQXYZ->BS_Z[0], stCDEF->BS_E[0]);
tmp1 = BS_AND (stPQXYZ->BS_Z[0], stCDEF->BS_E[0]);
stCDEF->BS_F[0] = BS_XOR (stCDEF->BS_E[0], BS_AND (stPQXYZ->BS_Q, BS_XOR (stPQXYZ->BS_Z[0], stCDEF->BS_C)));
tmp3 = BS_AND (tmp0, stCDEF->BS_C);
tmp4 = BS_OR (tmp1, tmp3);
tmp0 = BS_XOR (stPQXYZ->BS_Z[1], stCDEF->BS_E[1]);
tmp1 = BS_AND (stPQXYZ->BS_Z[1], stCDEF->BS_E[1]);
stCDEF->BS_F[1] = BS_XOR (stCDEF->BS_E[1], BS_AND (stPQXYZ->BS_Q, BS_XOR (stPQXYZ->BS_Z[1], tmp4)));
tmp3 = BS_AND (tmp0, tmp4);
tmp4 = BS_OR (tmp1, tmp3);
tmp0 = BS_XOR (stPQXYZ->BS_Z[2], stCDEF->BS_E[2]);
tmp1 = BS_AND (stPQXYZ->BS_Z[2], stCDEF->BS_E[2]);
stCDEF->BS_F[2] = BS_XOR (stCDEF->BS_E[2], BS_AND (stPQXYZ->BS_Q, BS_XOR (stPQXYZ->BS_Z[2], tmp4)));
tmp3 = BS_AND (tmp0, tmp4);
tmp4 = BS_OR (tmp1, tmp3);
tmp0 = BS_XOR (stPQXYZ->BS_Z[3], stCDEF->BS_E[3]);
tmp1 = BS_AND (stPQXYZ->BS_Z[3], stCDEF->BS_E[3]);
stCDEF->BS_F[3] = BS_XOR (stCDEF->BS_E[3], BS_AND (stPQXYZ->BS_Q, BS_XOR (stPQXYZ->BS_Z[3], tmp4)));
tmp3 = BS_AND (tmp0, tmp4);
stCDEF->BS_C = BS_XOR (stCDEF->BS_C, BS_AND (stPQXYZ->BS_Q, BS_XOR (BS_OR (tmp1, tmp3), stCDEF->BS_C))); // ultimate carry
for (b = 0; b < 4; b++)
stCDEF->BS_E[b] = BS_Enew[b];
aycw__vCaculatePQXYZ(stRegister->A_BS, stPQXYZ);
}
