uprava a kompilacia skryptu

bool cSystem::ProcessECM(const cEcmInfo *ecmInfo, unsigned char *data)
{
  int len=SCT_LEN(data);
  if(data[ECM_NANO_LEN]!=len-ECM_NANO_START) {
    dc(printf("system-crypt: invalid ECM structure\n"))
    return false;
    }

  int prov=-1, keyid=0;
  for(int i=ECM_NANO_START; i<len; i+=data[i+1]+2) {
    if(data[i]==0x83) {
      prov =data[i+2]&0xFC;
      keyid=data[i+2]&0x03;
      break;
      }
    }
  if(prov<0) {
    dc(printf("system-crypt: provider ID not located in ECM\n"));
    return false;
    }

  unsigned char key[22];
  cPlainKey *pk;
  if(!(pk=keys.FindKey('W',ecmInfo->caId,KEYSET(prov,CCTYP,CCID),6))) {
    if(doLog) d(printf("system-crypt: missing %04X %02X CC key\n",ecmInfo->caId,prov))
    return false;
    }
  pk->Get(key+16);

  // RSA stage
  DUMPNANO("pre-RSA",&data[ECM_NANO_START],len-ECM_NANO_START);
  for(int i=ECM_NANO_START; i<len; i+=data[i+1]+2) {
    int l=data[i+1]+2;
    switch(data[i]) {
      case 0x85:
        {
        if(!(pk=keys.FindKey('W',ecmInfo->caId,KEYSET(prov,0x31,keyid),16))) {
          if(doLog) d(printf("system-crypt: missing %04X %02X 31 %02X key\n",ecmInfo->caId,prov,keyid))
          return false;
          }
        pk->Get(key);
        cBN mod;
        if(!(pk=keys.FindKey('W',ecmInfo->caId,KEYSET(prov,0x10,0x00),64))) {
          if(doLog) d(printf("system-crypt: missing %04X %02X 10 00 key\n",ecmInfo->caId,prov))
          return false;
          }
        pk->Get(mod);

        l-=10;
        if(!DecryptRSA(&data[i+2],l,data[ECM_ALGO_TYP],key,mod))
          return false;
        memmove(&data[i],&data[i+2],l);
        memmove(&data[i+l],&data[i+l+10],len-i-l);
        len-=10;
        break;
        }
      case 0x86:
        memmove(&data[i],&data[i+l],len-i-l);
        len-=l;
        continue;
      }
    }
  DUMPNANO("post-RSA",&data[ECM_NANO_START],len-ECM_NANO_START);

  cKeySnoop ks(this,'W',ecmInfo->caId,KEYSET(prov,0x20,keyid));
  if(!(pk=keys.FindKey('W',ecmInfo->caId,KEYSET(prov,0x20,keyid),16))) {
    if(doLog) d(printf("system-crypt: missing %04X %02X 20 %02X key\n",ecmInfo->caId,prov,keyid))
    return false;
    }
  pk->Get(key);

  // DES stage
  unsigned char sig[8];
  DUMP("sig org:",&data[len-8],8);
  data[ECM_NANO_LEN]=len-ECM_NANO_START;
  Signature(&data[ECM_DATA_START],len-ECM_DATA_START-10,key,sig);
  for(int i=ECM_NANO_START; i<len; i+=data[i+1]+2) {
    switch(data[i]) {
      case 0xDA:
      case 0xDB:
      case 0xDC:
        for(int j=0; j<data[i+1]; j+=8)
          DecryptDES(&data[i+2+j],data[ECM_ALGO_TYP],key);
        break;
      case 0xDF:
        if(memcmp(&data[i+2],sig,8)) {
          dc(printf("system-crypt: signature failed in ECM\n"))
          return false;
          }
        break;
      }
    }
 
  // CW stage
  for(int i=ECM_NANO_START; i<len; i+=data[i+1]+2) {
    switch(data[i]) {
      case 0xDB:
        if(data[i+1]==0x10) {
          memcpy(cw,&data[i+2],16);
          DUMP("cw:",cw,16);
          ks.OK(pk);
          return true;
          }
        break;
      }
    }

  return false;
}

/*
void cSystem:ProcessEMM(int pid, int caid, unsigned char *data)
{
}
*/

// -- cSystemLinkCrypt ---------------------------------------------------

class cSystemLinkCrypt : public cSystemLink {
public:
  cSystemLinkCrypt(void);
  virtual bool CanHandle(unsigned short SysId);
  virtual cSystem *Create(void) { return new cSystem; }
  };

static cSystemLinkCrypt staticInit;

cSystemLinkCrypt::cSystemLinkCrypt(void)
:cSystemLink(SYSTEM_NAME,SYSTEM_PRI)
{
  Feature.NeedsKeyFile();
}

bool cSystemLinkCrypt::CanHandle(unsigned short SysId)
{
  SysId&=SYSTEM_MASK;
  return SYSTEM_CAN_HANDLE(SysId);
}

#include "genincs.h"

#if defined(SUPPORT_SOFT_CI_SOLUTION) && defined(CRYPTOWORKS_MCAS_ON)
//#if 1

#include "emsc.h"
#include "dbmgr.h"

#include "nn.h"
#include <string.h>

//---------------------------------------------------------------------------
// common Cryptoworks DES modes
#define CRW_DES_LEFT      0
#define CRW_DES_RIGHT      1
#define DESMOD1            2
#define DES               4
#define DESMOD3            8

// common Cryptoworks DES modes
#define DES2_DECRYPT      (DES|DESMOD3|CRW_DES_LEFT)
#define DES2_ENCRYPT      (DES|DESMOD1|CRW_DES_RIGHT)
#define CRW_DES_DECRTPT   DES


#define S1024  (1024/NN_DIGIT_BITS)
#define S768   (768/NN_DIGIT_BITS)
#define S512   (512/NN_DIGIT_BITS)
#define S256   (256/NN_DIGIT_BITS)

