Changeset 1853


Ignore:
Timestamp:
Mar 18, 2010, 6:19:12 PM (10 years ago)
Author:
_network
Message:

modular: read neutrino pmt.tmp in dvbapi

Location:
branches/modular
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • branches/modular/Distribution/doc/man/oscam.conf.5

    r1769 r1853  
    9898.RE
    9999.PP
     100\fBclientdyndns\fP = \fB0\fP|\fB1\fP
     101.RS 3n
     1021 = disable DNS resolving of clients, if you have already defined a hostname
     103for your clients the parameter must be 1, otherwise no authentication will
     104be possible for this clients, default:0
     105.RE
     106.PP
    100107\fBsleep\fP = \fBminutes\fP
    101108.RS 3n               
  • branches/modular/Distribution/doc/txt/oscam.conf.txt

    r1769 r1853  
    7474      delay for DNS resolving, default:30
    7575
     76       clientdyndns = 0|1
     77      1 = disable DNS resolving of clients, if you have already defined  a
     78      hostname  for  your  clients  the  parameter must be 1, otherwise no
     79      authentication will be possible for this clients, default:0
     80
    7681       sleep = minutes
    7782      time waiting for inactive users, default:none,  can  be  overwritten
  • branches/modular/globals.h

    r1839 r1853  
    298298    pthread_t rt;
    299299    unsigned char modem_status;
    300 } SR_CONFIG;
     300} GCC_PACK SR_CONFIG;
    301301#endif
    302302
  • branches/modular/module-dvbapi.c

    r1840 r1853  
    656656    if (demux_id<0) {
    657657        cs_log("dvbapi: error no free id (MAX_DEMUX)");
    658         return 0;
     658        return -1;
    659659    }
    660660
     
    710710        cs_log("dvbapi: new program number: %04X", program_number);
    711711
    712     return 0;
     712    return demux_id;
    713713}
    714714
     
    799799}
    800800
     801time_t pmt_timestamp=0;
     802int pmt_id=-1, dir_fd=-1;
     803
     804void event_handler(int signal) {
     805    struct stat pmt_info;
     806    uchar inhalt[200], dest[200];
     807    int len;
     808    int pmt_fd = open("/tmp/pmt.tmp", O_RDONLY);
     809    if(pmt_fd>0) {
     810        if (fstat(pmt_fd, &pmt_info) == 0) {
     811            if (pmt_info.st_mtime == pmt_timestamp) {
     812                return;
     813            }
     814
     815            if (pmt_id > -1) {
     816                dvbapi_stop_descrambling(pmt_id);
     817                fcntl(dir_fd, F_NOTIFY, 0);
     818                close(dir_fd);
     819                close(pmt_fd);
     820                return;
     821            }
     822
     823            pmt_timestamp = pmt_info.st_mtime;
     824
     825            cs_sleepms(100);
     826            //02 B0 <len> <srvid1> <srvid2> ..
     827            len = read(pmt_fd,inhalt,sizeof(inhalt));
     828            if (len<1) return;
     829
     830            cs_ddump(inhalt,len,"pmt:");
     831       
     832            memcpy(dest, "\x00\xFF\xFF\x00\x00\x13\x00", 7);
     833           
     834            dest[1] = inhalt[3];
     835            dest[2] = inhalt[4];
     836            dest[5] = inhalt[11]+1;
     837       
     838            memcpy(dest + 7, inhalt + 12, len - 12 - 4);
     839
     840            pmt_id = dvbapi_parse_capmt(dest, 7 + len - 12 - 4, -1);
     841            close(pmt_fd);
     842        }
     843    } else {
     844        if (pmt_id > -1)
     845            dvbapi_stop_descrambling(pmt_id);
     846
     847        fcntl(dir_fd, F_NOTIFY, 0);
     848        close(dir_fd);
     849    }
     850}
     851
    801852void dvbapi_main_local() {
    802853    int maxpfdsize=(MAX_DEMUX*MAX_FILTER)+MAX_DEMUX+2;
     
    841892    dvbapi_chk_caidtab(cfg->dvbapi_priority, &prioritytab);
    842893    dvbapi_chk_caidtab(cfg->dvbapi_ignore, &ignoretab);
     894
     895    int pmt_fd = open("/tmp/pmt.tmp", O_RDONLY);
     896    if(pmt_fd>0) {
     897        struct sigaction signal_action;
     898        signal_action.sa_handler = event_handler;
     899        sigemptyset(&signal_action.sa_mask);
     900        signal_action.sa_flags = 0;
     901        sigaction(SIGRTMIN + 1, &signal_action, NULL);
     902   
     903        dir_fd = open("/tmp/", O_RDONLY);
     904        if (dir_fd >= 0) {
     905            fcntl(dir_fd, F_SETSIG, SIGRTMIN + 1);
     906            fcntl(dir_fd, F_NOTIFY, DN_MODIFY | DN_CREATE | DN_DELETE | DN_MULTISHOT);
     907            event_handler(SIGRTMIN + 1);
     908        }
     909        close(pmt_fd);
     910    }
    843911
    844912    cs_ftime(&tp);
  • branches/modular/module-newcamd.c

    r1839 r1853  
    356356static int newcamd_recv(uchar *buf)
    357357{
    358   int rc, rs;
    359 
    360   if (is_server)
    361   {
    362     rs=network_message_receive(client[cs_idx].udp_fd,
    363                                &client[cs_idx].ncd_msgid, buf,
    364                                client[cs_idx].ncd_skey, COMMTYPE_SERVER);
    365   }
    366   else
    367   {
    368     if (!client[cs_idx].udp_fd) return(-1);
    369     rs=network_message_receive(client[cs_idx].udp_fd,
    370                                &reader[ridx].ncd_msgid,buf,
    371                                reader[ridx].ncd_skey, COMMTYPE_CLIENT);
    372   }
    373 
    374   if (rs<5) rc=(-1);
    375   else rc=rs;
    376 
    377   cs_ddump(buf, rs, "received %d bytes from %s", rs, remote_txt());
    378   client[cs_idx].last = time((time_t *) 0);
    379 
    380   if( rc==-1 )
    381   {
    382     if (rs > 0)
    383       cs_log("packet to small (%d bytes)", rs);
    384     else
    385       cs_log("Connection closed to %s", remote_txt());
    386   }
    387   return(rc);
     358    int rc, rs;
     359
     360    if (is_server)
     361    {
     362        rs = network_message_receive(client[cs_idx].udp_fd,
     363                &client[cs_idx].ncd_msgid, buf,
     364                client[cs_idx].ncd_skey, COMMTYPE_SERVER);
     365    }
     366    else
     367    {
     368        if (!client[cs_idx].udp_fd) return(-1);
     369        rs = network_message_receive(client[cs_idx].udp_fd,
     370                &reader[ridx].ncd_msgid, buf,
     371                reader[ridx].ncd_skey, COMMTYPE_CLIENT);
     372    }
     373
     374    if (rs < 5) rc = (-1);
     375    else rc = rs;
     376
     377    cs_ddump(buf, rs, "received %d bytes from %s", rs, remote_txt());
     378    client[cs_idx].last = time((time_t *) 0);
     379
     380    if(rc == -1) {
     381        if (rs > 0)
     382            cs_log("packet to small or too large (%d bytes)", rs);
     383        else
     384            cs_log("Connection closed to %s", remote_txt());
     385    }
     386
     387    return(rc);
    388388}
    389389
  • branches/modular/module-serial.c

    r1691 r1853  
    5454  int pmt_len;
    5555  int ecm_len;
    56 } GBOX_LENS;
     56} GCC_PACK GBOX_LENS;
    5757
    5858typedef struct s_sssp
     
    6161  ushort pid;
    6262  ulong  prid;
    63 } SSSP_TAB;
     63} GCC_PACK SSSP_TAB;
    6464
    6565
  • branches/modular/oscam.c

    r1839 r1853  
    153153#endif
    154154  fprintf(stderr, "\n\n");
    155   fprintf(stderr, "oscam [-b] [-c config-dir] [-d]");
     155  fprintf(stderr, "oscam [-b] [-c config-dir] [-d] [-h]");
    156156#ifdef CS_NOSHM
    157157  fprintf(stderr, " [-m memory-file]");
     
    174174  fprintf(stderr, "\t             default = %s\n", CS_MMAPFILE);
    175175#endif
     176  fprintf(stderr, "\t-h         : show this help\n");
    176177  fprintf(stderr, "\n");
    177178  exit(1);
  • branches/modular/reader-videoguard2.c

    r1776 r1853  
    6565unsigned short Hash3[] = {0x0123,0x4567,0x89AB,0xCDEF,0xF861,0xCB52};
    6666unsigned char Hash4[] = {0x0B,0x04,0x07,0x08,0x05,0x09,0x0B,0x0A,0x07,0x02,0x0A,0x05,0x04,0x08,0x0D,0x0F};
    67 
     67/*
    6868static void postprocess_cw(unsigned char *cw, int nTableIdx)
    6969{
     
    101101  cs_ddump (cw, 8, "Postprocessed2 DW:");
    102102
    103 
     103*/
    104104
    105105static void swap_lb (unsigned char *buff, int len)
     
    461461static int read_cmd_len(const unsigned char *cmd)
    462462{
    463   unsigned char cmd2[5]; 
    464   memcpy(cmd2,cmd,5); 
    465   cmd2[3]=0x80; 
    466   cmd2[4]=1; 
    467   if(!read_cmd(cmd2,NULL) || cta_res[1] != 0x90 || cta_res[2] != 0x00) { 
    468     cs_debug("[videoguard2-reader] failed to read %02x%02x cmd length (%02x %02x)",cmd[1],cmd[2],cta_res[1],cta_res[2]); 
     463  unsigned char cmd2[5];
     464  memcpy(cmd2,cmd,5);
     465  cmd2[3]=0x80;
     466  cmd2[4]=1;
     467  if(!read_cmd(cmd2,NULL) || cta_res[1] != 0x90 || cta_res[2] != 0x00) {
     468    cs_debug("[videoguard2-reader] failed to read %02x%02x cmd length (%02x %02x)",cmd[1],cmd[2],cta_res[1],cta_res[2]);
    469469    return -1;
    470470    }
     
    525525   unsigned short id;
    526526   char name[32];
    527 } tier_t;
     527} GCC_PACK tier_t;
    528528
    529529static tier_t skyit_tiers[] =
     
    668668    }
    669669    else if ((atr_size == sizeof (atr_foxtel_90b)) && (memcmp (atr, atr_foxtel_90b, atr_size) == 0))
    670     {   
     670    {
    671671    cs_ri_log("[videoguard2-reader] type: VideoGuard Foxtel Australia (090b)");
    672                 BASEYEAR = 2000;           
     672                BASEYEAR = 2000;
    673673    }
    674674/*    else
     
    821821}
    822822
     823
     824//Tables for B0 01 xx (00 to 14)
     825
     826unsigned short mem10C1E0[672]={
     827        0xEAF1, 0x237,  0x29D0, 0xBAD2, 0xE9D3, 0x8BAE, 0x2D6D, 0xCD1B, 0x538D, 0xDE6B, 0xA634,
     828        0xF81A, 0x18B5, 0x5087, 0x14EA, 0x672E, 0xF0FC, 0x55E,  0x62E5, 0xB78F, 0x5D09, 0x03,
     829        0xE4E8, 0x2DCE, 0x6BE0, 0xAC4E, 0xF485, 0x6967, 0xF28C, 0x97A0, 0x1EF,  0x100,  0xC539,
     830        0xF5B9, 0x9099, 0x13A,  0xD4B9, 0x6AB5, 0xEA67, 0x7EB4, 0x6C30, 0x4BF0, 0xB810, 0xB0B5,
     831        0xB76D, 0xA751, 0x1AE7, 0x14CA, 0x4F4F, 0x1586, 0x2608, 0x10B1, 0xE7E1, 0x48BE, 0x7DDD,
     832        0x5ECB, 0xCFBF, 0x323B, 0x8B31, 0xB131, 0xF1A,  0x664B, 0x140,  0x100,  0x3C7D, 0xBDC4,
     833        0xFEC7, 0x26A6, 0xB0A0, 0x6E55, 0xF710, 0xF9BF, 0x23,   0xE81F, 0x41CA, 0xBE32, 0xB461,
     834        0xE92D, 0xF1AF, 0x409F, 0xFC85, 0xFE5B, 0x7FCE, 0x17F5, 0x1AB,  0x4A46, 0xEB05, 0xA251,
     835        0xDC6F, 0xF0C0, 0x10F0, 0x1D51, 0xEFAA, 0xE9BF, 0x100,  0x100,  0x1819, 0xCAA,  0x9067,
     836        0x607A, 0x7576, 0x1CBC, 0xE51D, 0xBF77, 0x7EC6, 0x839E, 0xB695, 0xF096, 0xDC10, 0xCB69,
     837        0x4654, 0x8E68, 0xD62D, 0x4F1A, 0x4227, 0x92AC, 0x9064, 0x6BD1, 0x1E75, 0x2747, 0xDA,
     838        0xA6A6, 0x6CF1, 0xD151, 0xBE56, 0x3E33, 0x128,  0x100,  0x4091, 0x9ED,  0xD494, 0x6054,
     839        0x1869, 0x71D5, 0xB572, 0x7BF1, 0xE925, 0xEE2D, 0xEEDE, 0xA13C, 0x6613, 0x9BAB, 0x122D,
     840        0x7AE4, 0x5268, 0xE6C9, 0x50CB, 0x79A1, 0xF212, 0xA062, 0x6B48, 0x70B3, 0xF6B0, 0x6D5,
     841        0xF8AB, 0xECF5, 0x6255, 0xEDD8, 0x79D2, 0x290A, 0xD3CF, 0x14E,  0xACB3, 0x8F6B, 0xF2C,
     842        0xA5D8, 0xE8E0, 0x863D, 0x80D5, 0x5705, 0x658A, 0x8BC2, 0xEE46, 0xD3AE, 0x199,  0x100,
     843        0x4A35, 0xABE4, 0xF976, 0x935A, 0xA8A5, 0xBAE9, 0x24D0, 0x71AA, 0xB3FE, 0x95E,  0xAB06,
     844        0x4CD5, 0x2F0D, 0x1ACB, 0x59F3, 0x4C50, 0xFD27, 0xF8E,  0x191A, 0xEEE7, 0x2F49, 0x3A05,
     845        0x3267, 0x4F88, 0x38AE, 0xFCE9, 0x9476, 0x18C6, 0xF961, 0x4EF0, 0x39D0, 0x42E6, 0xB747,
     846        0xE625, 0xB68E, 0x5100, 0xF92A, 0x86FE, 0xE79B, 0xEE91, 0x21D5, 0x4C3C, 0x683D, 0x5AD1,
     847        0x1B49, 0xF407, 0x194,  0x100,  0x4BF9, 0xDC0D, 0x9478, 0x5174, 0xCB4A, 0x8A89, 0x4D6A,
     848        0xFED8, 0xF123, 0xA8CD, 0xEEE7, 0xA6D1, 0xB763, 0xF5E2, 0xE085, 0x1EF,  0xE466, 0x9FA3,
     849        0x2F68, 0x2190, 0x423F, 0x287F, 0x7F3F, 0x9F6,  0x2111, 0xA963, 0xD0BB, 0x674A, 0xBA72,
     850        0x45F9, 0xF186, 0xB8F5, 0x10,   0xD1B9, 0xB164, 0x9E87, 0x1F49, 0x6950, 0x2DBF, 0x38D3,
     851        0x2EB0, 0x3E8E, 0x91E6, 0xF688, 0x7E41, 0x566E, 0x1B0,  0x100,  0x24A1, 0x73D8, 0xA0C3,
     852        0xF71B, 0xA0A5, 0x2A06, 0xBA46, 0xFEC3, 0xDD4C, 0x52CC, 0xF9BC, 0x3B7E, 0x3812, 0x666,
     853        0xB74B, 0x40F8, 0x28F2, 0x7C81, 0xFC92, 0x6FBD, 0x53D6, 0x72A3, 0xBBDF, 0xB6FC, 0x9CE5,
     854        0x2331, 0xD4F6, 0xC5BB, 0xE8BB, 0x6676, 0x2D9,  0x2F0E, 0xD009, 0xD136, 0xCD09, 0x7551,
     855        0x1826, 0x9D9B, 0x63EA, 0xFC63, 0x68CD, 0x3672, 0xCB95, 0xD28E, 0xF1CD, 0x20CA, 0x14C,
     856        0x100,  0xE539, 0x55B7, 0x989D, 0x21C4, 0x463A, 0xE68F, 0xF8B5, 0xE5C5, 0x662B, 0x35BF,
     857        0x3C50, 0x131,  0xF4BF, 0x38B2, 0x41BC, 0xB829, 0x2B7,  0x6B8F, 0xA25C, 0xAFD2, 0xD84A,
     858        0x2243, 0x53EB, 0xC6C9, 0x2E14, 0x181F, 0x8F96, 0xDF0E, 0xD4C,  0x30F6, 0xFFE1, 0x9DDA,
     859        0x30B6, 0x777E, 0xDA3D, 0xAF77, 0x205E, 0xC90B, 0x856B, 0xB451, 0x3BCC, 0x76C2, 0x8ACF,
     860        0xDCB1, 0xA5E5, 0xDD64, 0x197,  0x100,  0xE751, 0xB661, 0x404,  0xDB4A, 0xE9DD, 0xA400,
     861        0xAF26, 0x3F5E, 0x904B, 0xA924, 0x9E0,  0xE72B, 0x825B, 0x2C50, 0x6FD0, 0xD52,  0x2730,
     862        0xC2BA, 0x9E44, 0x5815, 0xFC47, 0xB21D, 0x67B8, 0xF8B9, 0x47D,  0xB0AF, 0x9F14, 0x741B,
     863        0x4668, 0xBE54, 0xDE16, 0xDB14, 0x7CB7, 0xF2B8, 0x683,  0x762C, 0x9A0,  0x9507, 0x7F92,
     864        0x22C,  0xBA6A, 0x7D52, 0xAF4,  0x1BC3, 0xB46A, 0xC4FD, 0x1C2,  0x100,  0x7611, 0x66F3,
     865        0xEE87, 0xEDD3, 0xC559, 0xEFD4, 0xDC59, 0xF86B, 0x6D1C, 0x1C85, 0x9BB1, 0x3373, 0x763F,
     866        0x4EBE, 0x1BF3, 0x99B5, 0xD721, 0x978F, 0xCF5C, 0xAC51, 0x984,  0x7462, 0x8F0C, 0x2817,
     867        0x4AD9, 0xFD41, 0x6678, 0x7C85, 0xD330, 0xC9F8, 0x1D9A, 0xC622, 0x5AE4, 0xE16A, 0x60F6,
     868        0xFD45, 0x668C, 0x29D6, 0x285,  0x6B92, 0x92C2, 0x21DE, 0x45E0, 0xEF3D, 0x8B0D, 0x2CD,
     869        0x198,  0x100,  0x9E6D, 0x4D38, 0xDEF9, 0xE6F2, 0xF72E, 0xB313, 0x14F2, 0x390A, 0x2D67,
     870        0xC71E, 0xCB69, 0x7F66, 0xD3CF, 0x7F8A, 0x81D9, 0x9DDE, 0x85E3, 0x8F29, 0x36EB, 0xC968,
     871        0x3696, 0x59F6, 0x7832, 0xA78B, 0xA1D8, 0xF5CF, 0xAB64, 0x646D, 0x7A2A, 0xBAF8, 0xAA87,
     872        0x41C7, 0x5120, 0xDE78, 0x738D, 0xDC1A, 0x268D, 0x5DF8, 0xED69, 0x1C8A, 0xBC85, 0x3DCD,
     873        0xAE30, 0xF8D,  0xEC89, 0x3ABD, 0x166,  0x100,  0xB8BD, 0x643B, 0x748E, 0xBD63, 0xEC6F,
     874        0xE23A, 0x9493, 0xDD76, 0xA62,  0x774F, 0xCD68, 0xA67A, 0x9A23, 0xC8A8, 0xBDE5, 0x9D1B,
     875        0x2B86, 0x8B36, 0x5428, 0x1DFB, 0xCD1D, 0x713,  0x29C2, 0x8E8E, 0x5207, 0xA13F, 0x6005,
     876        0x4F5E, 0x52E0, 0xE7C8, 0x6D1C, 0x3E34, 0x581D, 0x2BFA, 0x5E1D, 0xA891, 0x1069, 0x1DA4,
     877        0x39A0, 0xBE45, 0x5B9A, 0x7333, 0x6F3E, 0x8637, 0xA550, 0xC9E9, 0x5C6C, 0x42BA, 0xA712,
     878        0xC3EA, 0x3808, 0x910,  0xAA4D, 0x5B25, 0xABCD, 0xE680, 0x96AD, 0x2CEC, 0x8EBB, 0xA47D,
     879        0x1690, 0xE8FB, 0x1C8,  0x100,  0x73B9, 0x82BC, 0x9EBC, 0xB130, 0xDA5,  0x8617, 0x9F7B,
     880        0x9766, 0x205D, 0x752D, 0xB05C, 0x2A17, 0xA75C, 0x18EF, 0x8339, 0xFD34, 0x8DA2, 0x7970,
     881        0xD0B4, 0x70F1, 0x3765, 0x7380, 0x7CAF, 0x570E, 0x6440, 0xBC44, 0x743,  0x2D02, 0x419,
     882        0xA240, 0x2113, 0x1AD4, 0x1EB5, 0xBBFF, 0x39B1, 0x3209, 0x705F, 0x15F4, 0xD7AD, 0x340B,
     883        0xC2A6, 0x25CA, 0xF412, 0x9570, 0xF4F,  0xE4D5, 0x1614, 0xE464, 0x911A, 0xF0E,  0x7DA,
     884        0xA929, 0x2379, 0xD988, 0xAA6,  0x3B57, 0xBF63, 0x71FB, 0x72D5, 0x26CE, 0xB0AF, 0xCF45,
     885        0x11B,  0x100,  0x9999, 0x98FE, 0xA108, 0x6588, 0xF90B, 0x4554, 0xFF38, 0x4642, 0x8F5F,
     886        0x6CC3, 0x4E8E, 0xFF7E, 0x64C2, 0x50CA, 0xE7F,  0xAD7D, 0x6AAB, 0x33C1, 0xE1F4, 0x6165,
     887        0x7894, 0x83B9, 0xA0C,  0x38AF, 0x5803, 0x18C0, 0xFA36, 0x592C, 0x4548, 0xABB8, 0x1527,
     888        0xAEE9 };
     889
     890typedef struct Attack_data {                                     //dim 0x6C bytes
     891        char Unused0[0x10];
     892        unsigned char val4[0x40];
     893        char Unused1[0x08];
     894        unsigned short Val7[0x14];
     895} GCC_PACK MyData;
     896
     897
     898static void PrepareData1(MyData *P1) {
     899    unsigned short Tb1[0x6]={0x0123,0x4567,0x89AB,0xCDEF,0xF861,0xCB52};
     900    int i;
     901    for(i = 0; i < 6; i++) P1->Val7[i] = Tb1[i];
     902}
     903
     904static void PrepareData4(MyData *P1) {
     905    int Tb[4]={0x67452301,0xefcdab89,0x98badcfe,0x10325476};
     906    int *mybuf = (int*) P1->Val7;
     907    int i;
     908    for(i = 0; i < 4; i++) mybuf[i] = Tb[i];
     909}
     910
     911static unsigned char AdditionalFunc1(MyData *P1, int P2) {
     912  short res;
     913  short *buf = (short*) P1->Val7;
     914
     915    if(P2&1)
     916        res=((buf[(P2>>1)])>>8);  //Return HIGH byte
     917    else
     918        res=(buf[(P2>>1)]);       //Return LOW byte
     919
     920        return (res & 0xFF);
     921}
     922
     923static unsigned char AdditionalFunc4(MyData *P1, int P2) {
     924  int res = 0;
     925  int *buf = (int*) P1->Val7;
     926
     927  switch (P2&3) {
     928    case 0: res=((buf[(P2>>2)])>>0); break;
     929    case 1: res=((buf[(P2>>2)])>>8); break;
     930    case 2: res=((buf[(P2>>2)])>>16); break;
     931    case 3: res=((buf[(P2>>2)])>>24); break;
     932  };
     933
     934        return (res & 0xFF);
     935}
     936
     937static void Process_1(MyData *Data, int TableIdx) {
     938    unsigned char var0=0,var3=0;
     939    int var1;
     940    short *Tmp=(short*)Data->Val7;
     941    int var8 = Tmp[0];//(sword[(var_ext_1 + 4*0x16)]);
     942    int var2 = Tmp[1];//(sword[var_ext_1 + 0x5A]);
     943    int var5 = Tmp[2];//(sword[(var_ext_1 + 4*0x17)]);
     944    int var4 = Tmp[3];//(sword[var_ext_1 + 0x5E]);
     945    int var9 = Tmp[4];//(sword[(var_ext_1 + 4*0x18)]);
     946    int var6 = Tmp[5];//(sword[var_ext_1 + 0x62]);
     947    int var7;
     948    int var0xB;
     949    int var0xD;
     950    int var0xC;
     951    int var0xE;
     952    int var0xF = 0;
     953    short *var0x10 = (short*) mem10C1E0+(TableIdx*0x20);
     954    unsigned char var0x11[0x10] = {0x0B,0x04,0x07,0x08,0x05,0x09,0x0B,0x0A,0x07,0x02,0x0A,0x05,0x04,0x08,0x0D,0x0F};   //byte array
     955    unsigned char *var0xA = Data->val4;
     956    do{
     957        var1=0;
     958        do{
     959            var0xB=((var0xA[(var1*2) +1]<<8)+var0xA[var1*2])&0xFFFF;
     960
     961            if(var0xF)
     962                var7 = (((var2 & var4) | ((~var4) & var5)) & 0xFFFF);
     963            else
     964                var7 = (((var2 & var5) | ((~var2) & var4)) & 0xFFFF);
     965            if((var0 & 1))
     966                var0xC = (var0x10[(var0>>1)])>>8;
     967            else
     968                var0xC = (var0x10[(var0>>1)]);
     969            var0xE = var8;
     970            var8 = var2;
     971            var0xD = var2;
     972            var2 = var5;
     973            var5 = var4;
     974            var4 = var9;
     975            var9 = var6;
     976            var6 = ((((var7 + var0xE) + var0xB) + (var0xC & 0xFF)) & 0xFFFF);
     977            var7 = var0x11[var3];
     978            var6 = ((((var6 << var7) | (var6 >> (0x10 - var7))) + var0xD) & 0xFFFF);
     979            var3++;
     980            if(var3 == 0x10)
     981                var3 = 0;
     982            var0 = (var0 + 1) & 0xFF;
     983            if(var0 == 0x40)
     984                var0 = 0;
     985
     986            var1++;
     987        }while(var1<0x24);
     988        var0xF++;
     989    }while(var0xF<2);
     990    Tmp[0] = (var8 + Tmp[0]);
     991    Tmp[1] = (var2 + Tmp[1]);
     992    Tmp[2] = (var5 + Tmp[2]);
     993    Tmp[3] = (var4 + Tmp[3]);
     994    Tmp[4] = (var9 + Tmp[4]);
     995    Tmp[5] = (var6 + Tmp[5]);
     996    return;
     997}
     998
     999
     1000
     1001#define I(x, y, z) ((y) ^ ((x) | ~(z)))
     1002#define H(x, y, z) ((x) ^ (y) ^ (z))
     1003#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
     1004#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
     1005#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
     1006
     1007static int Transform_MD5_C069B411(MyData *Data){    // ROM:C069B411
     1008     short var0;
     1009     short var5;
     1010     short var9;
     1011
     1012     unsigned int var1;
     1013     unsigned int var2;
     1014     unsigned char var4;
     1015
     1016     unsigned int var6;
     1017     unsigned int var7;
     1018     unsigned int var8;
     1019
     1020     unsigned int var0xA;
     1021     unsigned int var0xB;
     1022     unsigned int var0xC = 0;
     1023     unsigned char *var0xD;
     1024     unsigned int var0xE;
     1025     unsigned int *mybuf = (unsigned int*) Data->Val7;
     1026    unsigned char mem08C0[] = {0x00, 0x01, 0x05, 0x00, 0x01, 0x05, 0x03, 0x07};
     1027
     1028
     1029
     1030
     1031    int MD5_C[] = {
     1032                                // round 1
     1033        0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
     1034        0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
     1035        0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
     1036        0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
     1037                                // round 2
     1038        0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
     1039        0xd62f105d, 0x2441453,  0xd8a1e681, 0xe7d3fbc8,
     1040        0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
     1041        0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
     1042                                // round 3
     1043        0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
     1044        0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
     1045        0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
     1046        0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
     1047                                // round 4
     1048        0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
     1049        0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
     1050        0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
     1051        0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
     1052    };
     1053
     1054
     1055
     1056    unsigned char S[] = {7, 12, 17, 22,
     1057        5, 9, 14, 20,
     1058        4, 11, 16, 23,
     1059        6, 10, 15, 21
     1060    };
     1061
     1062     var7 = mybuf[0];
     1063     var2 = mybuf[1];
     1064     var8 = mybuf[2];
     1065     var6 = mybuf[3];
     1066     var5 = 0;
     1067     var9 = 0;
     1068
     1069
     1070
     1071     while(var9 < 4)     {
     1072          var1   = mem08C0[var9+0];  //OK
     1073          var0xE = mem08C0[var9+4];  //OK
     1074          var0 = 0;
     1075
     1076          var0xD = &S[var9*4];
     1077
     1078
     1079          while(var0 < 16) {
     1080               var4=var1*4;
     1081               var0xB = (Data->val4[var4+3] << 24) | (Data->val4[var4+2] << 16) | (Data->val4[var4+1] << 8) | (Data->val4[var4]);
     1082               var4 = var9;
     1083
     1084               switch (var4) {
     1085                 case 0: var0xC=F(var2,var8,var6);
     1086                         break;
     1087                 case 1: var0xC=G(var2,var8,var6);
     1088                         break;
     1089                 case 2: var0xC=H(var2,var8,var6);
     1090                         break;
     1091                 case 3: var0xC=I(var2,var8,var6);
     1092                         break;
     1093               }
     1094
     1095               var0xA = var6;
     1096               var6 = var8;
     1097               var8 = var2;
     1098               var7 = (((var0xC + var7) + var0xB) + MD5_C[var5]);
     1099               var4 = var0xD[var0 & 3];
     1100               var2=var2+ROTATE_LEFT(var7,var4);
     1101
     1102               var7 = var0xA;
     1103               var1 = ((var1 + var0xE) & 0xF);
     1104               var0++;
     1105               var5++;
     1106          };
     1107          var9++;
     1108     };
     1109
     1110
     1111     mybuf[0] = (var7 + mybuf[0]);
     1112     mybuf[1] = (var2 + mybuf[1]);
     1113     mybuf[2] = (var8 + mybuf[2]);
     1114     mybuf[3] = (var6 + mybuf[3]);
     1115
     1116     return(0);
     1117}
     1118
     1119/*
     112080 70 8E 00 00 01
     112128 9E 10 7C 19 04 5B AA 55 81 21 84 01 00 01 01 02 FF FF 80
     112201 12 B0 03 0A 00 87 F4 0B 98 99 FF DD 0C 10 C0 80 C2 20 03 17 61 7E 0A A0 7F 9B 14 05 66 3E CD 00 00 90 53 C0 02 94 33 75 1C 54 32 3C E9 21 B4 23 9E A2 D2 2E 85 AE 75 24 2D 71 16 DA 39 88 65 AE C3 0F 10 B2 2A 93 A8 53 00 AD 93 B6 8D C4 30 B1 DE 75 1F A8 3E EF A9 DC AC F1 5F AE B4 8A E9 60 E3 27 FC 64 29 8B ED 5C AA 06 D5 42 D8 2A 6D 48 FA D6 65 A3 F8 C4
     1123*/
     1124
     1125static void do_post_dw_hash(unsigned char *DW_INPUT, unsigned char *DW_OUTPUT, unsigned char *ecm_header_data) {
     1126    MyData Data;
     1127    int a,i,j,ecmi,ecm_header_count;
     1128
     1129    //ecm_header_data = 01 03 b0 01 01
     1130
     1131    if (!cw_is_valid(DW_INPUT)) //if cw is all zero, keep it that way
     1132        return;
     1133
     1134    ecm_header_count=ecm_header_data[0];
     1135
     1136    for(i=0, ecmi = 1; i<ecm_header_count; i++) {
     1137                if(ecm_header_data[ecmi+1] != 0xb0) {
     1138                        ecmi += ecm_header_data[ecmi]+1;
     1139                } else {
     1140                  switch(ecm_header_data[ecmi+2]) {   //b0 01
     1141                  case 1:
     1142                    {
     1143                    memset(Data.val4, 0, sizeof(Data.val4));
     1144                    memcpy(Data.val4,DW_INPUT,8);
     1145                    Data.val4[0x8]=0x80;
     1146                    PrepareData1(&Data);
     1147                    Process_1(&Data, ecm_header_data[ecmi+3]);
     1148                    for(a=0;a<8;a++) DW_OUTPUT[a]=AdditionalFunc1(&Data,a);
     1149
     1150                    break;
     1151                    }
     1152                case 3:
     1153                    {
     1154                    memset(Data.val4, 0, sizeof(Data.val4));
     1155                    memcpy(Data.val4,DW_INPUT,8);
     1156                    memcpy(Data.val4+8,&ecm_header_data[ecmi+3],ecm_header_data[ecmi]-2);
     1157                    Data.val4[8+(ecm_header_data[ecmi]-2)]=0x80;
     1158                    a=(ecm_header_data[ecmi]-2+8);
     1159                    Data.val4[0x38] = (a << 3);
     1160                    a = (a >> 5);
     1161                    for (j=1; j<8; j++)
     1162                    {
     1163                      Data.val4[0x38+j] = a;
     1164                      a = a >> 8;
     1165                    }
     1166                    PrepareData4(&Data);
     1167                    Transform_MD5_C069B411(&Data);
     1168                    for(a=0;a<8;a++) DW_OUTPUT[a]=AdditionalFunc4(&Data,a);
     1169
     1170                    break;
     1171                    }
     1172
     1173                case 2:
     1174                    {  /* Method 2 left out */
     1175                    memcpy(DW_OUTPUT, DW_INPUT, 8);
     1176                    break;
     1177                    }
     1178                  }
     1179                }
     1180    }
     1181  cs_ddump (DW_OUTPUT, 8, "Postprocessed DW:");
     1182}
     1183
    8231184int videoguard_do_ecm(ECM_REQUEST *er)
    8241185{
     1186  unsigned char cw[16];
    8251187  static unsigned char ins40[5] = { 0xD1,0x40,0x00,0x80,0xFF };
    8261188  static const unsigned char ins54[5] = { 0xD3,0x54,0x00,0x00,0x00};
     
    8471209      }
    8481210
     1211
    8491212      //test for postprocessing marker
    8501213      int posB0 = -1;
     
    8521215      for (i = 6; i < posECMpart2; i++)
    8531216      {
    854         if (er->ecm[i] == 0xB0 && er->ecm[i+1] == 0x01 ) {
     1217        if (er->ecm[i-3] == 0x80 && er->ecm[i] == 0xB0 && ((er->ecm[i+1] == 0x01) ||(er->ecm[i+1] == 0x02)||(er->ecm[i+1] == 0x03) ) ) {
    8551218            posB0 = i;
    8561219          break;
    8571220        }
    8581221      }
     1222
     1223      if (posB0 != -1) {
     1224          memcpy(cw, er->cw+0, 16);
     1225          do_post_dw_hash(&cw[0], er->cw+0, &er->ecm[posB0-2]);
     1226          do_post_dw_hash(&cw[8], er->cw+8, &er->ecm[posB0-2]);
     1227      }
     1228
     1229/*
    8591230      if (posB0 != -1) {
    8601231    postprocess_cw(er->cw+0, er->ecm[posB0+2]);
    8611232    postprocess_cw(er->cw+8, er->ecm[posB0+2]);
    8621233      }
     1234
     1235*/
     1236
    8631237      return OK;
    8641238    }
Note: See TracChangeset for help on using the changeset viewer.