stream.c

这是一个LINUX环境的 VDR 插件源代码,可支持Irdeto, Seca, Viaccess, Nagra, Conax & Cryptoworks等CA系统的读卡、共享等操作。

/* 1111 1111  1111 1111   : lev  0: */ tmp3=FF1();
      s3a=FFXOR(tmp0,FFAND(FFNOT(fe),tmp1));
      s3b=FFXOR(tmp2,FFAND(fe,tmp3));

      fe=regs->A[aboff+2][3];fa=regs->A[aboff+0][1];fb=regs->A[aboff+1][3];fc=regs->A[aboff+3][2];fd=regs->A[aboff+7][0];
/* 1011 0101  0100 1001   : lev  7: */ //tmp0=( fa^( ( fc&( fa^fd ) )|( fb^( fc|( fd^ALL_ONES ) ) ) ) );
/* 0010 1101  0110 0110   : lev  6: */ //tmp1=( ( fa&fb )^( fb^( ( ( fa|fc )&fd )^fc ) ) );
/* 0110 0111  1101 0000   : lev  7: */ //tmp2=( fa^( ( fb&fc )|( ( ( fa&( fb^fd ) )|fc )^fd ) ) );
/* 1111 1111  1111 1111   : lev  0: */ //tmp3=ALL_ONES;
/* 1011 0101  0100 1001   : lev  7: */ tmp0=FFXOR(fa,FFOR(FFAND(fc,FFXOR(fa,fd)),FFXOR(fb,FFOR(fc,FFXOR(fd,FF1())))));
/* 0010 1101  0110 0110   : lev  6: */ tmp1=FFXOR(FFAND(fa,fb),FFXOR(fb,FFXOR(FFAND(FFOR(fa,fc),fd),fc)));
/* 0110 0111  1101 0000   : lev  7: */ tmp2=FFXOR(fa,FFOR(FFAND(fb,fc),FFXOR(FFOR(FFAND(fa,FFXOR(fb,fd)),fc),fd)));
/* 1111 1111  1111 1111   : lev  0: */ tmp3=FF1();
      s4a=FFXOR(tmp0,FFAND(fe,FFXOR(tmp1,tmp0)));
      s4b=FFXOR(FFXOR(s4a,tmp2),FFAND(fe,tmp3));

      fe=regs->A[aboff+4][2];fa=regs->A[aboff+3][3];fb=regs->A[aboff+5][0];fc=regs->A[aboff+7][1];fd=regs->A[aboff+8][2];
/* 1000 1111  0011 0010   : lev  7: */ //tmp0=( ( ( fa&( fb|fc ) )^fb )|( ( ( fa^fc )|fd )^ALL_ONES ) );
/* 0110 1011  0000 1011   : lev  6: */ //tmp1=( fb^( ( fc^fd )&( fc^( fb|( fa^fd ) ) ) ) );
/* 0001 1010  0111 1001   : lev  6: */ //tmp2=( ( fa&fc )^( fb^( ( fb|( fa^fc ) )&fd ) ) );
/* 0101 1101  1101 0101   : lev  4: */ //tmp3=( ( ( fa^fb )&( fc^ALL_ONES ) )|fd );
/* 1000 1111  0011 0010   : lev  7: */ tmp0=FFOR(FFXOR(FFAND(fa,FFOR(fb,fc)),fb),FFXOR(FFOR(FFXOR(fa,fc),fd),FF1()));
/* 0110 1011  0000 1011   : lev  6: */ tmp1=FFXOR(fb,FFAND(FFXOR(fc,fd),FFXOR(fc,FFOR(fb,FFXOR(fa,fd)))));
/* 0001 1010  0111 1001   : lev  6: */ tmp2=FFXOR(FFAND(fa,fc),FFXOR(fb,FFAND(FFOR(fb,FFXOR(fa,fc)),fd)));
/* 0101 1101  1101 0101   : lev  4: */ tmp3=FFOR(FFAND(FFXOR(fa,fb),FFXOR(fc,FF1())),fd);
      s5a=FFXOR(tmp0,FFAND(fe,tmp1));
      s5b=FFXOR(tmp2,FFAND(fe,tmp3));

      fe=regs->A[aboff+2][1];fa=regs->A[aboff+3][1];fb=regs->A[aboff+4][0];fc=regs->A[aboff+6][2];fd=regs->A[aboff+8][3];
