Пример #1
0
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));
}
Пример #2
0
static void DVBCSA_INLINE
dvbcsa_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));
}
Пример #3
0
/**
set up data used for stream. Depends on scrambled data only, so can be global
@param   data_return[out]     bit sliced output data IB1
@param   outbits[in]          number of bits to calculate
@param   BS_key[in]           bit sliced key array 64 elements
@param   bs_data_sb0[in]      bit sliced 1st data block used for initialization
*/
void aycw_stream_decrypt(dvbcsa_bs_word_t * data_return, unsigned int outbits, dvbcsa_bs_word_t * BS_key, dvbcsa_bs_word_t *bs_data_sb0)
{
   unsigned int      i;
   dvbcsa_bs_word_t    BS_Streambit0, BS_Streambit1;
   aycw_tstRegister stRegister/*=
   {
   {0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,    0,0,0,0,0,0,0,0,0,0,    0,0,0,0,0,0,0,0,0,0,    0,0,0,0/*,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,    0,0,0,0,0,0,0,0,0,0,    0,0,0,0,0,0,0,0,0,0* /},
   {0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,    0,0,0,0,0,0,0,0,0,0,    0,0,0,0,0,0,0,0,0,0,    0,0,0,0/*,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,    0,0,0,0,0,0,0,0,0,0,    0,0,0,0,0,0,0,0,0,0* /},
   }*/;
   aycw_tstPQXYZ stPQXYZ =
   {
      0,
      0,
      0, 0, 0, 0,
      0, 0, 0, 0,
      0, 0, 0, 0
   };
   aycw_tstCDEF stCDEF =
   {
      0,
      0, 0, 0, 0,
      0, 0, 0, 0,
      0, 0, 0, 0
   };
   // aycw__vInitVariables( &stPQXYZ, &stCDEF ,  & BS_Streambit0,   & BS_Streambit1);

   /*  aycw_vInitVariables();*/
   /*  BS_vTransformMultiKey((char *) cw);*/
   /* init A and B - bs */
   aycw__vInitShiftRegister(BS_key, &stRegister);
   /* init A and B - bs */
   for (i = 0; i < 8; i++)
   {
      aycw__vInitRound(0, i, &stPQXYZ, &stCDEF, &stRegister, bs_data_sb0);
      aycw__vInitRound(1, i, &stPQXYZ, &stCDEF, &stRegister, bs_data_sb0);
      aycw__vInitRound(2, i, &stPQXYZ, &stCDEF, &stRegister, bs_data_sb0);
      aycw__vInitRound(3, i, &stPQXYZ, &stCDEF, &stRegister, bs_data_sb0);
   }

   for (i = 0; i < outbits; i += 8)
   {
      aycw__vRound(&stPQXYZ, &stCDEF, &stRegister, &BS_Streambit0, &BS_Streambit1);
      data_return[i + 6] = BS_XOR(bs_data_sb0[i + 64 + 6], BS_Streambit0);
      data_return[i + 7] = BS_XOR(bs_data_sb0[i + 64 + 7], BS_Streambit1);
      aycw__vRound(&stPQXYZ, &stCDEF, &stRegister, &BS_Streambit0, &BS_Streambit1);
      data_return[i + 4] = BS_XOR(bs_data_sb0[i + 64 + 4], BS_Streambit0);
      data_return[i + 5] = BS_XOR(bs_data_sb0[i + 64 + 5], BS_Streambit1);
      aycw__vRound(  &stPQXYZ, &stCDEF, &stRegister, &BS_Streambit0, &BS_Streambit1);
      data_return[i + 2] = BS_XOR(bs_data_sb0[i + 64 + 2], BS_Streambit0);
      data_return[i + 3] = BS_XOR(bs_data_sb0[i + 64 + 3], BS_Streambit1);
      aycw__vRound(  &stPQXYZ, &stCDEF, &stRegister, &BS_Streambit0, &BS_Streambit1);
      data_return[i + 0] = BS_XOR(bs_data_sb0[i + 64 + 0], BS_Streambit0);
      data_return[i + 1] = BS_XOR(bs_data_sb0[i + 64 + 1], BS_Streambit1);
   }
}
Пример #4
0
void
dvbcsa_bs_stream_cipher_batch(const struct dvbcsa_bs_key_s *key,
			      const struct dvbcsa_bs_batch_s *pcks,
			      unsigned int maxlen)
{
  dvbcsa_bs_word_t A[32 + 10][4];	// 32 because we will move back (virtual shift register)
  dvbcsa_bs_word_t B[32 + 10][4];	// 32 because we will move back (virtual shift register)
  dvbcsa_bs_word_t X[4];
  dvbcsa_bs_word_t Y[4];
  dvbcsa_bs_word_t Z[4];
  dvbcsa_bs_word_t D[4];
  dvbcsa_bs_word_t E[4];
  dvbcsa_bs_word_t F[4];
  dvbcsa_bs_word_t p;
  dvbcsa_bs_word_t q;
  dvbcsa_bs_word_t r;
  dvbcsa_bs_word_t in1[4];
  dvbcsa_bs_word_t in2[4];
  dvbcsa_bs_word_t extra_B[4];
  dvbcsa_bs_word_t s1a, s1b, s2a, s2b, s3a, s3b, s4a, s4b, s5a, s5b, s6a, s6b, s7a, s7b;
  dvbcsa_bs_word_t next_E[4];
  dvbcsa_bs_word_t tmp0, tmp1, tmp3, tmp4;
  dvbcsa_bs_word_t sb[64];
  int h, i, j, k, b;

  dvbcsa_bs_stream_transpose_in(pcks, sb);

  for (b = 0; b < 4; b++)
    {
      for (i = 0; i < 8; i++)
	{
	  A[i][b] = key->stream[b + i * 4];
	  B[i][b] = key->stream[b + i * 4 + 32];
	}

      // all other regs = 0
      A[8][b] = BS_VAL8(00);
      A[9][b] = BS_VAL8(00);
      B[8][b] = BS_VAL8(00);
      B[9][b] = BS_VAL8(00);

      X[b] = BS_VAL8(00);
      Y[b] = BS_VAL8(00);
      Z[b] = BS_VAL8(00);
      D[b] = BS_VAL8(00);
      E[b] = BS_VAL8(00);
      F[b] = BS_VAL8(00);
    }

  p = BS_VAL8(00);
  q = BS_VAL8(00);
  r = BS_VAL8(00);

  /* Stream INIT */

  for (i = 0; i < 8; i++)
    {

      for (b = 0; b < 4; b++)
	{
	  in1[b] = sb[8 * i + 4 + b];
	  in2[b] = sb[8 * i + b];
	}

      for (j = 0; j < 4; j++)
	{
	  dvbcsa_bs_stream_sbox1(A[0][2], A[5][1], A[6][3], A[8][0], A[3][0], &s1a, &s1b);
	  dvbcsa_bs_stream_sbox2(A[2][2], A[5][3], A[6][0], A[8][1], A[1][1], &s2a, &s2b);
	  dvbcsa_bs_stream_sbox3(A[1][0], A[4][1], A[4][3], A[5][2], A[0][3], &s3a, &s3b);
	  dvbcsa_bs_stream_sbox4(A[0][1], A[1][3], A[3][2], A[7][0], A[2][3], &s4a, &s4b);
	  dvbcsa_bs_stream_sbox5(A[3][3], A[5][0], A[7][1], A[8][2], A[4][2], &s5a, &s5b);
	  dvbcsa_bs_stream_sbox6(A[3][1], A[4][0], A[6][2], A[8][3], A[2][1], &s6a, &s6b);
	  dvbcsa_bs_stream_sbox7(A[2][0], A[6][1], A[7][2], A[7][3], A[1][2], &s7a, &s7b);

	  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]);

	  for (b = 0; b < 4; b++)
	    {
	      dvbcsa_bs_word_t	A_next;

	      A_next = BS_XOR (A[9][b], X[b]);
	      A_next = BS_XOR (BS_XOR (A_next, D[b]), ((j % 2) ? in2[b] : in1[b]));

	      for (k = 9; k > 0; k--)
		A[k][b] = A[k - 1][b];

	      A[0][b] = A_next;
	    }

	  dvbcsa_bs_word_t	B_next[4];

	  for (b = 0; b < 4; b++)
	    {
	      B_next[b] = BS_XOR (BS_XOR (B[6][b], B[9][b]), Y[b]);
	      B_next[b] = BS_XOR (B_next[b], ((j % 2) ? in1[b] : in2[b]));
	    }

	  tmp3 = B_next[3];
	  B_next[3] = BS_XOR (B_next[3], BS_AND (BS_XOR (B_next[3], B_next[2]), p));
	  B_next[2] = BS_XOR (B_next[2], BS_AND (BS_XOR (B_next[2], B_next[1]), p));
	  B_next[1] = BS_XOR (B_next[1], BS_AND (BS_XOR (B_next[1], B_next[0]), p));
	  B_next[0] = BS_XOR (B_next[0], BS_AND (BS_XOR (B_next[0], tmp3), p));

	  for (b = 0; b < 4; b++)
	    {
	      for (k = 9; k > 0; k--)
		B[k][b] = B[k - 1][b];

	      B[0][b] = B_next[b];
	    }

	  for (b = 0; b < 4; b++)
	    D[b] = BS_XOR (BS_XOR (E[b], Z[b]), extra_B[b]);

	  for (b = 0; b < 4; b++)
	    next_E[b] = F[b];

	  tmp0 = BS_XOR (Z[0], E[0]);
	  tmp1 = BS_AND (Z[0], E[0]);
	  F[0] = BS_XOR (E[0], BS_AND (q, BS_XOR (Z[0], r)));
	  tmp3 = BS_AND (tmp0, r);
	  tmp4 = BS_OR (tmp1, tmp3);

	  tmp0 = BS_XOR (Z[1], E[1]);
	  tmp1 = BS_AND (Z[1], E[1]);
	  F[1] = BS_XOR (E[1], BS_AND (q, BS_XOR (Z[1], tmp4)));
	  tmp3 = BS_AND (tmp0, tmp4);
	  tmp4 = BS_OR (tmp1, tmp3);

	  tmp0 = BS_XOR (Z[2], E[2]);
	  tmp1 = BS_AND (Z[2], E[2]);
	  F[2] = BS_XOR (E[2], BS_AND (q, BS_XOR (Z[2], tmp4)));
	  tmp3 = BS_AND (tmp0, tmp4);
	  tmp4 = BS_OR (tmp1, tmp3);

	  tmp0 = BS_XOR (Z[3], E[3]);
	  tmp1 = BS_AND (Z[3], E[3]);
	  F[3] = BS_XOR (E[3], BS_AND (q, BS_XOR (Z[3], tmp4)));
	  tmp3 = BS_AND (tmp0, tmp4);
	  r = BS_XOR (r, BS_AND (q, BS_XOR (BS_OR (tmp1, tmp3), r)));	// ultimate carry

	  for (b = 0; b < 4; b++)
	    E[b] = next_E[b];

	  X[0] = s1a;
	  X[1] = s2a;
	  X[2] = s3b;
	  X[3] = s4b;
	  Y[0] = s3a;
	  Y[1] = s4a;
	  Y[2] = s5b;
	  Y[3] = s6b;
	  Z[0] = s5a;
	  Z[1] = s6a;
	  Z[2] = s1b;
	  Z[3] = s2b;
	  p = s7a;
	  q = s7b;

	}

    }

  /* Stream GEN */

  for (h = 8; h < maxlen; h++)
    {
      dvbcsa_bs_word_t cb[8];

      for (j = 0; j < 4; j++)
	{
	  dvbcsa_bs_stream_sbox1(A[0][2], A[5][1], A[6][3], A[8][0], A[3][0], &s1a, &s1b);
	  dvbcsa_bs_stream_sbox2(A[2][2], A[5][3], A[6][0], A[8][1], A[1][1], &s2a, &s2b);
	  dvbcsa_bs_stream_sbox3(A[1][0], A[4][1], A[4][3], A[5][2], A[0][3], &s3a, &s3b);
	  dvbcsa_bs_stream_sbox4(A[0][1], A[1][3], A[3][2], A[7][0], A[2][3], &s4a, &s4b);
	  dvbcsa_bs_stream_sbox5(A[3][3], A[5][0], A[7][1], A[8][2], A[4][2], &s5a, &s5b);
	  dvbcsa_bs_stream_sbox6(A[3][1], A[4][0], A[6][2], A[8][3], A[2][1], &s6a, &s6b);
	  dvbcsa_bs_stream_sbox7(A[2][0], A[6][1], A[7][2], A[7][3], A[1][2], &s7a, &s7b);

	  // use 4x4 xor to produce extra nibble for T3

	  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]);

	  // T1 = xor all inputs
	  // in1, in2, D are only used in T1 during initialisation, not generation
	  for (b = 0; b < 4; b++)
	    {
	      dvbcsa_bs_word_t	A_next;

	      A_next = BS_XOR (A[9][b], X[b]);

	      for (k = 9; k > 0; k--)
		A[k][b] = A[k - 1][b];

	      A[0][b] = A_next;
	    }

	  dvbcsa_bs_word_t	B_next[4];

	  // T2 =  xor all inputs
	  // in1, in2 are only used in T1 during initialisation, not generation
	  // if p=0, use this, if p=1, rotate the result left
	  for (b = 0; b < 4; b++)
	    B_next[b] = BS_XOR (BS_XOR (B[6][b], B[9][b]), Y[b]);

	  // if p=1, rotate left (yes, this is what we're doing)
	  tmp3 = B_next[3];
	  B_next[3] = BS_XOR (B_next[3], BS_AND (BS_XOR (B_next[3], B_next[2]), p));
	  B_next[2] = BS_XOR (B_next[2], BS_AND (BS_XOR (B_next[2], B_next[1]), p));
	  B_next[1] = BS_XOR (B_next[1], BS_AND (BS_XOR (B_next[1], B_next[0]), p));
	  B_next[0] = BS_XOR (B_next[0], BS_AND (BS_XOR (B_next[0], tmp3), p));

	  for (b = 0; b < 4; b++)
	    {
	      for (k = 9; k > 0; k--)
		B[k][b] = B[k - 1][b];

	      B[0][b] = B_next[b];
	    }

	  // T3 = xor all inputs
	  for (b = 0; b < 4; b++)
	    D[b] = BS_XOR (BS_XOR (E[b], Z[b]), extra_B[b]);

	  // T4 = sum, carry of Z + E + r
	  for (b = 0; b < 4; b++)
	    next_E[b] = F[b];

	  tmp0 = BS_XOR (Z[0], E[0]);
	  tmp1 = BS_AND (Z[0], E[0]);
	  F[0] = BS_XOR (E[0], BS_AND (q, BS_XOR (Z[0], r)));
	  tmp3 = BS_AND (tmp0, r);
	  tmp4 = BS_OR (tmp1, tmp3);

	  tmp0 = BS_XOR (Z[1], E[1]);
	  tmp1 = BS_AND (Z[1], E[1]);
	  F[1] = BS_XOR (E[1], BS_AND (q, BS_XOR (Z[1], tmp4)));
	  tmp3 = BS_AND (tmp0, tmp4);
	  tmp4 = BS_OR (tmp1, tmp3);

	  tmp0 = BS_XOR (Z[2], E[2]);
	  tmp1 = BS_AND (Z[2], E[2]);
	  F[2] = BS_XOR (E[2], BS_AND (q, BS_XOR (Z[2], tmp4)));
	  tmp3 = BS_AND (tmp0, tmp4);
	  tmp4 = BS_OR (tmp1, tmp3);

	  tmp0 = BS_XOR (Z[3], E[3]);
	  tmp1 = BS_AND (Z[3], E[3]);
	  F[3] = BS_XOR (E[3], BS_AND (q, BS_XOR (Z[3], tmp4)));
	  tmp3 = BS_AND (tmp0, tmp4);
	  r = BS_XOR (r, BS_AND (q, BS_XOR (BS_OR (tmp1, tmp3), r)));	// ultimate carry

	  for (b = 0; b < 4; b++)
	    E[b] = next_E[b];

	  X[0] = s1a;
	  X[1] = s2a;
	  X[2] = s3b;
	  X[3] = s4b;
	  Y[0] = s3a;
	  Y[1] = s4a;
	  Y[2] = s5b;
	  Y[3] = s6b;
	  Z[0] = s5a;
	  Z[1] = s6a;
	  Z[2] = s1b;
	  Z[3] = s2b;

	  p = s7a;
	  q = s7b;

	  // require 4 loops per output byte
	  // 2 output bits are a function of the 4 bits of D
	  // xor 2 by 2
	  cb[7 - 2 * j] = BS_XOR (D[2], D[3]);
	  cb[6 - 2 * j] = BS_XOR (D[0], D[1]);
	}				// EXTERNAL LOOP

      ////////////////////////////////////////////////////////////////////////////////

      dvbcsa_bs_stream_transpose_out(pcks, h, cb);

    }

}
Пример #5
0
/****** 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]);

}
Пример #6
0
/****** 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);

}