void DecryptRSA(byte *in_msg, byte *n, byte *exp, byte len_n, byte len_exp)
{
  NN_DIGIT E[S512], N[S512];
  NN_DIGIT M[S512];

  int  nDigits, eDigits;

  NN_DecodeLE(M, S512, in_msg, 64);
  NN_DecodeLE(N, S512, n, len_n);
  NN_DecodeLE(E, S512, exp, len_exp); 
 
  nDigits = NN_Digits (M, S512);
  eDigits = NN_Digits (M, S512); 
 
  NN_ModExp(M,M,E,eDigits,N,nDigits);
  NN_EncodeLE(in_msg,64,M,S512);
}


void swapbytes (byte *data, int len) {
   byte tempBUF[256];
   int i;

   for(i=0; i<len; i++) tempBUF[i]=data[(len-1)-i];
   memcpy (data, tempBUF, len);
}

typedef struct
{
   unsigned char CAID[2];
   unsigned char provID[4];
   unsigned char last6[6];
} CRWlast6;

#define provDecryptable 13
unsigned char CRWprovi_last6[provDecryptable*12]={
   0x0D, 0x03, 0x04, 0x08, 0xD0, 0x00,     // Czech Link
   0x27, 0xB4, 0x88, 0x34, 0x8D, 0x54,
   0x0D, 0x05, 0x04, 0x0C, 0x00, 0x00,     // Easy.tv
   0x09, 0x87, 0xCF, 0x2A, 0x61, 0x1D,
   0x0D, 0x04, 0x04, 0x08, 0x0C, 0x10,         // DMC15°W
   0x28, 0xD6, 0xF3, 0xBF, 0x1B, 0x76,
   0x0D, 0x01, 0x50, 0x54, 0x00, 0x00,
   0xE0, 0xE6, 0xB0, 0xBA, 0x31, 0x25,
   0x0D, 0x03, 0xC0, 0xC4, 0x00, 0x00,         // Digiturk
   0x64, 0x2F, 0x15, 0xA3, 0xBC, 0x63,
   0x0D, 0x00, 0x20, 0x30, 0x00, 0x00,         // Kingstone
   0x23, 0x90, 0x91, 0x78, 0x1C, 0x7E,
   0x0D, 0x02, 0x88, 0x8C, 0x00, 0x00,
   0x8A, 0xD8, 0xBE, 0x27, 0x92, 0x21,
   0x0D, 0x03, 0xA0, 0x00, 0x00, 0x00,         // British Telecom
   0xC8, 0x79, 0x1A, 0x66, 0xBE, 0x69,
   0x0D, 0x03, 0x5C, 0x60, 0x00, 0x00,         // Turner
   0xDE, 0x20, 0x34, 0x14, 0x54, 0x55,
   0x0D, 0x03, 0xB0, 0x00, 0x00, 0x00,         // Xtramusic
   0x5E, 0x13, 0x97, 0xA6, 0x59, 0x7E,
   0x0D, 0x01, 0xE4, 0xE8, 0xEC, 0xF0,         // JSTV
   0xC2, 0x3F, 0xFA, 0x92, 0x19, 0xAB,
   0x0D, 0x03, 0x20, 0x00, 0x00, 0x00,         // Slovak Link
   0x91, 0x47, 0x55, 0x0F, 0x41, 0x9C,
};

typedef struct
{
   char ident;
   unsigned char key00[0x10];
   unsigned char key01[0x10];
} CRWkeys;