/* 0011 0110  0010 1101   : lev  6: */ //tmp0=( ( ( fa&fc )&fd )^( ( fb&( fa|fd ) )^fc ) );
/* 1110 1110  1011 1011   : lev  3: */ //tmp1=( ( ( fa^fc )&fd )^ALL_ONES );
/* 0101 1000  0110 0111   : lev  6: */ //tmp2=( ( fa&( fb|fc ) )^( fb^( ( fb&fc )|fd ) ) );
/* 0001 0011  0000 0001   : lev  5: */ //tmp3=( fc&( ( fa&( fb^fd ) )^( fb|fd ) ) );
/* 0011 0110  0010 1101   : lev  6: */ tmp0=FFXOR(FFAND(FFAND(fa,fc),fd),FFXOR(FFAND(fb,FFOR(fa,fd)),fc));
/* 1110 1110  1011 1011   : lev  3: */ tmp1=FFXOR(FFAND(FFXOR(fa,fc),fd),FF1());
/* 0101 1000  0110 0111   : lev  6: */ tmp2=FFXOR(FFAND(fa,FFOR(fb,fc)),FFXOR(fb,FFOR(FFAND(fb,fc),fd)));
/* 0001 0011  0000 0001   : lev  5: */ tmp3=FFAND(fc,FFXOR(FFAND(fa,FFXOR(fb,fd)),FFOR(fb,fd)));
      s6a=FFXOR(tmp0,FFAND(fe,tmp1));
      s6b=FFXOR(tmp2,FFAND(fe,tmp3));

      fe=regs->A[aboff+1][2];fa=regs->A[aboff+2][0];fb=regs->A[aboff+6][1];fc=regs->A[aboff+7][2];fd=regs->A[aboff+7][3];
/* 0111 1000  1001 0110   : lev  5: */ //tmp0=( fb^( ( fc&fd )|( fa^( fc^fd ) ) ) );
/* 0100 1001  0101 1011   : lev  6: */ //tmp1=( ( fb|fd )&( ( fa&fc )|( fb^( fc^fd ) ) ) );
/* 0100 1001  1011 1001   : lev  5: */ //tmp2=( ( fa|fb )^( ( fc&( fb|fd ) )^fd ) );
/* 1111 1111  1101 1101   : lev  3: */ //tmp3=( fd|( ( fa&fc )^ALL_ONES ) );
/* 0111 1000  1001 0110   : lev  5: */ tmp0=FFXOR(fb,FFOR(FFAND(fc,fd),FFXOR(fa,FFXOR(fc,fd))));
/* 0100 1001  0101 1011   : lev  6: */ tmp1=FFAND(FFOR(fb,fd),FFOR(FFAND(fa,fc),FFXOR(fb,FFXOR(fc,fd))));
/* 0100 1001  1011 1001   : lev  5: */ tmp2=FFXOR(FFOR(fa,fb),FFXOR(FFAND(fc,FFOR(fb,fd)),fd));
/* 1111 1111  1101 1101   : lev  3: */ tmp3=FFOR(fd,FFXOR(FFAND(fa,fc),FF1()));
      s7a=FFXOR(tmp0,FFAND(fe,tmp1));
      s7b=FFXOR(tmp2,FFAND(fe,tmp3));


