source: trunk/reader-irdeto.c @ 5375

Last change on this file since 5375 was 5027, checked in by _network, 8 years ago

irdeto: add possible fix for nova card

File size: 27.5 KB
Line 
1#include "globals.h"
2#include "reader-common.h"
3
4static const uchar CryptTable[256] =
5{
6  0xDA, 0x26, 0xE8, 0x72, 0x11, 0x52, 0x3E, 0x46,
7  0x32, 0xFF, 0x8C, 0x1E, 0xA7, 0xBE, 0x2C, 0x29,
8  0x5F, 0x86, 0x7E, 0x75, 0x0A, 0x08, 0xA5, 0x21,
9  0x61, 0xFB, 0x7A, 0x58, 0x60, 0xF7, 0x81, 0x4F,
10  0xE4, 0xFC, 0xDF, 0xB1, 0xBB, 0x6A, 0x02, 0xB3,
11  0x0B, 0x6E, 0x5D, 0x5C, 0xD5, 0xCF, 0xCA, 0x2A,
12  0x14, 0xB7, 0x90, 0xF3, 0xD9, 0x37, 0x3A, 0x59,
13  0x44, 0x69, 0xC9, 0x78, 0x30, 0x16, 0x39, 0x9A,
14  0x0D, 0x05, 0x1F, 0x8B, 0x5E, 0xEE, 0x1B, 0xC4,
15  0x76, 0x43, 0xBD, 0xEB, 0x42, 0xEF, 0xF9, 0xD0,
16  0x4D, 0xE3, 0xF4, 0x57, 0x56, 0xA3, 0x0F, 0xA6,
17  0x50, 0xFD, 0xDE, 0xD2, 0x80, 0x4C, 0xD3, 0xCB,
18  0xF8, 0x49, 0x8F, 0x22, 0x71, 0x84, 0x33, 0xE0,
19  0x47, 0xC2, 0x93, 0xBC, 0x7C, 0x3B, 0x9C, 0x7D,
20  0xEC, 0xC3, 0xF1, 0x89, 0xCE, 0x98, 0xA2, 0xE1,
21  0xC1, 0xF2, 0x27, 0x12, 0x01, 0xEA, 0xE5, 0x9B,
22  0x25, 0x87, 0x96, 0x7B, 0x34, 0x45, 0xAD, 0xD1,
23  0xB5, 0xDB, 0x83, 0x55, 0xB0, 0x9E, 0x19, 0xD7,
24  0x17, 0xC6, 0x35, 0xD8, 0xF0, 0xAE, 0xD4, 0x2B,
25  0x1D, 0xA0, 0x99, 0x8A, 0x15, 0x00, 0xAF, 0x2D,
26  0x09, 0xA8, 0xF5, 0x6C, 0xA1, 0x63, 0x67, 0x51,
27  0x3C, 0xB2, 0xC0, 0xED, 0x94, 0x03, 0x6F, 0xBA,
28  0x3F, 0x4E, 0x62, 0x92, 0x85, 0xDD, 0xAB, 0xFE,
29  0x10, 0x2E, 0x68, 0x65, 0xE7, 0x04, 0xF6, 0x0C,
30  0x20, 0x1C, 0xA9, 0x53, 0x40, 0x77, 0x2F, 0xA4,
31  0xFA, 0x6D, 0x73, 0x28, 0xE2, 0xCD, 0x79, 0xC8,
32  0x97, 0x66, 0x8E, 0x82, 0x74, 0x06, 0xC7, 0x88,
33  0x1A, 0x4A, 0x6B, 0xCC, 0x41, 0xE9, 0x9D, 0xB8,
34  0x23, 0x9F, 0x3D, 0xBF, 0x8D, 0x95, 0xC5, 0x13,
35  0xB9, 0x24, 0x5A, 0xDC, 0x64, 0x18, 0x38, 0x91,
36  0x7F, 0x5B, 0x70, 0x54, 0x07, 0xB6, 0x4B, 0x0E,
37  0x36, 0xAC, 0x31, 0xE6, 0xD6, 0x48, 0xAA, 0xB4
38};
39
40static const uchar
41  sc_GetCountryCode[] = { 0x02, 0x02, 0x03, 0x00, 0x00 };
42
43static const uchar
44  sc_GetCountryCode2[]= { 0x02, 0x0B, 0x00, 0x00, 0x00 },
45  sc_GetCamKey384CZ[] = { 0x02, 0x09, 0x03, 0x00, 0x40, 
46                          0x18, 0xD7, 0x55, 0x14, 0xC0, 0x83, 0xF1, 0x38, 
47                          0x39, 0x6F, 0xF2, 0xEC, 0x4F, 0xE3, 0xF1, 0x85, 
48                          0x01, 0x46, 0x06, 0xCE, 0x7D, 0x08, 0x2C, 0x74, 
49                          0x46, 0x8F, 0x72, 0xC4, 0xEA, 0xD7, 0x9C, 0xE0, 
50                          0xE1, 0xFF, 0x58, 0xE7, 0x70, 0x0C, 0x92, 0x45, 
51                          0x26, 0x18, 0x4F, 0xA0, 0xE2, 0xF5, 0x9E, 0x46, 
52                          0x6F, 0xAE, 0x95, 0x35, 0xB0, 0x49, 0xB2, 0x0E, 
53                          0xA4, 0x1F, 0x8E, 0x47, 0xD0, 0x24, 0x11, 0xD0 },
54  sc_GetCamKey384DZ[] = { 0x02, 0x09, 0x03, 0x00, 0x40, 
55                          0x27, 0xF2, 0xD6, 0xCD, 0xE6, 0x88, 0x62, 0x46, 
56                          0x81, 0xB0, 0xF5, 0x3E, 0x6F, 0x13, 0x4D, 0xCC, 
57                          0xFE, 0xD0, 0x67, 0xB1, 0x93, 0xDD, 0xF4, 0xDE, 
58                          0xEF, 0xF5, 0x3B, 0x04, 0x1D, 0xE5, 0xC3, 0xB2, 
59                          0x54, 0x38, 0x57, 0x7E, 0xC8, 0x39, 0x07, 0x2E, 
60                          0xD2, 0xF4, 0x05, 0xAA, 0x15, 0xB5, 0x55, 0x24, 
61                          0x90, 0xBB, 0x9B, 0x00, 0x96, 0xF0, 0xCB, 0xF1, 
62                          0x8A, 0x08, 0x7F, 0x0B, 0xB8, 0x79, 0xC3, 0x5D },
63  sc_GetCamKey384FZ[] = { 0x02, 0x09, 0x03, 0x00, 0x40,
64                          0x62, 0xFE, 0xD8, 0x4F, 0x44, 0x86, 0x2C, 0x21,
65                          0x50, 0x9A, 0xBE, 0x27, 0x15, 0x9E, 0xC4, 0x48,
66                          0xF3, 0x73, 0x5C, 0xBD, 0x08, 0x64, 0x6D, 0x13,
67                          0x64, 0x90, 0x14, 0xDB, 0xFF, 0xC3, 0xFE, 0x03,
68                          0x97, 0xFA, 0x75, 0x08, 0x12, 0xF9, 0x8F, 0x84,
69                          0x83, 0x17, 0xAA, 0x6F, 0xEF, 0x2C, 0x10, 0x1B,
70                          0xBF, 0x31, 0x41, 0xC3, 0x54, 0x2F, 0x65, 0x50, 
71                          0x95, 0xA9, 0x64, 0x22, 0x5E, 0xA4, 0xAF, 0xA9 };
72
73/* some variables for acs57 (Dahlia for ITA dvb-t) */
74#define ACS57EMM  0xD1
75#define ACS57ECM  0xD5
76#define ACS57GET  0xD2
77/* end define */
78
79typedef struct chid_base_date {
80    uint16_t caid;
81    uint16_t acs;
82    char c_code[4];
83    uint32_t base;
84} CHID_BASE_DATE;
85
86static void XRotateLeft8Byte(uchar *buf)
87{
88  int32_t k;
89  uchar t1=buf[7];
90  uchar t2=0;
91  for(k=0; k<=7; k++)
92  {
93    t2=t1;
94    t1=buf[k];
95    buf[k]=(buf[k]<<1)|(t2>>7);
96  }
97}
98
99static void ReverseSessionKeyCrypt(const uchar *camkey, uchar *key)
100{
101  uchar localkey[8], tmp1, tmp2;
102  int32_t idx1,idx2;
103
104  memcpy(localkey, camkey, 8) ;
105  for(idx1=0; idx1<8; idx1++)
106  {
107    for(idx2=0; idx2<8; idx2++)
108    {
109      tmp1 = CryptTable[key[7] ^ localkey[idx2] ^ idx1] ;
110      tmp2 = key[0] ;
111      key[0] = key[1] ;
112      key[1] = key[2] ;
113      key[2] = key[3] ;
114      key[3] = key[4] ;
115      key[4] = key[5] ;
116      key[5] = key[6] ^ tmp1 ;
117      key[6] = key[7] ;
118      key[7] = tmp1 ^ tmp2 ;
119    }
120    XRotateLeft8Byte(localkey);
121  } 
122}
123
124static time_t chid_date(struct s_reader * reader, uint32_t date, char *buf, int32_t l)
125{
126
127    // Irdeto date starts 01.08.1997 which is
128    // 870393600 seconds in unix calendar time
129    //
130    // The above might not be true for all Irdeto card
131    // we need to find a way to identify cards to set the base date
132    // like we did for NDS
133    //
134    // this is the known default value.
135    uint32_t date_base=870393600L; // this is actually 31.07.1997, 17:00
136                                // CAID, ACS, Country, base date       D . M.   Y, h : m
137    CHID_BASE_DATE table[] = { {0x0604, 0x1541, "GRC", 977817600L}, // 26.12.2000, 00:00
138                            {0x0604, 0x1542, "GRC", 977817600L},    // 26.12.2000, 00:00
139                            {0x0604, 0x1543, "GRC", 977817600L},    // 26.12.2000, 00:00
140                            {0x0604, 0x1544, "GRC", 977817600L},    // 26.12.2000, 17:00
141                            {0x0628, 0x0606, "MCR", 1159574400L},   // 29.09.2006, 00:00
142                            {0x0604, 0x0608, "EGY", 999993600L},    // 08.09.2001, 17:00
143                            {0x0604, 0x0606, "EGY", 1003276800L},   // 16.10.2001, 17:00
144                            {0x0627, 0x0608, "EGY", 946598400L},    // 30.12.1999, 16:00
145                            {0x0662, 0x0608, "ITA", 944110500L},    // 01.12.1999, 23.55
146                            {0x0664, 0x0608, "TUR", 946598400L},    // 31.12.1999, 00:00
147                            {0x0624, 0x0006, "CZE", 946598400L},    // 30.12.1999, 16:00    //skyklink irdeto
148                            {0x0624, 0x0006, "SVK", 946598400L},    // 30.12.1999, 16:00    //skyklink irdeto
149                            // {0x1702, 0x0384, "AUT", XXXXXXXXXL},     // -> we need the base date for this
150                            // {0x1702, 0x0384, "GER", 888883200L},     // 02.03.1998, 16:00 -> this fixes some card but break others (S02).
151                            {0x0, 0x0, "", 0L}
152                            };
153
154    // now check for specific providers base date
155    int32_t i=0;
156    while(table[i].caid) {
157        if(reader->caid==table[i].caid && reader->acs==table[i].acs && !memcmp(reader->country_code,table[i].c_code,3) ) {
158            date_base = table[i].base;
159            break;
160        }
161        i++;
162    }
163
164    time_t ut=date_base+date*(24*3600); 
165    if (buf) {
166        struct tm *t;
167        t=gmtime(&ut);
168        snprintf(buf, l, "%04d/%02d/%02d", t->tm_year+1900, t->tm_mon+1, t->tm_mday);
169    }
170    return(ut);
171}
172
173static int32_t irdeto_do_cmd(struct s_reader * reader, uchar *buf, uint16_t good, uchar * cta_res, uint16_t * p_cta_lr)
174{
175    int32_t rc;
176    if( (rc = reader_cmd2icc(reader, buf, buf[4] + 5, cta_res, p_cta_lr)) )
177        return(rc);         // result may be 0 (success) or negative
178    if (*p_cta_lr < 2)
179        return(0x7F7F);     // this should never happen
180    return(good != b2i(2, cta_res+*p_cta_lr-2));
181}
182
183#define reader_chk_cmd(cmd, l) \
184{ \
185        if (reader_cmd2icc(reader, cmd, sizeof(cmd), cta_res, &cta_lr)) return ERROR; \
186  if (l && (cta_lr!=l)) return ERROR; }
187
188static int32_t irdeto_card_init_provider(struct s_reader * reader)
189{
190    def_resp;
191    int32_t i, p;
192    uchar buf[256] = {0};
193
194    uchar sc_GetProvider[]    = { 0x02, 0x03, 0x03, 0x00, 0x00 };
195    uchar sc_Acs57Prov[]    = { 0xD2, 0x06, 0x03, 0x00, 0x01, 0x3C };
196    uchar sc_Acs57_Cmd[]    = { ACS57GET, 0xFE, 0x00, 0x00, 0x00 };
197    /*
198     * Provider
199     */
200    memset(reader->prid, 0xff, sizeof(reader->prid));
201    for (buf[0] = i = p = 0; i<reader->nprov; i++)
202    {
203        int32_t acspadd = 0;
204        if(reader->acs57==1){
205                acspadd=8;
206                sc_Acs57Prov[3]=i;
207                irdeto_do_cmd(reader, sc_Acs57Prov, 0x9021, cta_res, &cta_lr);
208                int32_t acslength = cta_res[cta_lr-1];
209            sc_Acs57_Cmd[4]=acslength;   
210                reader_chk_cmd(sc_Acs57_Cmd, acslength+2);
211                sc_Acs57Prov[5]++;
212                sc_Acs57_Cmd[3]++;
213        } else {
214            sc_GetProvider[3] = i;
215            reader_chk_cmd(sc_GetProvider, 0);
216        }
217        //if ((cta_lr==26) && (cta_res[0]!=0xf))
218        if (((cta_lr == 26) && ((!(i&1)) || (cta_res[0] != 0xf))) || (reader->acs57==1))
219        {
220            reader->prid[i][4] = p++;
221
222            // maps the provider id for Betacrypt from FFFFFF to 000000,
223            // fixes problems with cascading CCcam and OSCam
224            if ((reader->caid >= 0x1700) && (reader->caid <= 0x1799))
225                memset(&reader->prid[i][0], 0, 4);
226            else
227                memcpy(&reader->prid[i][0], cta_res+acspadd, 4);
228
229            snprintf((char *) buf+strlen((char *)buf), sizeof(buf)-strlen((char *)buf), ",%06x", b2i(3, &reader->prid[i][1]));
230        }
231        else
232            reader->prid[i][0] = 0xf;
233    }
234    if (p)
235        cs_ri_log(reader, "active providers: %d (%s)", p, buf + 1);
236
237    return OK;
238}
239
240
241
242static int32_t irdeto_card_init(struct s_reader * reader, ATR newatr)
243{
244    def_resp;
245    get_atr;
246    int32_t camkey = 0;
247    uchar buf[256] = {0};
248    uchar sc_GetCamKey383C[]  = { 0x02, 0x09, 0x03, 0x00, 0x40,
249                          0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
250                          0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
251                          0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
252                          0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF,
253                          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
254                          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
255                          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
256                          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
257
258    uchar   sc_GetASCIISerial[] = { 0x02, 0x00, 0x03, 0x00, 0x00 },
259        sc_GetHEXSerial[]   = { 0x02, 0x01, 0x00, 0x00, 0x00 },
260        sc_GetCardFile[]    = { 0x02, 0x0E, 0x02, 0x00, 0x00 };
261
262
263    uchar   sc_Acs57CamKey[70]  = { 0xD2, 0x12, 0x03, 0x00, 0x41},
264        sc_Acs57Country[] = { 0xD2, 0x04, 0x00, 0x00, 0x01, 0x3E },
265        sc_Acs57Ascii[]   = { 0xD2, 0x00, 0x03, 0x00, 0x01, 0x3F },
266        sc_Acs57Hex[]     = { 0xD2, 0x02, 0x03, 0x00, 0x01, 0x3E },
267        sc_Acs57CFile[]   = { 0xD2, 0x1C, 0x02, 0x00, 0x01, 0x30 },
268        sc_Acs57_Cmd[]    = { ACS57GET, 0xFE, 0x00, 0x00, 0x00 };
269
270    int32_t acspadd = 0;
271    if (!memcmp(atr+4, "IRDETO", 6))
272        reader->acs57=0;
273    else {
274        if((!memcmp(atr+5, "IRDETO", 6 ) || (atr[6]==0xC4 && atr[9]==0x8F && atr[10]==0xF1)) && reader->force_irdeto) {
275            reader->acs57=1;
276            acspadd=8;
277            cs_ri_log(reader, "Hist. Bytes: %s",atr+5);
278        } else {
279            return ERROR;
280        }
281    }
282    cs_ri_log(reader, "detect irdeto card");
283    if(check_filled(reader->rsa_mod, 64) > 0 && (!reader->force_irdeto || reader->acs57)) // we use rsa from config as camkey
284    {
285        cs_debug_mask(D_READER, "[irdeto-reader] using camkey data from config");
286        cs_debug_mask(D_READER, "[irdeto-reader]      camkey: %s", cs_hexdump (0, reader->nagra_boxkey, 8));
287        if (reader->acs57==1) {
288            memcpy(&sc_Acs57CamKey[5], reader->rsa_mod, 0x40);
289            cs_debug_mask(D_READER, "[irdeto-reader] camkey-data: %s", cs_hexdump (0, &sc_Acs57CamKey[5], 32));
290            cs_debug_mask(D_READER, "[irdeto-reader] camkey-data: %s", cs_hexdump (0, &sc_Acs57CamKey[37], 32));
291        } else {
292            memcpy(&sc_GetCamKey383C[5], reader->rsa_mod, 0x40);
293            cs_debug_mask(D_READER, "[irdeto-reader] camkey-data: %s", cs_hexdump (0, &sc_GetCamKey383C[5], 32));
294            cs_debug_mask(D_READER, "[irdeto-reader] camkey-data: %s", cs_hexdump (0, &sc_GetCamKey383C[37], 32));
295        }
296    } else {
297        if(reader->acs57==1) {
298            cs_log("WARNING: ACS57 card can require the CamKey from config");
299        } else {
300            memcpy(reader->nagra_boxkey, "\x11\x22\x33\x44\x55\x66\x77\x88", 8);
301        }
302    }
303
304    /*
305     * ContryCode
306     */
307    if(reader->acs57==1) {
308        irdeto_do_cmd(reader, sc_Acs57Country, 0x9019, cta_res, &cta_lr);
309        int32_t acslength=cta_res[cta_lr-1];
310        sc_Acs57_Cmd[4]=acslength;
311        reader_chk_cmd(sc_Acs57_Cmd, acslength+2);
312    } else {
313        reader_chk_cmd(sc_GetCountryCode, 18);
314    }
315    reader->acs = (cta_res[0+acspadd] << 8) | cta_res[1+acspadd];
316    reader->caid = (cta_res[5+acspadd] << 8) | cta_res[6+acspadd];
317    memcpy(reader->country_code,cta_res + 13 + acspadd, 3);
318    cs_ri_log(reader, "caid: %04X, acs: %x.%02x, country code: %c%c%c",
319            reader->caid, cta_res[0+acspadd], cta_res[1+acspadd], cta_res[13+acspadd], cta_res[14+acspadd], cta_res[15+acspadd]);
320
321    /*
322     * Ascii/Hex-Serial
323     */
324    if(reader->acs57==1) {
325        irdeto_do_cmd(reader, sc_Acs57Ascii, 0x901D, cta_res, &cta_lr);
326        int32_t acslength=cta_res[cta_lr-1];
327        sc_Acs57_Cmd[4]=acslength;
328        reader_chk_cmd(sc_Acs57_Cmd, acslength+2);   
329    } else {
330        reader_chk_cmd(sc_GetASCIISerial, 22);
331    }
332    memcpy(buf, cta_res+acspadd, 10);
333    buf[10] = 0;
334    if(reader->acs57==1) {
335        irdeto_do_cmd(reader, sc_Acs57Hex, 0x903E, cta_res, &cta_lr);
336        int32_t acslength=cta_res[cta_lr-1];
337        sc_Acs57_Cmd[4]=acslength;
338        reader_chk_cmd(sc_Acs57_Cmd, acslength+2);   
339    } else {
340        reader_chk_cmd(sc_GetHEXSerial, 18);
341    }
342    reader->nprov = cta_res[10+acspadd];
343    if (reader->caid==0x0624) {
344        memcpy(reader->hexserial, cta_res+12+acspadd, 4);
345        cs_ri_log(reader, "providers: %d, ascii serial: %s, hex serial: %02X%02X%02X, hex base: %02X",
346            reader->nprov, buf, cta_res[20], cta_res[21], cta_res[22], cta_res[23]);
347    } else {
348        memcpy(reader->hexserial, cta_res+12+acspadd, 8);
349        cs_ri_log(reader, "providers: %d, ascii serial: %s, hex serial: %02X%02X%02X, hex base: %02X",
350            reader->nprov, buf, cta_res[12], cta_res[13], cta_res[14], cta_res[15]);
351    }
352
353    /*
354     * CardFile
355     */
356    if(reader->acs57==1) {
357        irdeto_do_cmd(reader, sc_Acs57CFile, 0x9049, cta_res, &cta_lr);
358        int32_t acslength=cta_res[cta_lr-1];
359        sc_Acs57_Cmd[4]=acslength;
360        reader_chk_cmd(sc_Acs57_Cmd, acslength+2);
361        sc_Acs57CFile[2]=0x03;sc_Acs57CFile[5]++;
362        irdeto_do_cmd(reader, sc_Acs57CFile, 0x9049, cta_res, &cta_lr);
363        acslength=cta_res[cta_lr-1];
364        sc_Acs57_Cmd[4]=acslength;
365        sc_Acs57_Cmd[2]=0x03;
366        reader_chk_cmd(sc_Acs57_Cmd, acslength+2);
367        sc_Acs57_Cmd[2]=0x00;
368    } else {
369        for (sc_GetCardFile[2] = 2; sc_GetCardFile[2] < 4; sc_GetCardFile[2]++)
370            reader_chk_cmd(sc_GetCardFile, 0);
371    }
372
373    /*
374     * CamKey
375     */
376    if (((atr[14] == 0x03) && (atr[15] == 0x84) && (atr[16] == 0x55)) || (((atr[14]==0x53) && (atr[15]==0x20) && (atr[16]==0x56))))
377    {
378        switch (reader->caid)
379        {
380        case 0x1702: camkey = 1; break;
381        case 0x1722: camkey = 2; break;
382        case 0x1762: camkey = 3; break;
383        case 0x0624: camkey = 4; break;
384        default    : camkey = 5; break;
385        }
386    }
387
388    cs_debug_mask(D_READER, "[irdeto-reader] set camkey for type=%d", camkey);
389
390    switch (camkey)
391    {
392    case 1:
393        reader_chk_cmd(sc_GetCamKey384CZ, 10);
394        break;
395    case 2:
396        reader_chk_cmd(sc_GetCamKey384DZ, 10);
397        break;
398    case 3:
399        reader_chk_cmd(sc_GetCamKey384FZ, 10);
400        break;
401    case 4:
402        {
403            int32_t i,crc=61;
404            crc^=0x01, crc^=0x02, crc^=0x09;
405            crc^=sc_Acs57CamKey[2], crc^=sc_Acs57CamKey[3], crc^=(sc_Acs57CamKey[4]+1);
406            for(i=5;i<(int)sizeof(sc_Acs57CamKey);i++)
407                crc^=sc_Acs57CamKey[i];
408            sc_Acs57CamKey[69]=crc;
409            irdeto_do_cmd(reader, sc_Acs57CamKey, 0x9012, cta_res, &cta_lr);
410            int32_t acslength=cta_res[cta_lr-1];
411            sc_Acs57_Cmd[4]=acslength;
412            reader_chk_cmd(sc_Acs57_Cmd, acslength+2);
413        }
414        break;
415    default:
416        if(reader->acs57==1) {
417            int32_t i, crc=0x76;
418            for(i=6;i<(int)sizeof(sc_Acs57CamKey)-1;i++)
419                crc^=sc_Acs57CamKey[i];
420            sc_Acs57CamKey[69]=crc;
421            irdeto_do_cmd(reader, sc_Acs57CamKey, 0x9012, cta_res, &cta_lr);
422            int32_t acslength=cta_res[cta_lr-1];
423            sc_Acs57_Cmd[4]=acslength;
424            reader_chk_cmd(sc_Acs57_Cmd, acslength+2);
425        } else {
426            reader_chk_cmd(sc_GetCamKey383C, 0);
427        }
428        break;
429    }
430    if (reader->cardmhz != 600)
431        cs_log("WARNING: For Irdeto cards you will have to set 'cardmhz = 600' in oscam.server");
432
433    return irdeto_card_init_provider(reader);
434}
435
436int32_t irdeto_do_ecm(struct s_reader * reader, ECM_REQUEST *er)
437{
438    def_resp; cta_lr = 0; //suppress compiler error
439    static const uchar sc_EcmCmd[] = { 0x05, 0x00, 0x00, 0x02, 0x00 };
440    uchar sc_Acs57Ecm[] = {0xD5, 0x00, 0x00, 0x02, 0x00};
441    uchar sc_Acs57_Cmd[]={ ACS57ECM, 0xFE, 0x00, 0x00, 0x00 };
442    uchar cta_cmd[272];
443
444    int32_t i=0, acspadd=0; 
445    if(reader->acs57==1) {
446        int32_t crc=63;
447        sc_Acs57Ecm[4]=er->ecm[2]-2;
448        sc_Acs57Ecm[2]=er->ecm[6];
449        crc^=0x01;crc^=0x05;crc^=sc_Acs57Ecm[2];crc^=sc_Acs57Ecm[3];crc^=(sc_Acs57Ecm[4]-1);
450        for(i=6;i<er->ecm[3]-5;i++)
451            crc^=er->ecm[i];
452        memcpy(cta_cmd,sc_Acs57Ecm,6);
453        memcpy(cta_cmd+5,er->ecm+6,er->ecm[2]-1); 
454        cta_cmd[er->ecm[2]+2]=crc;
455        irdeto_do_cmd(reader, cta_cmd, 0, cta_res, &cta_lr);
456        int32_t acslength=cta_res[cta_lr-1];
457        // If acslength != 0x1F you don't have the entitlements or you camkey is bad
458        if(acslength!=0x1F){
459            switch(acslength){
460                case 0x09:
461                    cs_log("[reader-irdeto] Maybe you don't have the entitlements for this channel");
462                    break;
463                default:
464                    cs_log("[reader-irdeto] Maybe you have a bad Cam Key set it from config file");
465                    break;
466            }
467            return ERROR; 
468        }
469        sc_Acs57_Cmd[4]=acslength;
470        cta_lr=0;
471        reader_chk_cmd(sc_Acs57_Cmd, acslength+2);
472        acspadd=8;
473    }else{
474        memcpy(cta_cmd, sc_EcmCmd, sizeof(sc_EcmCmd));
475        cta_cmd[4] = (er->ecm[2]) - 3;
476        memcpy(cta_cmd + sizeof(sc_EcmCmd), &er->ecm[6], cta_cmd[4]);
477
478        int32_t try = 1;
479        int32_t ret;
480        do {
481            if (try >1)
482                snprintf( er->msglog, MSGLOGSIZE, "%s irdeto_do_cmd try nr %i", reader->label, try);
483            ret = (irdeto_do_cmd(reader, cta_cmd, 0x9D00, cta_res, &cta_lr));
484            ret = ret || (cta_lr < 24);
485            if (ret)
486                    snprintf( er->msglog, MSGLOGSIZE, "%s irdeto_do_cmd [%d] %02x %02x", reader->label, cta_lr, cta_res[cta_lr - 2], cta_res[cta_lr - 1] );
487            try++;
488        } while ((try < 3) && (ret));
489        if (ret)
490            return ERROR;
491    }
492    ReverseSessionKeyCrypt(reader->nagra_boxkey, cta_res+6+acspadd);
493    ReverseSessionKeyCrypt(reader->nagra_boxkey, cta_res+14+acspadd);
494    memcpy(er->cw, cta_res + 6 + acspadd, 16);
495    return OK;
496}
497
498static int32_t irdeto_get_emm_type(EMM_PACKET *ep, struct s_reader * rdr) {
499
500    int32_t i, l = (ep->emm[3]&0x07);
501    int32_t base = (ep->emm[3]>>3);
502    char dumprdrserial[l*3];
503
504    cs_debug_mask(D_EMM, "Entered irdeto_get_emm_type ep->emm[3]=%02x",ep->emm[3]);
505
506    switch (l) {
507
508        case 0:
509            // global emm, 0 bytes addressed
510            ep->type = GLOBAL;
511            cs_debug_mask(D_EMM, "IRDETO EMM: GLOBAL");
512            return TRUE;
513
514        case 2:
515            // shared emm, 2 bytes addressed
516            ep->type = SHARED;
517            memset(ep->hexserial, 0, 8);
518            memcpy(ep->hexserial, ep->emm + 4, l);
519            cs_strncpy(dumprdrserial, cs_hexdump(1, rdr->hexserial, l), sizeof(dumprdrserial));
520            cs_debug_mask(D_EMM, "IRDETO EMM: SHARED l = %d ep = %s rdr = %s base = %02x", l, 
521                    cs_hexdump(1, ep->hexserial, l), dumprdrserial, base);
522
523            if (base & 0x10) {
524                // hex addressed
525                return (base == rdr->hexserial[3] && !memcmp(ep->emm + 4, rdr->hexserial, l));
526            }
527            else {
528                // not hex addressed and emm mode zero
529                if (base == 0)
530                    return TRUE;
531
532                // provider addressed
533                for(i = 0; i < rdr->nprov; i++)
534                    if (base == rdr->prid[i][0] && !memcmp(ep->emm + 4, &rdr->prid[i][1], l))
535                        return TRUE;
536            }
537            cs_debug_mask(D_EMM, "IRDETO EMM: neither hex nor provider addressed or unknown provider id");
538            return FALSE;
539
540        case 3:
541            // unique emm, 3 bytes addressed
542            ep->type = UNIQUE;
543            memset(ep->hexserial, 0, 8);
544            memcpy(ep->hexserial, ep->emm + 4, l);
545            cs_strncpy(dumprdrserial, cs_hexdump(1, rdr->hexserial, l), sizeof(dumprdrserial));
546            cs_debug_mask(D_EMM, "IRDETO EMM: UNIQUE l = %d ep = %s rdr = %s", l, 
547                    cs_hexdump(1, ep->hexserial, l), dumprdrserial);
548
549            return (base == rdr->hexserial[3] && !memcmp(ep->emm + 4, rdr->hexserial, l));
550
551        default:
552            ep->type = UNKNOWN;
553            cs_debug_mask(D_EMM, "IRDETO EMM: UNKNOWN");
554            return TRUE;
555    }
556
557}
558
559static void irdeto_get_emm_filter(struct s_reader * rdr, uchar *filter)
560{
561    int32_t idx = 2;
562
563    filter[0]=0xFF;
564    filter[1]=0;        //filter count
565
566    int32_t base = rdr->hexserial[3];
567    int32_t emm_g = base * 8;
568    int32_t emm_s = emm_g + 2;
569    int32_t emm_u = emm_g + 3;
570
571
572    filter[idx++]=EMM_GLOBAL;
573    filter[idx++]=0;
574    filter[idx+0]    = 0x82;
575    filter[idx+0+16] = 0xFF;
576    filter[idx+1]    = emm_g;
577    filter[idx+1+16] = 0xFF;
578    filter[1]++;
579    idx += 32;
580
581    filter[idx++]=EMM_GLOBAL;
582    filter[idx++]=0;
583    filter[idx+0]    = 0x82;
584    filter[idx+16]   = 0xFF;
585    filter[idx+1]    = 0x81;
586    filter[idx+1+16] = 0xFF;
587    memcpy(filter+idx+2, rdr->hexserial, 1);
588    memset(filter+idx+2+16, 0xFF, 1);
589    filter[1]++;
590    idx += 32;
591
592    filter[idx++]=EMM_UNIQUE;
593    filter[idx++]=0;
594    filter[idx+0]    = 0x82;
595    filter[idx+0+16] = 0xFF;
596    filter[idx+1]    = emm_u;
597    filter[idx+1+16] = 0xFF;
598    memcpy(filter+idx+2, rdr->hexserial, 3);
599    memset(filter+idx+2+16, 0xFF, 3);
600    filter[1]++;
601    idx += 32;
602   
603    filter[idx++]=EMM_SHARED;
604    filter[idx++]=0;
605    filter[idx+0]    = 0x82;
606    filter[idx+0+16] = 0xFF;
607    filter[idx+1]    = emm_s;
608    filter[idx+1+16] = 0xFF;
609    memcpy(filter+idx+2, rdr->hexserial, 2);
610    memset(filter+idx+2+16, 0xFF, 2);
611    filter[1]++;
612    idx += 32;
613
614    int32_t i;
615    for(i = 0; i < rdr->nprov; i++) {
616        if (rdr->prid[i][1]==0xFF)
617            continue;
618
619        filter[idx++]=EMM_SHARED;
620        filter[idx++]=0;
621        filter[idx+0]    = 0x82;
622        filter[idx+0+16] = 0xFF;
623        // filter[idx+1]    = 0x02; // base = 0, len = 2
624        // filter[idx+1+16] = 0xFF;
625        memcpy(filter+idx+2, &rdr->prid[i][1], 2);
626        memset(filter+idx+2+16, 0xFF, 2);
627        filter[1]++;
628        idx += 32;
629
630        if (filter[1]>=10) {
631            cs_log("irdeto_get_emm_filter: could not start all emm filter");
632            break;
633        }
634    }
635
636    return;
637}
638
639static int32_t irdeto_do_emm(struct s_reader * reader, EMM_PACKET *ep)
640{
641    def_resp;
642    static const uchar sc_EmmCmd[] = { 0x01,0x00,0x00,0x00,0x00 };
643    static uchar sc_Acs57Emm[] = { 0xD1,0x00,0x00,0x00,0x00 };
644    uchar sc_Acs57_Cmd[]={ ACS57EMM, 0xFE, 0x00, 0x00, 0x00 };
645
646    uchar cta_cmd[272];
647
648    int32_t i, l = (ep->emm[3] & 0x07), ok = 0;
649    int32_t mode = (ep->emm[3] >> 3);
650    uchar *emm = ep->emm;
651
652    if (reader->caid == 0x0604 && ep->emm[2] != 0x38 && ep->emm[2] != 0x3F)
653        return ERROR;
654
655    if (mode & 0x10) {
656        // hex addressed
657        ok = (mode == reader->hexserial[3] && (!l || !memcmp(&emm[4], reader->hexserial, l)));
658    }
659    else {
660        // not hex addressed and emm mode zero
661        if (mode == 0)
662            ok = 1;
663        else {
664            // provider addressed
665            for(i = 0; i < reader->nprov; i++) {
666                ok = (mode == reader->prid[i][0] && (!l || !memcmp(&emm[4], &reader->prid[i][1], l)));
667                if (ok) break;
668            }
669        }
670    }
671
672    if (ok) {
673        l++;
674        if (l <= ADDRLEN) {
675            if(reader->acs57==1) {
676                int32_t dataLen=0;
677                if(ep->type==UNIQUE){
678                    dataLen=ep->emm[2]-1;
679                }else{
680                    dataLen=ep->emm[2];
681                }
682                if (ep->type==GLOBAL && reader->caid==0x0624) dataLen+=2;
683                int32_t crc=63;
684                sc_Acs57Emm[4]=dataLen;
685                memcpy(&cta_cmd, sc_Acs57Emm, sizeof(sc_Acs57Emm));
686                crc^=0x01;crc^=0x01;crc^=0x00;crc^=0x00;crc^=0x00;crc^=(dataLen-1);
687                memcpy(&cta_cmd[5],&ep->emm[3],10);
688                if (ep->type==UNIQUE) {
689                    memcpy(&cta_cmd[9],&ep->emm[9],dataLen-4);
690                } else {
691                    if (ep->type==GLOBAL && reader->caid==0x0624) {
692                        memcpy(&cta_cmd[9],&ep->emm[6],1);
693                        memcpy(&cta_cmd[10],&ep->emm[7],dataLen-6);                 
694//                      cta_cmd[9]=0x00;
695                    } else {
696                        memcpy(&cta_cmd[10],&ep->emm[9],dataLen-6);
697                    }
698                }
699                int32_t i=0;
700                for(i=5;i<dataLen+4;i++)
701                    crc^=cta_cmd[i];
702                cta_cmd[dataLen-1+5]=crc;
703                irdeto_do_cmd(reader, cta_cmd, 0, cta_res, &cta_lr);
704                int32_t acslength=cta_res[cta_lr-1];
705                sc_Acs57_Cmd[4]=acslength;
706                reader_chk_cmd(sc_Acs57_Cmd, acslength+2);
707                return OK;
708            } else {
709                const int32_t dataLen = SCT_LEN(emm) - 5 - l;       // sizeof of emm bytes (nanos)
710                uchar *ptr = cta_cmd;
711                memcpy(ptr, sc_EmmCmd, sizeof(sc_EmmCmd));      // copy card command
712                ptr[4] = dataLen + ADDRLEN;                     // set card command emm size
713                ptr += sizeof(sc_EmmCmd); emm += 3;
714                memset(ptr, 0, ADDRLEN);                        // clear addr range
715                memcpy(ptr, emm, l);                            // copy addr bytes
716                ptr += ADDRLEN; emm += l;
717                memcpy(ptr, &emm[2], dataLen);                  // copy emm bytes
718                return(irdeto_do_cmd(reader, cta_cmd, 0, cta_res, &cta_lr) ? 0 : 1);
719            }
720        } else
721            cs_debug_mask(D_EMM, "[irdeto-reader] addrlen %d > %d", l, ADDRLEN);
722    }
723    return ERROR;
724}
725
726static int32_t irdeto_card_info(struct s_reader * reader)
727{
728  def_resp;
729  int32_t i, p;
730
731    uchar   sc_GetChanelIds[] = { 0x02, 0x04, 0x00, 0x00, 0x01, 0x00 };
732    uchar   sc_Acs57Code[]    = { 0xD2, 0x16, 0x00, 0x00, 0x01 ,0x37},
733        sc_Acs57Prid[]    = { 0xD2, 0x08, 0x00, 0x00, 0x02, 0x00,0x00 },
734        sc_Acs57_Cmd[]    = { ACS57GET, 0xFE, 0x00, 0x00, 0x00 };
735
736  /*
737   * ContryCode2
738   */
739    int32_t acspadd=0;
740    if(reader->acs57==1){
741        acspadd=8;
742        reader_chk_cmd(sc_Acs57Code,0);
743        int32_t acslength=cta_res[cta_lr-1];
744        sc_Acs57_Cmd[4]=acslength;
745        reader_chk_cmd(sc_Acs57_Cmd, acslength+2);
746    } else {
747        reader_chk_cmd(sc_GetCountryCode2, 0);
748    }
749
750  if (((cta_lr>9) && !(cta_res[cta_lr-2]|cta_res[cta_lr-1])) || (reader->acs57==1))
751  {
752    cs_debug_mask(D_READER, "[irdeto-reader] max chids: %d, %d, %d, %d", cta_res[6+acspadd], cta_res[7+acspadd], cta_res[8+acspadd], cta_res[9+acspadd]);
753
754    /*
755     * Provider 2
756     */
757    for (i=p=0; i<reader->nprov; i++)
758    {
759      int32_t j, k, chid, first=1;
760      char t[32];
761      if (reader->prid[i][4]!=0xff)
762      {
763        p++;
764        sc_Acs57Prid[3]=i;
765        sc_GetChanelIds[3]=i; // provider at index i
766        j=0;
767        // for (j=0; j<10; j++) => why 10 .. do we know for sure the there are only 10 chids !!!
768        // shouldn't it me the max chid value we read above ?!
769        while(1) // will exit if cta_lr < 61 .. which is the correct break condition.
770        {
771          if(reader->acs57==1) {
772        int32_t crc=63;
773                sc_Acs57Prid[5]=j;
774                crc^=0x01;crc^=0x02;crc^=0x04;
775                crc^=sc_Acs57Prid[2];crc^=sc_Acs57Prid[3];crc^=(sc_Acs57Prid[4]-1);crc^=sc_Acs57Prid[5];
776                sc_Acs57Prid[6]=crc;
777                irdeto_do_cmd(reader, sc_Acs57Prid, 0x903C, cta_res, &cta_lr);
778                int32_t acslength=cta_res[cta_lr-1];
779            if (acslength==0x09) break;
780                sc_Acs57_Cmd[4]=acslength;
781            reader_chk_cmd(sc_Acs57_Cmd, acslength+2);
782            if(cta_res[10]==0xFF) break;
783                cta_res[cta_lr-3]=0xff;
784                cta_res[cta_lr-2]=0xff;
785                cta_res[cta_lr-1]=0xff;
786                acspadd=8;
787          } else {
788                sc_GetChanelIds[5]=j; // chid at index j for provider at index i
789                reader_chk_cmd(sc_GetChanelIds, 0);
790          }
791          // if (cta_lr<61) break; // why 61 (0 to 60 in steps of 6 .. is it 10*6 from the 10 in the for loop ?
792          // what happen if the card only send back.. 9 chids (or less)... we don't see them
793          // so we should check whether or not we have at least 6 bytes (1 chid).
794          if (cta_lr<6) break; 
795         
796          for(k=0+acspadd; k<cta_lr; k+=6)
797          {
798            chid=b2i(2, cta_res+k);
799            if (chid && chid!=0xFFFF)
800            {
801              time_t date;
802              chid_date(reader,date=b2i(2, cta_res+k+2), t, 16);
803              chid_date(reader,date+cta_res[k+4], t+16, 16);
804              if (first)
805              {
806                cs_ri_log(reader, "entitlements for provider: %d, id: %06X", p, b2i(3, &reader->prid[i][1]));
807                first=0;
808              }
809              cs_ri_log(reader, "chid: %04X, date: %s - %s", chid, t, t+16);
810            }
811          }
812        j++;
813        }
814      }
815    }
816  }
817  cs_log("[irdeto-reader] ready for requests");
818  return OK;
819}
820
821void reader_irdeto(struct s_cardsystem *ph) 
822{
823    ph->do_emm=irdeto_do_emm;
824    ph->do_ecm=irdeto_do_ecm;
825    ph->card_info=irdeto_card_info;
826    ph->card_init=irdeto_card_init;
827    ph->get_emm_type=irdeto_get_emm_type;
828    ph->get_emm_filter=irdeto_get_emm_filter;
829    ph->caids[0]=0x06;
830    ph->caids[1]=0x17;
831    ph->desc="irdeto";
832}
Note: See TracBrowser for help on using the repository browser.