#define CRWnumofprov                19
CRWkeys CRWprovi_key[CRWnumofprov]=
{
   //Easy.tv
   {
      0x0C,
      { 0x65, 0xD4, 0xE6, 0xD5, 0x37, 0xE3, 0xAD, 0x18, 0x4D, 0xF4, 0xD5, 0x79, 0x6A, 0x8F, 0x8A, 0xED, },//00
      { 0x07, 0x16, 0x5D, 0xF9, 0xAC, 0x22, 0x6C, 0x9A, 0x38, 0x46, 0x0C, 0x26, 0xA2, 0xD8, 0x4F, 0xBF, },//01
  },   
   {
      0x04,
      { 0x07, 0x16, 0x5D, 0xF9, 0xAC, 0x22, 0x6C, 0x9A, 0x38, 0x46, 0x0C, 0x26, 0xA2, 0xD8, 0x4F, 0xBF, },//00
      { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },//01
   },
   //Xtramusic
   {   
      0xB0,
      { 0x38, 0xB6, 0x9B, 0x35, 0xFE, 0x1D, 0xF0, 0xF3, 0x6A, 0xF3, 0x32, 0xD0, 0x8B, 0xFF, 0x1B, 0x92, },//00
      { 0x43, 0x08, 0xCC, 0x4A, 0x2B, 0x65, 0x55, 0x8D, 0x99, 0xEE, 0x2A, 0xAD, 0xE4, 0x42, 0x66, 0x38, },//01
   },
   
   //JSTV
   {
      0xE4,
      { 0x00, 0xE3, 0xC1, 0xC3, 0x9A, 0xA9, 0xF2, 0xB4, 0x04, 0x96, 0x63, 0xDB, 0x58, 0x78, 0x6A, 0xA9,   },//00
      { 0x6F, 0xA5, 0x03, 0x31, 0x9D, 0x84, 0x97, 0xD6, 0x91, 0xE1, 0x22, 0x4A, 0xA4, 0x46, 0xA9, 0xAC,   },//01
   },
   {
      0xE8,
      { 0x75, 0xB6, 0x3D, 0xF1, 0x6E, 0xC5, 0x21, 0xF7, 0x8B, 0x9A, 0x5D, 0x29, 0xB3, 0x3D, 0xDC, 0xBD,   },//00
      { 0x21, 0x88, 0x9B, 0x3E, 0xA2, 0x51, 0x67, 0x38, 0x9E, 0x3B, 0xD6, 0x7E, 0xEE, 0x26, 0x24, 0xC1, },//01
   },
   {
      0xEC,
      { 0x2F, 0xF7, 0x15, 0x97, 0x0E, 0x0F, 0x65, 0x9C, 0x43, 0x88, 0xE8, 0xAD, 0x4F, 0x33, 0xCD, 0xAE,   },//00
      { 0xE5, 0x84, 0x69, 0xED, 0xD5, 0x5B, 0x58, 0xBC, 0xD0, 0x9F, 0xF5, 0x0C, 0x69, 0x45, 0x76, 0x6C,   },//01
   },
   {
      0xF0,
      { 0xF8, 0xD4, 0x7C, 0xD0, 0x75, 0x27, 0x00, 0x63, 0x96, 0x2A, 0x0C, 0x95, 0xBD, 0x64, 0xFE, 0xDE,   },//00
      { 0x16, 0x14, 0xDE, 0xAB, 0xF1, 0x84, 0xAC, 0x1A, 0xFB, 0x4C, 0xFE, 0x02, 0x63, 0xD4, 0xDC, 0x62, },//01
   },

   //Digiturk
   {
      0xC0,
      { 0xB1, 0x22, 0xE3, 0x7A, 0xA7, 0xD2, 0xDA, 0xA8, 0x59, 0x3C, 0x1F, 0xCD, 0x4C, 0xED, 0xBE, 0x2B   },//00
      { 0x28, 0x1C, 0xEE, 0xC1, 0x9A, 0xB8, 0x06, 0xE0, 0x17, 0x4E, 0x8B, 0x4F, 0x46, 0xCE, 0x09, 0x9A   },//01
   },
   {
      0xC4,
      { 0x72, 0x67, 0x85, 0xF0, 0x6D, 0x6A, 0x3F, 0xAA, 0x45, 0xD4, 0xF9, 0xF7, 0x28, 0x6B, 0x4A, 0x29   },//00
      { 0x02, 0x6C, 0x00, 0xC3, 0xD2, 0xAC, 0xEE, 0x47, 0x00, 0x18, 0xA6, 0x26, 0x73, 0xC2, 0x18, 0x70   },//01
   },

   //DMC15West
   {
      0x04,
      { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0x97, 0x34, 0xDD, 0x42, 0xCF, 0xC8, 0x24,   },//00
      { 0x24, 0x5D, 0x6D, 0xFA, 0x62, 0xA1, 0x9F, 0x93, 0x08, 0xE6, 0x6E, 0xA8, 0x36, 0xE9, 0x40, 0x27,   },//01
   },

   //Kingstone
   {
      0x20,
      { 0xA4, 0x04, 0x03, 0x14, 0x3E, 0xCB, 0x62, 0x20, 0xDA, 0x18, 0x0E, 0x54, 0x85, 0x14, 0x51, 0xEF,   },//00
      { 0x5C, 0xE8, 0x14, 0xB0, 0x0F, 0xF5, 0xD5, 0xD9, 0xE0, 0x41, 0x19, 0x39, 0x23, 0x53, 0xD6, 0x6B,   },//01
   },
   {
      0x30,
      { 0xBD, 0xD3, 0xA8, 0xE9, 0x37, 0x64, 0xFF, 0xDB, 0x1D, 0x38, 0x66, 0xCF, 0x97, 0x4A, 0x40, 0x77,   },//00
      { 0x4D, 0x05, 0x18, 0x0E, 0xAE, 0x0B, 0x9D, 0x10, 0x23, 0x52, 0x1A, 0x61, 0x37, 0x79, 0x69, 0x55,   },//01
   },

   // Turner
   {
      0x5C,
      { 0x83, 0x97, 0x04, 0x92, 0x7C, 0xDA, 0xC2, 0x63, 0x69, 0xF5, 0x85, 0x57, 0xEF, 0xCD, 0x51, 0xAB, },//00
      { 0x6B, 0xA5, 0x93, 0x38, 0x1E, 0xA4, 0xB6, 0x8E, 0x48, 0xAF, 0x0B, 0x8F, 0xEE, 0xE5, 0xB7, 0xD6, },//01       
   },
   {
      0x60,
      { 0x19, 0x20, 0x37, 0x4F, 0x95, 0x17, 0xC2, 0x71, 0xD0, 0x9B, 0xB6, 0xD6, 0x89, 0xBC, 0xE3, 0xD3, },//00
      { 0xA4, 0x80, 0x40, 0x1A, 0x1D, 0x2F, 0x3E, 0x49, 0x4B, 0x44, 0x47, 0x7E, 0xD7, 0x3B, 0xFE, 0x41, },//01
   },

   // British Telecom
   {
      0xA0,
      { 0x21, 0x79, 0x38, 0x7D, 0x62, 0x46, 0x09, 0x9F, 0xB2, 0xE9, 0x73, 0x3B, 0xDB, 0x4E, 0x1B, 0x78, },//00
      { 0x21, 0x79, 0x38, 0x7D, 0x62, 0x46, 0x09, 0x9F, 0xB2, 0xE9, 0x73, 0x3B, 0xDB, 0x4E, 0x1B, 0x78, },//01
   },
   
   // Slovak Link
   {
      0x20,
      { 0xEA, 0xD0, 0x3E, 0xEB, 0x20, 0x25, 0xF1, 0x6F, 0xC4, 0x86, 0x30, 0x0E, 0x1E, 0x84, 0xA8, 0x28, },//00
      { 0xEA, 0xD0, 0x3E, 0xEB, 0x20, 0x25, 0xF1, 0x6F, 0xC4, 0x86, 0x30, 0x0E, 0x1E, 0x84, 0xA8, 0x28, },//01
   },

   // Czech Link
   {
      0x04,
      { 0x72, 0x55, 0x91, 0xA1, 0x9F, 0x0C, 0x8F, 0x38, 0x97, 0x37, 0x78, 0xFF, 0x7E, 0x57, 0x7C, 0x04, },//00
      { 0x15, 0x44, 0x2A, 0xF4, 0xF4, 0x5D, 0xA4, 0x5A, 0x02, 0xCF, 0xFE, 0x37, 0xCE, 0xC2, 0xB6, 0x07, },//01       
   },
   {
      0x08,
      { 0xD0, 0x49, 0xD9, 0xA9, 0xE2, 0xC2, 0xAA, 0x9F, 0x32, 0x2E, 0xF6, 0xFE, 0x45, 0x68, 0xD9, 0x0A, },//00
      { 0x0C, 0x16, 0x6A, 0xA1, 0xF1, 0x5E, 0x80, 0x23, 0x56, 0xE5, 0x86, 0x9E, 0x23, 0xF4, 0x1D, 0x4C, },//01
   },
   
   //UPC
   {
      0x0A,
      { 0x37, 0x13, 0x50, 0xA4, 0xB4, 0x0A, 0x5D, 0x65, 0x80, 0xF4, 0xCC, 0x4A, 0xAE, 0x95, 0x13, 0x93, },//00
      { 0x65, 0xDB, 0x63, 0xB8, 0x1D, 0xF9, 0x91, 0x65, 0x8B, 0xA4, 0x74, 0x0F, 0xC6, 0x33, 0x27, 0x2B, },//01
   },
};