/*
      we have just done this:
      
      int sbox1[0x20] = {2,0,1,1,2,3,3,0, 3,2,2,0,1,1,0,3, 0,3,3,0,2,2,1,1, 2,2,0,3,1,1,3,0};
      int sbox2[0x20] = {3,1,0,2,2,3,3,0, 1,3,2,1,0,0,1,2, 3,1,0,3,3,2,0,2, 0,0,1,2,2,1,3,1};
      int sbox3[0x20] = {2,0,1,2,2,3,3,1, 1,1,0,3,3,0,2,0, 1,3,0,1,3,0,2,2, 2,0,1,2,0,3,3,1};
      int sbox4[0x20] = {3,1,2,3,0,2,1,2, 1,2,0,1,3,0,0,3, 1,0,3,1,2,3,0,3, 0,3,2,0,1,2,2,1};
      int sbox5[0x20] = {2,0,0,1,3,2,3,2, 0,1,3,3,1,0,2,1, 2,3,2,0,0,3,1,1, 1,0,3,2,3,1,0,2};
      int sbox6[0x20] = {0,1,2,3,1,2,2,0, 0,1,3,0,2,3,1,3, 2,3,0,2,3,0,1,1, 2,1,1,2,0,3,3,0};
      int sbox7[0x20] = {0,3,2,2,3,0,0,1, 3,0,1,3,1,2,2,1, 1,0,3,3,0,1,1,2, 2,3,1,0,2,3,0,2};

      s12 = sbox1[ (((A3>>0)&1)<<4) | (((A0>>2)&1)<<3) | (((A5>>1)&1)<<2) | (((A6>>3)&1)<<1) | (((A8>>0)&1)<<0) ]
           |sbox2[ (((A1>>1)&1)<<4) | (((A2>>2)&1)<<3) | (((A5>>3)&1)<<2) | (((A6>>0)&1)<<1) | (((A8>>1)&1)<<0) ];
      s34 = sbox3[ (((A0>>3)&1)<<4) | (((A1>>0)&1)<<3) | (((A4>>1)&1)<<2) | (((A4>>3)&1)<<1) | (((A5>>2)&1)<<0) ]
           |sbox4[ (((A2>>3)&1)<<4) | (((A0>>1)&1)<<3) | (((A1>>3)&1)<<2) | (((A3>>2)&1)<<1) | (((A7>>0)&1)<<0) ];
      s56 = sbox5[ (((A4>>2)&1)<<4) | (((A3>>3)&1)<<3) | (((A5>>0)&1)<<2) | (((A7>>1)&1)<<1) | (((A8>>2)&1)<<0) ]
           |sbox6[ (((A2>>1)&1)<<4) | (((A3>>1)&1)<<3) | (((A4>>0)&1)<<2) | (((A6>>2)&1)<<1) | (((A8>>3)&1)<<0) ];
      s7 =  sbox7[ (((A1>>2)&1)<<4) | (((A2>>0)&1)<<3) | (((A6>>1)&1)<<2) | (((A7>>2)&1)<<1) | (((A7>>3)&1)<<0) ];
*/

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

      extra_B[3]=FFXOR(FFXOR(FFXOR(regs->B[aboff+2][0],regs->B[aboff+5][1]),regs->B[aboff+6][2]),regs->B[aboff+8][3]);
      extra_B[2]=FFXOR(FFXOR(FFXOR(regs->B[aboff+5][0],regs->B[aboff+7][1]),regs->B[aboff+2][3]),regs->B[aboff+3][2]);
      extra_B[1]=FFXOR(FFXOR(FFXOR(regs->B[aboff+4][3],regs->B[aboff+7][2]),regs->B[aboff+3][0]),regs->B[aboff+4][1]);
      extra_B[0]=FFXOR(FFXOR(FFXOR(regs->B[aboff+8][2],regs->B[aboff+5][3]),regs->B[aboff+2][1]),regs->B[aboff+7][0]);
for(dbg=0;dbg<4;dbg++){
  DBG(fprintf(stderr,"extra_B[%i]=",dbg));
  DBG(dump_mem("",(unsigned char *)&extra_B[dbg],BYPG,BYPG));
}

      // T1 = xor all inputs
      // in1, in2, D are only used in T1 during initialisation, not generation
      for(b=0;b<4;b++){
        regs->A[aboff-1][b]=FFXOR(regs->A[aboff+9][b],regs->X[b]);
      }

#ifdef STREAM_INIT
      for(b=0;b<4;b++){
        regs->A[aboff-1][b]=FFXOR(FFXOR(regs->A[aboff-1][b],regs->D[b]),((j % 2) ? in2[b] : in1[b]));
      }
#endif

for(dbg=0;dbg<4;dbg++){
  DBG(fprintf(stderr,"next_A0[%i]=",dbg));
  DBG(dump_mem("",(unsigned char *)&regs->A[aboff-1][dbg],BYPG,BYPG));
}

      // 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++){
        regs->B[aboff-1][b]=FFXOR(FFXOR(regs->B[aboff+6][b],regs->B[aboff+9][b]),regs->Y[b]);
      }

#ifdef STREAM_INIT
      for(b=0;b<4;b++){
        regs->B[aboff-1][b]=FFXOR(regs->B[aboff-1][b],((j % 2) ? in1[b] : in2[b]));
      }
