Changeset 9568


Ignore:
Timestamp:
Mar 16, 2014, 1:48:56 PM (6 years ago)
Author:
blaky
Message:

added Patch from pfanne
to get more feedback from other VG2 Card Owners
see: http://www.streamboard.tv/wbb2/thread.php?threadid=40471

-Added some info on entitlements page's
-Fix ins4c longer than 9 byte (like v14)
-Fix wrong order of some ins at boot
-Added possibility to send ins2e06 (like italian stb*)
-Added (experimental!) unlock parental control (it reads the pin from card and sends it with ins2e04, we don't need to write it in the config) set it on config>global

  • seems that the actual value for sky_it is BFFFFFFF

if your provider uses it, add ins2e06 = BFFFFFFF (or similar) in config or webif

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/globals.h

    r9565 r9568  
    13471347    unsigned char   rom[15];
    13481348    unsigned char   irdId[4];
     1349    uint16_t        VgCredit;
     1350    uint16_t        VgPin;
     1351    unsigned char   VgRegionC[8];
    13491352#ifdef WITH_LB
    13501353    int32_t         lb_weight;                      //loadbalance weight factor, if unset, weight=100. The higher the value, the higher the usage-possibility
     
    13811384    uint8_t         ins7E[0x1A + 1];
    13821385    uint8_t         ins7E11[0x01 + 1];
     1386    uint8_t         ins2e06[0x04 + 1];
    13831387    int8_t          ins7e11_fast_reset;
    13841388    uint8_t         sc8in1_dtrrts_patch; // fix for kernel commit 6a1a82df91fa0eb1cc76069a9efe5714d087eccd
  • trunk/module-webif.c

    r9562 r9568  
    17291729    {
    17301730        tpl_printf(vars, TPLAPPEND, "INS7E11", "%02X", rdr->ins7E11[0]);
     1731    }
     1732
     1733    // ins2e06
     1734    if(rdr->ins2e06[0x04])
     1735    {
     1736        for(i = 0; i < 4 ; i++) { tpl_printf(vars, TPLAPPEND, "INS2E06", "%02X", rdr->ins2e06[i]); }
    17311737    }
    17321738
     
    37473753                }
    37483754
    3749 
     3755                //regional code for Vg card
     3756                if(rdr->VgRegionC[0])
     3757                {
     3758                    for(i = 0; i < 8; i++) { tpl_printf(vars, TPLAPPEND, "READER_RCODE", "%c", rdr->VgRegionC[i]); }
     3759                }
     3760                else
     3761                {
     3762                    tpl_addVar(vars, TPLADD, "READER_RCODE", "n/a");
     3763                }
     3764
     3765                //Pin Vg card
     3766                if(rdr->VgPin)
     3767                {
     3768                    tpl_printf(vars, TPLAPPEND, "READERPIN", "%04i", rdr->VgPin);
     3769                }
     3770                else
     3771                {
     3772                    tpl_addVar(vars, TPLADD, "READERPIN", "n/a");
     3773                }
     3774
     3775                //credit on Vg card
     3776                if(rdr->VgCredit)
     3777                {
     3778                    tpl_printf(vars, TPLAPPEND, "READERCREDIT", "%i", rdr->VgCredit);
     3779                }
     3780                else
     3781                {
     3782                    tpl_addVar(vars, TPLADD, "READERCREDIT", "n/a");
     3783                }
    37503784
    37513785                if(rdr->card_valid_to)
  • trunk/oscam-config-reader.c

    r9531 r9568  
    990990    DEF_OPT_FUNC_X("ins7e"              , OFS(ins7E),                   ins7E_fn, SIZEOF(ins7E)),
    991991    DEF_OPT_FUNC_X("ins7e11"            , OFS(ins7E11),                 ins7E_fn, SIZEOF(ins7E11)),
     992    DEF_OPT_FUNC_X("ins2e06"            , OFS(ins2e06),                 ins7E_fn, SIZEOF(ins2e06)),
    992993    DEF_OPT_INT8("fix9993"              , OFS(fix_9993),                0),
    993994    DEF_OPT_INT8("force_irdeto"         , OFS(force_irdeto),            0),
     
    10741075    {
    10751076        "readnano", "resetcycle", "smargopatch", "autospeed", "sc8in1_dtrrts_patch", "boxid",
    1076         "fix9993", "rsakey", "ins7e", "ins7e11", "force_irdeto", "needsemmfirst", "boxkey",
     1077        "fix9993", "rsakey", "ins7e", "ins7e11", "ins2e06", "force_irdeto", "needsemmfirst", "boxkey",
    10771078        "atr", "detect", "nagra_read", "mhz", "cardmhz",
    10781079#ifdef WITH_AZBOX
  • trunk/reader-videoguard2.c

    r8960 r9568  
    402402    unsigned char buff[256];
    403403
    404     static const unsigned char ins7416[5] = { 0xD0, 0x74, 0x16, 0x00, 0x00 };
    405     if(do_cmd(reader, ins7416, NULL, NULL, cta_res) < 0)
    406     {
    407         rdr_log(reader, "classD0 ins7416: failed");
    408         return ERROR;
    409     }
    410 
    411404    static const unsigned char ins02[5] = { 0xD0, 0x02, 0x00, 0x00, 0x08 };
    412405    // D0 02 command is not always present in command table but should be supported
     
    439432    }
    440433
    441 
     434    /* get Vg credit on card */
     435    unsigned char ins7404[5] = { 0xD0, 0x74, 0x04, 0x00, 0x00 };
     436    l = read_cmd_len(reader, ins7404);     //get command len for ins7404
     437    ins7404[4] = l;
     438    if(!write_cmd_vg(ins7404, NULL) || !status_ok(cta_res + l))
     439    {
     440        rdr_log(reader, "Unable to get smartcard credit");
     441    }
     442    else
     443    {
     444        if (cta_res[0] == 0x15)
     445        {
     446            reader->VgCredit = ((cta_res[8] << 8) + cta_res[9]) / 100;
     447            rdr_log(reader, "Credit available on card: %i €", reader->VgCredit);
     448        }
     449    }
     450
     451    if(reader->ins7E11[0x01])
     452    {
     453        unsigned char ins742b[5] = { 0xD0, 0x74, 0x2b, 0x00, 0x00 };
     454
     455        l = read_cmd_len(reader, ins742b);  //get command len for ins742b
     456
     457        if(l < 2)
     458        {
     459            rdr_log(reader, "No TA1 change for this card is possible by ins7E11");
     460        }
     461        else
     462        {
     463            ins742b[4] = l;
     464            bool ta1ok = 0;
     465
     466            if(!write_cmd_vg(ins742b, NULL) || !status_ok(cta_res + ins742b[4]))  //get supported TA1 bytes
     467            {
     468                rdr_log(reader, "classD0 ins742b: failed");
     469                return ERROR;
     470            }
     471            else
     472            {
     473                int32_t i;
     474
     475                for(i = 2; i < l; i++)
     476                {
     477                    if(cta_res[i] == reader->ins7E11[0x00])
     478                    {
     479                        ta1ok = 1;
     480                        break;
     481                    }
     482                }
     483            }
     484            if(ta1ok == 0)
     485            {
     486                rdr_log(reader, "The value %02X of ins7E11 is not supported,try one between %02X and %02X", reader->ins7E11[0x00], cta_res[2], cta_res[ins742b[4] - 1]);
     487            }
     488            else
     489            {
     490                static const uint8_t ins7E11[5] = { 0xD0, 0x7E, 0x11, 0x00, 0x01 };
     491
     492                reader->ins7e11_fast_reset = 0;
     493
     494                l = do_cmd(reader, ins7E11, reader->ins7E11, NULL, cta_res);
     495
     496                if(l < 0 || !status_ok(cta_res))
     497                {
     498                    rdr_log(reader, "classD0 ins7E11: failed");
     499                    return ERROR;
     500                }
     501                else
     502                {
     503                    unsigned char TA1;
     504
     505                    if(ATR_GetInterfaceByte(newatr, 1, ATR_INTERFACE_BYTE_TA, &TA1) == ATR_OK)
     506                    {
     507                        if(TA1 != reader->ins7E11[0x00])
     508                        {
     509                            rdr_log(reader, "classD0 ins7E11: Scheduling card reset for TA1 change from %02X to %02X", TA1, reader->ins7E11[0x00]);
     510                            reader->ins7e11_fast_reset = 1;
     511#ifdef WITH_COOLAPI
     512                            if(reader->typ == R_MOUSE || reader->typ == R_SC8in1 || reader->typ == R_SMART || reader->typ == R_INTERNAL)
     513                            {
     514#else
     515                            if(reader->typ == R_MOUSE || reader->typ == R_SC8in1 || reader->typ == R_SMART)
     516                            {
     517#endif
     518                                add_job(reader->client, ACTION_READER_RESET_FAST, NULL, 0);
     519                            }
     520                            else
     521                            {
     522                                add_job(reader->client, ACTION_READER_RESTART, NULL, 0);
     523                            }
     524                            return OK; // Skip the rest of the init since the card will be reset anyway
     525                        }
     526                    }
     527                }
     528            }
     529        }
     530    }
     531    static const unsigned char ins7416[5] = { 0xD0, 0x74, 0x16, 0x00, 0x00 };
     532
     533    if(do_cmd(reader, ins7416, NULL, NULL, cta_res) < 0)
     534    {
     535        rdr_log(reader, "classD0 ins7416: failed");
     536        return ERROR;
     537    }
    442538    unsigned char boxID [4];
    443539
     
    551647    }
    552648
    553     static const unsigned char ins4C[5] = { 0xD0, 0x4C, 0x00, 0x00, 0x09 };
    554     unsigned char payload4C[9] = { 0, 0, 0, 0, 3, 0, 0, 0, 4 };
     649    unsigned char ins4C[5] = { 0xD0, 0x4C, 0x00, 0x00, 0x09 };
     650    unsigned char len4c = 0, mode = 0;
     651    unsigned char payload4C[0xF] = { 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     652    if(cmd_table_get_info(reader, ins4C, &len4c, &mode))
     653    {
     654        ins4C[4] = len4c;               //don't mind if payload is > of ins len, it will be cutted after write_cmd_vg()
     655        if(len4c > 9)
     656        {
     657            payload4C[8] = 0x44;        //value taken from v14 boot log
     658            rdr_log(reader, "Extended 4C detected");
     659        }
     660    }
     661
    555662    memcpy(payload4C, boxID, 4);
    556     if(!write_cmd_vg(ins4C, payload4C) || !status_ok(cta_res + l))
     663    if(!write_cmd_vg(ins4C, payload4C) || !status_ok(cta_res ))
    557664    {
    558665        rdr_log(reader, "classD0 ins4C: failed - sending boxid failed");
     
    572679    memcpy(reader->sa, cta_res + 3, 3);
    573680    reader->caid = cta_res[24] * 0x100 + cta_res[25];
     681    memset(reader->VgRegionC, 0, 8);
     682    memcpy(reader->VgRegionC, cta_res + 60, 8);
     683    rdr_log(reader, "Region Code: %c%c%c%c%c%c%c%c", reader->VgRegionC[0], reader->VgRegionC[1], reader->VgRegionC[2], reader->VgRegionC[3], reader->VgRegionC[4], reader->VgRegionC[5], reader->VgRegionC[6], reader->VgRegionC[7]);
    574684
    575685    /* we have one provider, 0x0000 */
     
    621731        return ERROR;
    622732    }
     733    /*new ins74 present at boot*/
     734
     735    static const unsigned char ins7423[5] = { 0xD1, 0x74, 0x23, 0x00, 0x00 };
     736    if(do_cmd(reader, ins7423, NULL, NULL, cta_res) < 0)
     737    {
     738        rdr_log(reader, "classD1 ins7423: failed");
     739    }
     740
     741    static const unsigned char ins742A[5] = { 0xD1, 0x74, 0x2A, 0x00, 0x00 };
     742    if(do_cmd(reader, ins742A, NULL, NULL, cta_res) < 0)
     743    {
     744        rdr_log(reader, "classD1 ins742A: failed");
     745    }
     746
     747    static const unsigned char ins741B[5] = { 0xD1, 0x74, 0x1B, 0x00, 0x00 };
     748    if(do_cmd(reader, ins741B, NULL, NULL, cta_res) < 0)
     749    {
     750        rdr_log(reader, "classD1 ins741B: failed");
     751    }
    623752
    624753    static const unsigned char ins4Ca[5] = { 0xD1, 0x4C, 0x00, 0x00, 0x00 };
     754    unsigned char ins741C[5] = { 0xD1, 0x74, 0x1C, 0x00, 0x00 };
     755    if(len4c > 9)
     756        {
     757            if((l = read_cmd_len(reader, ins741C)) < 0)  // We need to know the exact len
     758            {
     759                return ERROR;
     760            }
     761            ins741C[4] = l;
     762            if(do_cmd(reader, ins741C, NULL, NULL, cta_res) < 0)    //from log this payload is copied on 4c
     763            {
     764                rdr_log(reader, "classD1 ins741C: failed");
     765            }
     766            else
     767            {
     768                if(l > 8)   //if payload4c is length 0xF, we can't copy over more than 8 bytes in the next memcopy
     769                {
     770                    l = 8;
     771                }
     772                memcpy(payload4C + 8, cta_res, l);
     773            }
     774        }
    625775    l = do_cmd(reader, ins4Ca, payload4C, NULL, cta_res);
    626776    if(l < 0 || !status_ok(cta_res))
     
    640790        }
    641791    }
    642 
    643     if(reader->ins7E11[0x01])
    644     {
    645         unsigned char ins742b[5] = { 0xD0, 0x74, 0x2b, 0x00, 0x00 };
    646 
    647         l = read_cmd_len(reader, ins742b);  //get command len for ins742b
    648 
    649         if(l < 2)
    650         {
    651             rdr_log(reader, "No TA1 change for this card is possible by ins7E11");
     792    /* get PIN settings */
     793    static const unsigned char ins7411[5] = { 0xD1, 0x74, 0x11, 0x00, 0x00 };
     794    unsigned char payload2e4[4];
     795    if(do_cmd(reader, ins7411, NULL, NULL, cta_res) < 0)
     796    {
     797        rdr_log(reader, "classD1 ins7411: unable to get PIN");
     798        return ERROR;
     799    }
     800    else
     801    {
     802        memset(payload2e4, 0, 4);
     803        memcpy(payload2e4, cta_res + 2, 4);
     804        reader->VgPin = (cta_res[4] << 8) + cta_res[5];
     805        rdr_log(reader, "Pincode read: %i", reader->VgPin);
     806    }
     807
     808    /* get PCB(content rating) settings */
     809    static const unsigned char ins74e[5] = {0xD1, 0x74, 0x0E, 0x00, 0x00};
     810    if(do_cmd(reader, ins74e, NULL, NULL, cta_res) < 0)
     811    {
     812        rdr_log(reader, "classD1 ins74e: failed to get PCB settings");
     813    }
     814    else
     815    {
     816        rdr_log(reader, "PCB settings: %X %X %X %X", cta_res[2], cta_res[3], cta_res[4], cta_res[5]);
     817    }
     818
     819    /* send PIN */
     820    static const unsigned char ins2epin[5] = {0xD1, 0x2E, 0x04, 0x00, 0x04};
     821    if(cfg.ulparent)
     822    {
     823        l = do_cmd(reader, ins2epin, payload2e4, NULL, cta_res);
     824        if(l < 0 || !status_ok(cta_res))
     825        {
     826            rdr_log(reader, "classD1 ins2E: failed");
     827            rdr_log(reader, "Cannot disable parental control");
     828            return ERROR;
    652829        }
    653830        else
    654831        {
    655             ins742b[4] = l;
    656             bool ta1ok = 0;
    657 
    658             if(!write_cmd_vg(ins742b, NULL) || !status_ok(cta_res + ins742b[4]))  //get supported TA1 bytes
    659             {
    660                 rdr_log(reader, "classD0 ins742b: failed");
    661                 return ERROR;
    662             }
    663             else
    664             {
    665                 int32_t i;
    666 
    667                 for(i = 2; i < l; i++)
    668                 {
    669                     if(cta_res[i] == reader->ins7E11[0x00])
    670                     {
    671                         ta1ok = 1;
    672                         break;
    673                     }
    674                 }
    675             }
    676             if(ta1ok == 0)
    677             {
    678                 rdr_log(reader, "The value %02X of ins7E11 is not supported,try one between %02X and %02X", reader->ins7E11[0x00], cta_res[2], cta_res[ins742b[4] - 1]);
    679             }
    680             else
    681             {
    682                 static const uint8_t ins7E11[5] = { 0xD0, 0x7E, 0x11, 0x00, 0x01 };
    683 
    684                 reader->ins7e11_fast_reset = 0;
    685 
    686                 l = do_cmd(reader, ins7E11, reader->ins7E11, NULL, cta_res);
    687 
    688                 if(l < 0 || !status_ok(cta_res))
    689                 {
    690                     rdr_log(reader, "classD0 ins7E11: failed");
    691                     return ERROR;
    692                 }
    693                 else
    694                 {
    695                     unsigned char TA1;
    696 
    697                     if(ATR_GetInterfaceByte(newatr, 1, ATR_INTERFACE_BYTE_TA, &TA1) == ATR_OK)
    698                     {
    699                         if(TA1 != reader->ins7E11[0x00])
    700                         {
    701                             rdr_log(reader, "classD0 ins7E11: Scheduling card reset for TA1 change from %02X to %02X", TA1, reader->ins7E11[0x00]);
    702                             reader->ins7e11_fast_reset = 1;
    703 #ifdef WITH_COOLAPI
    704                             if(reader->typ == R_MOUSE || reader->typ == R_SC8in1 || reader->typ == R_SMART || reader->typ == R_INTERNAL)
    705                             {
    706 #else
    707                             if(reader->typ == R_MOUSE || reader->typ == R_SC8in1 || reader->typ == R_SMART)
    708                             {
    709 #endif
    710                                 add_job(reader->client, ACTION_READER_RESET_FAST, NULL, 0);
    711                             }
    712                             else
    713                             {
    714                                 add_job(reader->client, ACTION_READER_RESTART, NULL, 0);
    715                             }
    716                             return OK; // Skip the rest of the init since the card will be reset anyway
    717                         }
    718                     }
    719                 }
    720             }
    721         }
    722     }
    723 
    724     /* get parental lock settings */
    725     static const unsigned char ins74e[5] = {0xD0, 0x74, 0x0E, 0x00, 0x00};
    726     if(cmd_exists(reader, ins74e))
    727     {
    728         l = do_cmd(reader, ins74e, NULL, NULL, cta_res);
    729         if(l < 0 || !status_ok(cta_res + l))
    730         {
    731             rdr_log(reader, "classD0 ins74e: failed to get parental lock settings");
    732         }
    733         else
    734         {
    735             char tmp[l > 0 ? l * 3 : 1];
    736             rdr_log(reader, "parental lock setting: %s", cs_hexdump(1, cta_res + 2, l - 2, tmp, sizeof(tmp)));
    737         }
    738     }
    739 
    740     /* disable parental lock */
    741     static const uchar ins2e[5] = {0xD0, 0x2E, 0x00, 0x00, 0x04};
    742     static const uchar payload2e[4] = {0xFF, 0xFF, 0xFF, 0xFF};
    743     if(cfg.ulparent)
    744     {
    745         if(cmd_exists(reader, ins74e) && write_cmd_vg(ins2e, payload2e) && status_ok(cta_res + l))
    746         {
    747             rdr_log(reader, "parental lock disabled");
    748         }
    749         else
    750         {
    751             rdr_log(reader, "cannot disable parental lock");
    752         }
    753         if(cmd_exists(reader, ins74e))
    754         {
    755             l = do_cmd(reader, ins74e, NULL, NULL, cta_res);
    756             if(l < 0 || !status_ok(cta_res + l))
    757             {
    758                 rdr_log(reader, "classD0 ins74e: failed to get parental lock settings");
    759             }
    760             else
    761             {
    762                 char tmp[l > 0 ? l * 3 : 1];
    763                 rdr_log(reader, "parental lock setting after disabling: %s", cs_hexdump(1, cta_res + 2, l - 2, tmp, sizeof(tmp)));
    764             }
     832            rdr_log(reader, "Parental control disabled");
     833        }
     834    }
     835    /* send check control for pin, needed on some cards */
     836    /* the presence and the value of payloads is provider's dependent*/
     837        if(reader->ins2e06[4])
     838    {
     839        static const unsigned char ins2e06[5] = { 0xD1, 0x2E, 0x06, 0x00, 0x04 };
     840        l = do_cmd(reader, ins2e06, reader->ins2e06, NULL, cta_res);
     841        if(l < 0 || !status_ok(cta_res))
     842        {
     843            rdr_log(reader, "classD1 ins2E: failed");
     844            return ERROR;
    765845        }
    766846    }
     
    842922    if(l < 0 || !status_ok(cta_res))
    843923    {
    844         rdr_log(reader, "classD0 ins40: (%d) status not ok %02x %02x", l, cta_res[0], cta_res[1]);
     924        rdr_log(reader, "classD1 ins40: (%d) status not ok %02x %02x", l, cta_res[0], cta_res[1]);
    845925        rdr_log(reader, "The card is not answering correctly! Restarting reader for safety");
    846926        add_job(reader->client, ACTION_READER_RESTART, NULL, 0);
  • trunk/webif/entitlements/entitlements_bit.html

    r9111 r9568  
    44        <TR><TH COLSPAN="2">Serial</TH><TH COLSPAN="2">Rom</TH><TH COLSPAN="4">ATR</TH></TR>
    55        <TR CLASS="e_header"><TD COLSPAN="2">##READERSERIAL##</TD><TD COLSPAN="2">##READERROM##</TD><TD COLSPAN="4">##READERATR##</TD></TR>
     6        <TR><TH COLSPAN="3">Region Code (NDS)</TH><TH COLSPAN="2">Pin (NDS)</TH><TH COLSPAN="2">Credit (NDS)</TH></TR>
     7        <TR CLASS="e_header"><TD COLSPAN="3">##READER_RCODE##</TD><TD COLSPAN="2">##READERPIN##</TD><TD COLSPAN="2">##READERCREDIT##</TD></TR>
    68        <TR><TH>Type</TH><TH>Caid</TH><TH>Provid</TH><TH>ID</TH><TH>Class</TH><TH>Start Date</TH><TH>Expire Date</TH><TH>Name</TH></TR>
    79##READERENTENTRY##
  • trunk/webif/readerconfig/readerconfig_hwreader_videoguard.html

    r9430 r9568  
    1414                <TR><TD>##TPLHELPPREFIX##server#ins7e##TPLHELPSUFFIX##ins7E payload (26 bytes):</A></TD><TD><input name="ins7e" type="text" size="60" maxlength="56" value="##INS7E##"></TD></TR>
    1515                <TR><TD>##TPLHELPPREFIX##server#ins7e11##TPLHELPSUFFIX##ins7E11 TA1 Byte (1 byte):</A></TD><TD><input name="ins7e11" type="text" size="10" maxlength="2" value="##INS7E11##"></TD></TR>
     16                <TR><TD>##TPLHELPPREFIX##server#ins2e06##TPLHELPSUFFIX##ins2E06 payload (4 bytes):</A></TD><TD><input name="ins2e06" type="text" size="15" maxlength="8" value="##INS2E06##"></TD></TR>
Note: See TracChangeset for help on using the changeset viewer.