typedef struct
{
   unsigned char ident[4];
   unsigned char CAID[2];
   unsigned char KEY[2];
   unsigned char rsa[0x40];
} CRWrsa;

#define CRWnumofRSA 5
unsigned char CRWprovi_rsa[((4*16)+8)*CRWnumofRSA]={
   0x00, 0x00, 0x00, 0x04, 0x0D, 0x05, 0x12, 0x00, // 04 0D05 1200
   0x9D, 0x96, 0x5D, 0x72, 0x43, 0x2A, 0xA5, 0x11, 0x86, 0xBD, 0x0C, 0x98, 0xCB, 0xFE, 0xB7, 0x49,
   0xD0, 0x78, 0x8C, 0x6F, 0x37, 0x93, 0x3D, 0xB2, 0xFA, 0xED, 0xEF, 0xCB, 0x47, 0x3E, 0x3D, 0xF3,
   0x09, 0x34, 0xDA, 0x04, 0x44, 0x73, 0x94, 0xF9, 0x55, 0xD1, 0xCA, 0x47, 0x3B, 0x25, 0x01, 0xC7,
   0xAC, 0x0A, 0x7E, 0xC0, 0xF4, 0x3A, 0xFD, 0xB7, 0xEF, 0xC2, 0x0B, 0x17, 0xE1, 0xF4, 0x00, 0x80,
   
   0x00, 0x00, 0x00, 0x0C, 0x0D, 0x05, 0x12, 0x00, // 0C 0D05 1200
   0x9D, 0x96, 0x5D, 0x72, 0x43, 0x2A, 0xA5, 0x11, 0x86, 0xBD, 0x0C, 0x98, 0xCB, 0xFE, 0xB7, 0x49,
   0xD0, 0x78, 0x8C, 0x6F, 0x37, 0x93, 0x3D, 0xB2, 0xFA, 0xED, 0xEF, 0xCB, 0x47, 0x3E, 0x3D, 0xF3,
   0x09, 0x34, 0xDA, 0x04, 0x44, 0x73, 0x94, 0xF9, 0x55, 0xD1, 0xCA, 0x47, 0x3B, 0x25, 0x01, 0xC7,
   0xAC, 0x0A, 0x7E, 0xC0, 0xF4, 0x3A, 0xFD, 0xB7, 0xEF, 0xC2, 0x0B, 0x17, 0xE1, 0xF4, 0x00, 0x80,      
   
   0x00, 0x00, 0x00, 0xB0, 0x0D, 0x03, 0x12, 0x00, // B0 0D03 1200
   0x39, 0xFA, 0x13, 0x22, 0x59, 0xC6, 0x4C, 0x7C, 0xF5, 0x5D, 0x3D, 0x6F, 0xE8, 0x32, 0x0B, 0x64,
   0x4F, 0xE8, 0x2B, 0x96, 0x68, 0x1D, 0x54, 0x61, 0x21, 0xA0, 0xD2, 0xB6, 0xD0, 0x51, 0xE5, 0x68,
   0x05, 0xE0, 0x6E, 0xB0, 0x67, 0x80, 0x2A, 0xCE, 0xD1, 0x72, 0xF3, 0xF8, 0x7E, 0x0D, 0xE9, 0x1B,
   0x9B, 0x96, 0xE8, 0x46, 0x38, 0x30, 0x15, 0xC9, 0xD4, 0xD5, 0x84, 0x42, 0xF5, 0x9D, 0x00, 0x80,

   0x00, 0x00, 0x00, 0xC0, 0x0D, 0x03, 0x12, 0x00,   // C0 0D03 1200
   0x21, 0x4D, 0xA3, 0x1E, 0x63, 0x5D, 0x37, 0xC9, 0xA3, 0x16, 0x40, 0xAE, 0xC8, 0xD2, 0x14, 0x5F,
   0x3E, 0x5A, 0xE1, 0x8F, 0x1E, 0xDF, 0x73, 0x68, 0x35, 0xAB, 0x60, 0x42, 0x33, 0x33, 0xAB, 0x8C,
   0xEC, 0x8B, 0x6D, 0x47, 0x40, 0x08, 0xFB, 0x50, 0x31, 0x20, 0x0E, 0x0F, 0x68, 0x73, 0xFE, 0x58,
   0x87, 0xF1, 0x95, 0xC1, 0xE8, 0x86, 0x6D, 0xB2, 0x81, 0xF8, 0x49, 0xE1, 0x46, 0xBA, 0x00, 0x80,

   0x00, 0x00, 0x00, 0xC4, 0x0D, 0x03, 0x12, 0x00,   // C4 0D03 1200
   0x05, 0x48, 0x03, 0xCE, 0x3D, 0x7F, 0x3A, 0x6D, 0x98, 0xE1, 0xAB, 0x3E, 0x94, 0x7F, 0x67, 0x49,
   0x87, 0x79, 0x9B, 0x17, 0x26, 0x23, 0x8C, 0xCD, 0x6F, 0x16, 0x12, 0x5C, 0xB3, 0x93, 0xA6, 0x56,
   0x8A, 0x11, 0xFC, 0xA4, 0xD3, 0x06, 0x56, 0x94, 0x87, 0x76, 0x1D, 0xEF, 0xD6, 0x44, 0xC8, 0x3B,
   0x4C, 0x36, 0x81, 0x46, 0x0D, 0x7C, 0x3E, 0x74, 0x7A, 0x01, 0xAC, 0x70, 0x04, 0xC7, 0x00, 0x80,               
};