#endif

for(dbg=0;dbg<4;dbg++){
  DBG(fprintf(stderr,"next_B0[%i]=",dbg));
  DBG(dump_mem("",(unsigned char *)&regs->B[aboff-1][dbg],BYPG,BYPG));
}

      // if p=1, rotate left (yes, this is what we're doing)
      tmp3=regs->B[aboff-1][3];
      regs->B[aboff-1][3]=FFXOR(regs->B[aboff-1][3],FFAND(FFXOR(regs->B[aboff-1][3],regs->B[aboff-1][2]),regs->p));
      regs->B[aboff-1][2]=FFXOR(regs->B[aboff-1][2],FFAND(FFXOR(regs->B[aboff-1][2],regs->B[aboff-1][1]),regs->p));
      regs->B[aboff-1][1]=FFXOR(regs->B[aboff-1][1],FFAND(FFXOR(regs->B[aboff-1][1],regs->B[aboff-1][0]),regs->p));
      regs->B[aboff-1][0]=FFXOR(regs->B[aboff-1][0],FFAND(FFXOR(regs->B[aboff-1][0],tmp3),regs->p));

for(dbg=0;dbg<4;dbg++){
  DBG(fprintf(stderr,"next_B0[%i]=",dbg));
  DBG(dump_mem("",(unsigned char *)&regs->B[aboff-1][dbg],BYPG,BYPG));
}

      // T3 = xor all inputs
      for(b=0;b<4;b++){
        regs->D[b]=FFXOR(FFXOR(regs->E[b],regs->Z[b]),extra_B[b]);
      }

for(dbg=0;dbg<4;dbg++){
  DBG(fprintf(stderr,"D[%i]=",dbg));
  DBG(dump_mem("",(unsigned char *)&regs->D[dbg],BYPG,BYPG));
}

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

      tmp0=FFXOR(regs->Z[0],regs->E[0]);
      tmp1=FFAND(regs->Z[0],regs->E[0]);
      regs->F[0]=FFXOR(regs->E[0],FFAND(regs->q,FFXOR(regs->Z[0],regs->r)));
      tmp3=FFAND(tmp0,regs->r);
      tmp4=FFOR(tmp1,tmp3);

      tmp0=FFXOR(regs->Z[1],regs->E[1]);
      tmp1=FFAND(regs->Z[1],regs->E[1]);
      regs->F[1]=FFXOR(regs->E[1],FFAND(regs->q,FFXOR(regs->Z[1],tmp4)));
      tmp3=FFAND(tmp0,tmp4);
      tmp4=FFOR(tmp1,tmp3);

      tmp0=FFXOR(regs->Z[2],regs->E[2]);
      tmp1=FFAND(regs->Z[2],regs->E[2]);
      regs->F[2]=FFXOR(regs->E[2],FFAND(regs->q,FFXOR(regs->Z[2],tmp4)));
      tmp3=FFAND(tmp0,tmp4);
      tmp4=FFOR(tmp1,tmp3);

      tmp0=FFXOR(regs->Z[3],regs->E[3]);
      tmp1=FFAND(regs->Z[3],regs->E[3]);
      regs->F[3]=FFXOR(regs->E[3],FFAND(regs->q,FFXOR(regs->Z[3],tmp4)));
      tmp3=FFAND(tmp0,tmp4);
      regs->r=FFXOR(regs->r,FFAND(regs->q,FFXOR(FFOR(tmp1,tmp3),regs->r))); // ultimate carry

/*
      we have just done this: (believe it or not)
      
      if (q) {
        F = Z + E + r;
        r = (F >> 4) & 1;
        F = F & 0x0f;
      }
      else {
          F = E;
      }
*/
      for(b=0;b<4;b++){
        regs->E[b]=next_E[b];
      }
for(dbg=0;dbg<4;dbg++){
  DBG(fprintf(stderr,"F[%i]=",dbg));
  DBG(dump_mem("",(unsigned char *)&regs->F[dbg],BYPG,BYPG));
}
DBG(fprintf(stderr,"r="));
DBG(dump_mem("",(unsigned char *)&regs->r,BYPG,BYPG));
for(dbg=0;dbg<4;dbg++){
  DBG(fprintf(stderr,"E[%i]=",dbg));
  DBG(dump_mem("",(unsigned char *)&regs->E[dbg],BYPG,BYPG));
}

      // this simple instruction is virtually shifting all the shift registers
      aboff--;