int cryptoworks_find_key(U8 prov_id, int key_index, U8 *key)
{
   EmbSCInfo *McasEmbSC;
   U8   crypto_key[16];
   int   mm, xx, found = 0;
   
   McasEmbSC = DBKeyGetBaseSCDataAddr();

   for(mm=0; mm<MAX_EEP_CHAN; mm++)
   {
      if( (McasEmbSC[mm].usKeyValid == 1) && ((McasEmbSC[mm].usCaId & 0xff00) == 0x0d00))
      {            
         if(McasEmbSC[mm].uChId == prov_id)
         {
            for(xx = 0; xx<MAX_KEY_NUM; xx++)
            {               
               if(McasEmbSC[mm].ucKeyNum[xx] == key_index)
               {
                  memcpy(&crypto_key[0], &(McasEmbSC[mm].ucKey[xx][0]), 8);
                  found |= 0x01;
               }
               if(McasEmbSC[mm].ucKeyNum[xx] == (key_index | 0x10))
               {
                  memcpy(&crypto_key[8], &(McasEmbSC[mm].ucKey[xx][0]), 8);
                  found |= 0x02;
               }
               if (found == 0x03) {
                  memcpy(&key[0], &crypto_key[0], 16);
                  return true;
               }
            }
         }   
      }   
   }   
   
   return false;
}

int cryptoworks_ecm(unsigned char *ecm, unsigned char *dw1, unsigned char *dw2) //, unsigned char *basic_BUFEMU_E)
{
   unsigned char key[0x16];

   int i, j, odd, r29, keySelect, provID;
   unsigned char tempCW[0x10], nano85dec[0xFF];
   CRWlast6 *provi_last6;
   int found_key;
   
   provi_last6 = (CRWlast6 *) CRWprovi_last6;

   odd = ecm[0x5];

   for (i=8; i<ecm[7]; i++) {
      switch (ecm[i])
      {
         case 0x83:   // KEY
         case 0x84:
            provID = ecm[i+2]&0xFC;
            keySelect = ecm[i+2]&3;
            i+=ecm[i+1]+1;
            break;
         case 0x85:
            if (!nano85decrypt(ecm+i, odd, provID, nano85dec)) return false;   //nano85 decrypt fails
            memcpy (ecm+i, nano85dec, ecm[i+1]-8);
            i--;
            break;
         case 0x80:
         case 0x86:
         case 0x8A:
         case 0x8B:
         case 0x8C:
         case 0x8E:
                        case 0x8F: //dodane przez dvbxtreme
         case 0x90:
         case 0x91:
         case 0xD7:
         case 0xDF:
            i+=ecm[i+1]+1;
            break;
         case 0xDB:   // CWS
            memcpy (tempCW, ecm+i+2, 0x10);
            i+=ecm[i+1]+1;
            break;
         default:
            i+=ecm[i+1]+1;
            break;
      }
   }
   
#ifdef   _GOLDMASTER
   if (provID == 0xC0 || provID == 0xC4)
      return false;
#endif   

   found_key = cryptoworks_find_key(provID, keySelect, key);
   
   if (found_key == 0)
   {
      // select suitable provider
      for(i=0; i<CRWnumofprov; i++) {
         if (CRWprovi_key[i].ident == provID)
            break;
      }
   
      if (i==CRWnumofprov)
         return false;   // prov id not found
      if (keySelect == 0)
         memcpy (key, CRWprovi_key[i].key00, 0x10);
      else         
         memcpy(key, CRWprovi_key[i].key01, 0x10);
   }
   
   // select suitable last6 BYTES
   for(i=0; i<provDecryptable; i++)
   {
      if (provi_last6->provID[0] == provID) break;
      if (provi_last6->provID[1] == provID) break;
      if (provi_last6->provID[2] == provID) break;
      if (provi_last6->provID[3] == provID) break;
      provi_last6++;
   }

   memcpy (key+0x10, provi_last6->last6, 6);

   //decrypt CW
   odd=ecm[0x5];//0x28 DT

   for(i=0;i<2;i++)
   {
      r29=0;
      if ((ecm[0x5]&7)==7) for(j=0;j<3;i++) { r29^=1; odd=ecm[0x5]; algoCRW(tempCW+(8*i),key,odd,r29|2); }
      else algoCRW(tempCW+(8*i),key,odd,0);   //normal DecryptCW
   }

   memcpy (dw1, tempCW, 8);
   memcpy (dw2, tempCW+8, 8);
   
   return true;
}

#define ror1(value) (((value>>1)&0x7fffffff)) | ((value&0x10)<<27);
#define rol1(value) (((value<<1)&0xfffffffe)) | ((value&0x08000000)>>27);
#define lwz(rD,d,buf) (rD=buf[d+0]<<24|buf[d+1]<<16|buf[d+2]<<8|buf[d+3])

/*
int key2int(unsigned char *key)
{
   int i;
   i = (key[0] << 24) | (key[1] << 16) | (key[2] << 8) | key[3];
   return i;
}
*/
void int2key(unsigned char *key, int i1, int i0)
{
   key[0] = i1 >> 24;
   key[1] = i1 >> 16;
   key[2] = i1 >> 8;
   key[3] = i1;
   key[4] = i0 >> 24;
   key[5] = i0 >> 16;
   key[6] = i0 >> 8;
   key[7] = i0;
}


void prepareDesKey (unsigned char *desKey)
{
   unsigned char tempbuff[8];
   int i,j,k,r10,r11,temp, r0;

   memset(tempbuff,0,8);
   desKey[7]=6;

   for(i=6;i>=0;i--)
   {
      k=desKey[7];
      for(j=8;j>0;j--)
      {
         r0 = tempbuff[k];
         r0=r0<<1;
         r11 = r0|1;
         if(!(desKey[i]&1)) r11=r0;
         desKey[i]=desKey[i]>>1;
         tempbuff[k]=r11;
         k--;
         if(k<0) k=6;
      }
      desKey[7]=k;
   }

   tempbuff[7]=(tempbuff[3]<<4)&0xF0;
   temp=tempbuff[6];
   tempbuff[6]=tempbuff[4];
   tempbuff[4]=temp;

   memcpy(desKey,tempbuff,8);

   lwz(r10,4,desKey); lwz(r11,0,desKey);
   for(i=0;i<4;i++) { r11 = ror1(r11); r10 = ror1(r10); }
   int2key (desKey, r11, r10);
}

void algoCRW(unsigned char *CW, unsigned char  *key, int odd, int _mode)
{
   int i, j, r31, mode;
   unsigned char keytemp70[0x16];
   unsigned char desKey[8], desKey2[8];

   memcpy(keytemp70,key,0x16);
   memset(keytemp70,0,0x10);
   memcpy(keytemp70,key+0x10,6);

   odd=(~odd)&7;
   mode=_mode&1;

   for(r31=8; r31>odd; r31--) keytemp70[r31-2] = key[r31];
   prepareDesKey (keytemp70);
   memcpy (desKey, keytemp70, 8);
   memcpy (desKey2, key+9, 8);
   prepareDesKey (desKey2);

   cryptoworks_des (desKey, DES2_ENCRYPT, CW);   // DES 2 rounds encrypt
   cryptoworks_des (desKey2, CRW_DES_DECRTPT|mode, CW);   // DES 16 round decrypt
   cryptoworks_des (desKey, DES2_DECRYPT, CW);      // DES 2 rounds decrypt

   memcpy(desKey,CW,4);
   memcpy(CW,CW+4,4);
   memcpy(CW+4,desKey,4);

   if (_mode&2)
   {
      memcpy(desKey,key,8);
      memcpy(key,key+8,8);
      memcpy(key+8,desKey,8);
   }
}

int nano85decrypt(unsigned char *nano85, int odd, int provID, unsigned char *buffOut)
{
   unsigned char expNano85[1]=0x2;
   unsigned char tab_permut[0x10]={0xE, 3, 5, 8, 9, 4, 2, 0xF, 0, 0xD, 0xB, 6, 7, 0xA, 0xC, 1};

   //DIGITURK EMM-G KEYS prov 0D03 C0
   unsigned char C0key00[0x10]={0xB7, 0x52, 0xC3, 0xBE, 0x0B, 0xDE, 0xEB, 0x8A, 0x32, 0xA3, 0xE7, 0x3E, 0x63, 0x58, 0xF0, 0x44};
   unsigned char C0key01[0x10]={0x28, 0xE3, 0xAF, 0x36, 0xBB, 0xC2, 0xBC, 0x92, 0x40, 0x7D, 0xAA, 0xC2, 0x38, 0xD1, 0x2A, 0xDF};
   //DIGITURK EMM-G KEYS prov 0D03 C4
   unsigned char C4key00[0x10]={0x00, 0xB5, 0x34, 0xFF, 0x03, 0x2F, 0x8A, 0x5E, 0xAC, 0x0A, 0xE6, 0x3E, 0x99, 0x70, 0xEB, 0x74};
   unsigned char C4key01[0x10]={0xBC, 0xF2, 0x15, 0x87, 0x22, 0x0E, 0x44, 0xE3, 0xCF, 0x51, 0x60, 0x43, 0x33, 0xE2, 0x5F, 0x54};
        //EASY TV EMM-G KEYS prov 0D05 0C
   unsigned char OCkey00[0x10]={0xF5, 0xB7, 0xE5, 0xE8, 0x2B, 0x60, 0x0D, 0x82, 0x16, 0xD3, 0x53, 0xED, 0xFB, 0x18, 0x9B, 0x13};
   unsigned char OCkey01[0x10]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
        //EASY TV EMM-G KEYS prov 0D05 04
   unsigned char O4key00[0x10]={0xF5, 0xB7, 0xE5, 0xE8, 0x2B, 0x60, 0x0D, 0x82, 0x16, 0xD3, 0x53, 0xED, 0xFB, 0x18, 0x9B, 0x13};
   unsigned char O4key01[0x10]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

   int i, j, r5, r14, nanoLenCopy, nanoLen = nano85[1];
   unsigned char var1A0[16], var280[0x80], var300[0x40], key[0x16];
   const int posCryptKey = nanoLen-6;
   CRWrsa *provi;
   CRWlast6 *provi_last6;

   provi = (CRWrsa *)CRWprovi_rsa;
   provi_last6 = (CRWlast6 *) CRWprovi_last6;

   nanoLenCopy = nanoLen;

   // select suitable RSA
   for(i=0; i<CRWnumofRSA; i++){
      if(provi->ident[3] == provID) break;
      provi++;
   }
   if (i==CRWnumofRSA) return 0;   // RSA not found

   // select suitable last6 BYTES
   for(i=0; i<provDecryptable; i++){
      if (provi_last6->provID[0] == provID) break;
      if (provi_last6->provID[1] == provID) break;
      if (provi_last6->provID[2] == provID) break;
      if (provi_last6->provID[3] == provID) break;
      provi_last6++;
   }

   switch (provID&3)
   {
      case 0:
         if (provID==0xC0) memcpy (key, C0key00, 0x10);
         if (provID==0xC4) memcpy (key, C4key00, 0x10);
         if (provID==0x0C) memcpy (key, OCkey00, 0x10);         
         break;
      case 1:
         if (provID==0xC0) memcpy (key, C0key01, 0x10);
         if (provID==0xC4) memcpy (key, C4key01, 0x10);
         if (provID==0x0C) memcpy (key, OCkey01, 0x10);         
         break;
   }
   memcpy (key+0x10, provi_last6->last6, 6);

   memcpy (var300, nano85+posCryptKey, 8);   // copy last 8 bytes (cryptKey)
   algoCRW(var300, key, odd, 1);

   var300[0] |= 0x80;
   if ((odd & 0x18) < 0x18) var300[0] = -1;
   if (odd & 8) var300[1] = -1;

   for(r14=0; nanoLenCopy>r14; r14+=0x20)
   {
      for(i=0; i<8; i++)
      {
         var1A0[i*2] = (tab_permut[var300[i]&0xF] | ((tab_permut[var300[i]>>4]) << 4));
         var1A0[(i*2)+1] = var300[i];
      }
   
      for(i=0; i<4; i++) memcpy(var300+(i*0x10), var1A0, 0x10);
      var300[0x10] = var300[0] ^ 1;
      var300[0x1F] = (var300[0xF]<<4) | 6;
      var300[0x20] = (var300[0x20] & 0x7F) | 0x40;

      swapbytes(var300, 0x20);
      swapbytes(var300+0x20, 0x20);

      DecryptRSA (var300, provi->rsa, expNano85, 64, 1);
      swapbytes (var300, 8);

      r5 = nanoLen-8;
      if (nanoLen>0x20) r5=0x20;
      memcpy(var280+r14, var300+8, r5);
      swapbytes (var280+r14, r5);
   
      nanoLen-=0x20;
   }

   // nano85_end XORING
   for(i=0; i<(nanoLenCopy); i++) buffOut[i] = nano85[i+2] ^ var280[i];
   return 1;
}