/*
      we've just done this:

      A9=A8;A8=A7;A7=A6;A6=A5;A5=A4;A4=A3;A3=A2;A2=A1;A1=A0;A0=next_A0;
      B9=B8;B8=B7;B7=B6;B6=B5;B5=B4;B4=B3;B3=B2;B2=B1;B1=B0;B0=next_B0;
*/

      regs->X[0]=s1a;
      regs->X[1]=s2a;
      regs->X[2]=s3b;
      regs->X[3]=s4b;
      regs->Y[0]=s3a;
      regs->Y[1]=s4a;
      regs->Y[2]=s5b;
      regs->Y[3]=s6b;
      regs->Z[0]=s5a;
      regs->Z[1]=s6a;
      regs->Z[2]=s1b;
      regs->Z[3]=s2b;
      regs->p=s7a;
      regs->q=s7b;
for(dbg=0;dbg<4;dbg++){
  DBG(fprintf(stderr,"X[%i]=",dbg));
  DBG(dump_mem("",(unsigned char *)&regs->X[dbg],BYPG,BYPG));
}
for(dbg=0;dbg<4;dbg++){
  DBG(fprintf(stderr,"Y[%i]=",dbg));
  DBG(dump_mem("",(unsigned char *)&regs->Y[dbg],BYPG,BYPG));
}
for(dbg=0;dbg<4;dbg++){
  DBG(fprintf(stderr,"Z[%i]=",dbg));
  DBG(dump_mem("",(unsigned char *)&regs->Z[dbg],BYPG,BYPG));
}
DBG(fprintf(stderr,"p="));
DBG(dump_mem("",(unsigned char *)&regs->p,BYPG,BYPG));
DBG(fprintf(stderr,"q="));
DBG(dump_mem("",(unsigned char *)&regs->q,BYPG,BYPG));

#ifdef STREAM_NORMAL
      // require 4 loops per output byte
      // 2 output bits are a function of the 4 bits of D
      // xor 2 by 2
      cb_g[8*i+7-2*j]=FFXOR(regs->D[2],regs->D[3]);
      cb_g[8*i+6-2*j]=FFXOR(regs->D[0],regs->D[1]);
for(dbg=0;dbg<8;dbg++){
  DBG(fprintf(stderr,"op[%i]=",dbg));
  DBG(dump_mem("",(unsigned char *)&cb_g[8*i+dbg],BYPG,BYPG));
}
#endif

DBG(fprintf(stderr,"---END INTERNAL LOOP\n"));

    } // INTERNAL LOOP

DBG(fprintf(stderr,"--END EXTERNAL LOOP\n"));

  } // EXTERNAL LOOP

  // move 32 steps forward, ready for next call
  for(k=0;k<10;k++){
    for(b=0;b<4;b++){
DBG(fprintf(stderr,"moving forward AB k=%i b=%i\n",k,b));
      regs->A[32+k][b]=regs->A[k][b];
      regs->B[32+k][b]=regs->B[k][b];
    }
  }


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

#ifdef STREAM_NORMAL
for(j=0;j<64;j++){
  DBG(fprintf(stderr,"postcall prerot cb[%2i]=",j));
  DBG(dump_mem("",(unsigned char *)(cb+BYPG*j),BYPG,BYPG));
}

#if GROUP_PARALLELISM==32
trasp64_32_88cw(cb);
#endif
#if GROUP_PARALLELISM==64
trasp64_64_88cw(cb);
#endif
#if GROUP_PARALLELISM==128
trasp64_128_88cw(cb);
#endif

for(j=0;j<64;j++){
  DBG(fprintf(stderr,"postcall postrot cb[%2i]=",j));
  DBG(dump_mem("",(unsigned char *)(cb+BYPG*j),BYPG,BYPG));
}
#endif

#ifdef STREAM_INIT
  DBG(fprintf(stderr,":::::::::: END STREAM INIT\n"));
#endif
#ifdef STREAM_NORMAL
  DBG(fprintf(stderr,":::::::::: END STREAM NORMAL\n"));
#endif

}