unsigned char SBOXES [4][0x40] = {
{
   0xD8, 0xD7, 0x83, 0x3D, 0x1C, 0x8A, 0xF0, 0xCF, 0x72, 0x4C, 0x4D, 0xF2, 0xED, 0x33, 0x16, 0xE0,
   0x8F, 0x28, 0x7C, 0x82, 0x62, 0x37, 0xAF, 0x59, 0xB7, 0xE0, 0x00, 0x3F, 0x09, 0x4D, 0xF3, 0x94,
   0x16, 0xA5, 0x58, 0x83, 0xF2, 0x4F, 0x67, 0x30, 0x49, 0x72, 0xBF, 0xCD, 0xBE, 0x98, 0x81, 0x7F,
   0xA5, 0xDA, 0xA7, 0x7F, 0x89, 0xC8, 0x78, 0xA7, 0x8C, 0x05, 0x72, 0x84, 0x52, 0x72, 0x4D, 0x38
},
{
   0xD8, 0x35, 0x06, 0xAB, 0xEC, 0x40, 0x79, 0x34, 0x17, 0xFE, 0xEA, 0x47, 0xA3, 0x8F, 0xD5, 0x48,
   0x0A, 0xBC, 0xD5, 0x40, 0x23, 0xD7, 0x9F, 0xBB, 0x7C, 0x81, 0xA1, 0x7A, 0x14, 0x69, 0x6A, 0x96,
   0x47, 0xDA, 0x7B, 0xE8, 0xA1, 0xBF, 0x98, 0x46, 0xB8, 0x41, 0x45, 0x9E, 0x5E, 0x20, 0xB2, 0x35,
   0xE4, 0x2F, 0x9A, 0xB5, 0xDE, 0x01, 0x65, 0xF8, 0x0F, 0xB2, 0xD2, 0x45, 0x21, 0x4E, 0x2D, 0xDB
},
{
   0xDB, 0x59, 0xF4, 0xEA, 0x95, 0x8E, 0x25, 0xD5, 0x26, 0xF2, 0xDA, 0x1A, 0x4B, 0xA8, 0x08, 0x25,
   0x46, 0x16, 0x6B, 0xBF, 0xAB, 0xE0, 0xD4, 0x1B, 0x89, 0x05, 0x34, 0xE5, 0x74, 0x7B, 0xBB, 0x44,
   0xA9, 0xC6, 0x18, 0xBD, 0xE6, 0x01, 0x69, 0x5A, 0x99, 0xE0, 0x87, 0x61, 0x56, 0x35, 0x76, 0x8E,
   0xF7, 0xE8, 0x84, 0x13, 0x04, 0x7B, 0x9B, 0xA6, 0x7A, 0x1F, 0x6B, 0x5C, 0xA9, 0x86, 0x54, 0xF9
},
{
   0xBC, 0xC1, 0x41, 0xFE, 0x42, 0xFB, 0x3F, 0x10, 0xB5, 0x1C, 0xA6, 0xC9, 0xCF, 0x26, 0xD1, 0x3F,
   0x02, 0x3D, 0x19, 0x20, 0xC1, 0xA8, 0xBC, 0xCF, 0x7E, 0x92, 0x4B, 0x67, 0xBC, 0x47, 0x62, 0xD0,
   0x60, 0x9A, 0x9E, 0x45, 0x79, 0x21, 0x89, 0xA9, 0xC3, 0x64, 0x74, 0x9A, 0xBC, 0xDB, 0x43, 0x66,
   0xDF, 0xE3, 0x21, 0xBE, 0x1E, 0x16, 0x73, 0x5D, 0xA2, 0xCD, 0x8C, 0x30, 0x67, 0x34, 0x9C, 0xCB
}, };
unsigned char SBtab [4][8] = {
   {0, 0x40, 4, 0x80, 0x21, 0x10, 2, 8},
   {0x80, 8, 1, 0x40, 4, 0x20, 0x10, 2},
   {0x82, 0x40, 1, 0x10, 0, 0x20, 4, 8},
   {2, 0x10, 4, 0x40, 0x80, 8, 1, 0x20},
};
unsigned char tab_1002D85C[0x2C]={
   1, 0, 3, 1, 2, 2, 3, 2,   1, 3, 1, 1, 3, 0, 1, 2, 3, 1, 3, 2, 2, 0,
   7, 6,   5, 4, 7, 6, 5, 7, 6, 5,   6, 7, 5, 7, 5, 7, 6, 6, 7, 5, 4, 4
};
unsigned char tab_1002D888[0x2C]={
   0x80,0x08,0x10,0x02,0x08,0x40,0x01,0x20,0x40,0x80,0x04,
   0x10,0x04,0x01,0x01,0x02,0x20,0x20,0x02,0x01,0x80,0x04,
   0x02,0x02,0x08,0x02,0x10,0x80,0x01,0x20,0x08,0x80,0x01,
   0x08,0x40,0x01,0x02,0x80,0x10,0x40,0x40,0x10,0x08,0x01
};
unsigned char tab_1002D8B4[4]={0x02, 0x10, 0x04, 0x04};
unsigned char tab_1002D8E0[17]={1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 1};
unsigned char tab_1002D8C0[24]={4, 5, 6, 7, 7, 6, 5, 4, 7, 4, 5, 6, 4, 7, 6, 5, 0, 2, 4, 6, 7, 5, 3, 1};

void cryptoworks_des (unsigned char *key, int mode, unsigned char *CW)
{
   int i, j, x, left, right, iteration;

   // split OpKey on 2 half
   lwz(left,0,key); lwz(right,4,key);

   iteration = 16;
   if ((mode&DESMOD1) || (mode&DESMOD3))   iteration = 2;

   if (mode&DESMOD3)   {
      for(i=2;i>0;i--) { left = rol1(left); right = rol1(right); }
   }

   if (mode&DES)
   {
      for(j=iteration-1; j>=0; j--)
      {
         x=j;
         if (mode&CRW_DES_RIGHT)
         {
            if (mode&DESMOD1) x=0;
            for(i=0; i<tab_1002D8E0[x+1]; i++) {   left = rol1(left); right = rol1(right); }
         }
         desRound (CW, left, right);
         if (!(mode&CRW_DES_RIGHT))
         {
            if (mode&DESMOD3) x=0;
            for(i=0; i<tab_1002D8E0[x]; i++) { left = ror1(left); right = ror1(right); }
         }
      }
   }
}

void desRound (unsigned char *buff, int left, int right)
{
   int r0,r3,r5,r6,r9,r10,r11,r26,r27,r30,r31;
   unsigned char tempbuff38[8], key[8];

   int2key (key, left, right);

//step1 create tempbuff
   for(r10=0;r10<2;r10++)
   {
      for(r31=0;r31<4;r31++)
      {
         r9 = tab_1002D8C0[(4*r10)+r31];
         r0 = tab_1002D8C0[(4*r10)+r31+8];
         if (r10!=0) r0 = ((buff[r9]<<1)&0x3E) | ((buff[r0]&0x80)>>7);
         else
         {
            r6 = buff[r0]&1;
            r0 = (buff[r9]>>1) | 0x80;
            if(r6==0) r0 = buff[r9]>>1;            
         }
         tempbuff38[tab_1002D8C0[(4*r10)+r31+0x10]]=r0&0xFF;
      }
   }

//step2
   r26=1;   r27=0;
   for(r31=0; r31<8; r31++)
   {
      r26^=1;
      r30=(r26^1)+6;
      if(r31!=0) r11 = r31-1;
      else r11=1;
      if(r26!=0) r9 = -(key[r11] & tab_1002D8B4[(r31-1)>>1]) >> 31;
      else r9 = tempbuff38[r11];

      for(r3=1; r30>r3; r3++)
      {
         r6 = (r9<<1)&0xFE;
         r5 = (r9>>1)&0x7F;
         r10 = tab_1002D888[r27];
         r0 = key[ tab_1002D85C[r27] ];

         if(r26!=0)
         {
            r9 = (r6|1) & 0xFF;
            if((r0&r10)==0) r9=r6&0xFF;
         }
         else
         {
            r9 = r5|0x80;
            if((r0&r10)==0) r9=r5&0xFF;
         }
         r27++;
      }

      if(r31!=0) r11++;
      else r11=0;
      if(r26!=0) tempbuff38[r11] ^= r9;
      else tempbuff38[r11] = (tempbuff38[r11]^r9)/4;
   }

   for(r31=0; r31<8; r31++)
   {
      for (r0=0; r0<4; r0++) buff[r0] ^= (SBtab[r0][r31] & SBOXES[r0][tempbuff38[r31]]);
   }

   memcpy(tempbuff38,buff,4);
   memcpy(buff,buff+4,4);
   memcpy(buff+4,tempbuff38,4);

   lwz(right,4,key); lwz(left,0,key);
}
#endif

#include "genincs.h"

#if defined(SUPPORT_SOFT_CI_SOLUTION) && defined(CRYPTOWORKS_MCAS_ON)
//#if 1

#include "emsc.h"
#include "dbmgr.h"

#include "nn.h"