source: trunk/reader-nagracak7.c @ 11430

Last change on this file since 11430 was 11430, checked in by felixka, 16 months ago

[Nagra]

  • continue to prepare code for Nagra Merlin support
  • try to fix for HD04 display of tiers and valid_to
File size: 22.8 KB
Line 
1#include "globals.h"
2#include <math.h>
3#ifdef READER_NAGRA_MERLIN
4#include "cscrypt/bn.h"
5#include "cscrypt/idea.h"
6#include "cscrypt/sha256.h"
7#include "cscrypt/aescbc.h"
8#include "csctapi/icc_async.h"
9#include "oscam-time.h"
10#include "reader-common.h"
11#include "oscam-work.h"
12#include "cscrypt/des.h"
13#include "cscrypt/mdc2.h"
14#include "reader-nagracak7.h"
15
16const unsigned char exponent[] = {0x01, 0x00, 0x01};
17const unsigned char d00ff[]    = {0x00,0xff,0xff,0xFF};
18const unsigned char irdid[]    = {0x64,0x65,0x6D,0x6F};
19const unsigned char data1[]    = {0x00,0x00,0x00,0x01};
20
21struct nagra_data
22{
23    IDEA_KEY_SCHEDULE ksSession;
24    int8_t      is_pure_nagra;
25    int8_t      is_tiger;
26    int8_t      is_n3_na;
27    int8_t      has_dt08;
28    int8_t      swapCW;
29    uint8_t     ExpiryDate[2];
30    uint8_t     ActivationDate[2];
31    uint8_t     plainDT08RSA[64];
32    uint8_t     IdeaCamKey[16];
33    uint8_t     sessi[16];
34    uint8_t     signature[8];
35    uint8_t     cam_state[3];
36    uint32_t    Date_ird;
37    uint32_t    Provider_ID_tiers;
38    uint16_t    tiers;
39    uint32_t    Expire_date_tiers_2;
40    uint32_t    Begin_date_tiers_2;
41    uint16_t    tiers_2;
42    int32_t     num_records;
43};
44
45// Datatypes
46#define IRDINFO     0x03
47#define TIERS       0x0C
48#define SYSID       0x05
49#define allproviders    0x06
50
51#define SYSTEM_NAGRA    0x1800
52#define SYSTEM_MASK 0xFF00
53
54static time_t tier_date(uint64_t date, char *buf, int32_t l)
55{
56    time_t ut = +694224000L + (date>>1);
57    if(buf){
58        struct tm t;
59        cs_gmtime_r(&ut, &t);
60        snprintf(buf, l, "%04d/%02d/%02d", t.tm_year + 1900, t.tm_mon + 1, t.tm_mday);
61    }
62    return ut;
63}
64
65void rsa_decrypt(unsigned char *edata50, int len,unsigned char *out, unsigned char *key, int keylen)
66{
67    BN_CTX *ctx0 = BN_CTX_new();
68#ifdef WITH_LIBCRYPTO
69    BN_CTX_start(ctx0);
70#endif
71    BIGNUM *bnN0 = BN_CTX_get(ctx0);
72    BIGNUM *bnE0 = BN_CTX_get(ctx0);
73    BIGNUM *bnCT0 = BN_CTX_get(ctx0);
74    BIGNUM *bnPT0 = BN_CTX_get(ctx0);
75    BN_bin2bn(&key[0], keylen, bnN0);
76    BN_bin2bn(exponent, 0x03, bnE0);
77    BN_bin2bn(&edata50[0], len, bnCT0);
78    BN_mod_exp(bnPT0, bnCT0, bnE0, bnN0, ctx0);
79    memset(out,0x00,len);
80    BN_bn2bin(bnPT0, out+ (len- BN_num_bytes(bnPT0)));
81    BN_CTX_end(ctx0);
82    BN_CTX_free(ctx0);
83}
84
85static void addProvider(struct s_reader *reader, unsigned char *cta_res)
86{
87    int32_t i;
88    int32_t toadd = 1;
89    for(i = 0; i < reader->nprov; i++){
90        if((cta_res[19] == reader->prid[i][2]) && (cta_res[20] == reader->prid[i][3])){
91            toadd = 0;
92        }
93    }
94    if(toadd){
95        reader->prid[reader->nprov][0] = 0;
96        reader->prid[reader->nprov][1] = 0;
97        reader->prid[reader->nprov][2] = cta_res[19];
98        reader->prid[reader->nprov][3] = cta_res[20];
99        memcpy(reader->sa[reader->nprov], reader->sa[0], 4);
100        reader->nprov += 1;
101    }
102}
103
104typedef struct{
105    uint32_t    Expire_date_tiers;
106    uint32_t    Begin_date_tiers;
107    uint16_t    tiers;
108    int32_t     num_records;
109    uint32_t    Provider_ID_tiers;
110} tiers_rec;
111
112static int32_t ParseDataType(struct s_reader *reader, unsigned char dt, unsigned char *cta_res, uint16_t cta_lr)
113{
114    struct nagra_data *csystem_data = reader->csystem_data;
115    char ds[20], de[16], da[16];
116    IDEA_KEY_SCHEDULE ks;
117    //rdr_log_dump_dbg(reader, D_READER, cta_res, cta_lr, "cta_res:");
118    switch(dt)
119    {
120    //case 0x0C:
121    case TIERS:
122        if((cta_res[13] >= 0x20) && (cta_lr != 0x10) && (reader->caid==0x1860 || reader->caid==0x186A))
123        {
124            csystem_data->tiers = b2i(2,cta_res +23);
125            uint16_t chid = csystem_data->tiers;
126            int32_t id = b2i(2,cta_res +19);
127            rdr_log_dbg(reader, D_READER, "Provid : %04X", id);
128            rdr_log_dbg(reader, D_READER, "ID : %04X", chid);
129           
130            if(reader->caid==0x1860)
131            {
132                cs_add_entitlement(
133                            reader,
134                            reader->caid,
135                            id,
136                            chid,
137                            0,
138                            tier_date(b2ll(4, cta_res + 42)-0x7f7, ds, 15), // noch nicht richtig
139                            tier_date(b2ll(4, cta_res + 28)-0x7f7, de, 15),
140                            4,
141                            1);
142
143                rdr_log(reader, "|%04X|%04X    |%s  |%s  |", id, chid, ds, de);
144                addProvider(reader, cta_res);
145            }
146            if(reader->caid==0x186A)
147            {
148                cs_add_entitlement(
149                            reader,
150                            reader->caid,
151                            id,
152                            chid,
153                            0,
154                            tier_date(b2ll(4, cta_res + 0x35)-0x7f7, ds, 15),
155                            tier_date(b2ll(4, cta_res + 0x27)-0x7f7, de, 15),
156                            4,
157                            1);
158
159                rdr_log(reader, "|%04X|%04X    |%s  |%s  |", id, chid, ds, de);
160                addProvider(reader, cta_res);
161            }
162        }
163        break;
164
165    //case 0x03:
166    case IRDINFO:
167        //if(cta_res[13] == 0x4D || cta_res[13] == 0x50 || cta_res[13] == 0x55)
168        if(cta_lr == 0x72) 
169        {
170            rdr_log_dump_dbg(reader, D_READER, cta_res+19, 2, "Provider ID :");
171            reader->card_valid_to=tier_date(b2ll(4, cta_res + 22)-0x7f7, da, 15);
172            rdr_log(reader, "Card expire date: %s", da);
173        }
174        break;
175
176    case 0x02:
177        reader->prid[0][0]=cta_res[17];
178        reader->prid[0][1]=cta_res[18];
179        reader->prid[0][2]=cta_res[19];
180        reader->prid[0][3]=cta_res[20];
181
182        reader->prid[1][0] = 0x00;
183        reader->prid[1][1] = 0x00;
184        reader->prid[1][2] = 0x00;
185        reader->prid[1][3] = 0x00;
186        memcpy(reader->sa[1], reader->sa[0], 4);
187        reader->nprov += 1;
188        reader->caid = (SYSTEM_NAGRA | cta_res[25]);
189        rdr_log_dbg(reader, D_READER, "CAID : %04X", reader->caid);
190        break;
191
192    //case 0x05:
193    case SYSID:
194        memcpy(reader->edata,cta_res+26,0x70);
195        reader->dt5num=cta_res[20];
196        rsa_decrypt(reader->edata,0x70,reader->out,mod1,sizeof(mod1));
197        if(reader->dt5num==0x00)
198        {
199            memcpy(reader->kdt05_00,&reader->out[18],0x5C+2);
200            memcpy(&reader->kdt05_00[0x5C+2],cta_res+26+0x70,6);
201            memcpy(reader->ideakey1,reader->out,16);
202            memcpy(reader->block3,cta_res+26+0x70+6,8);
203            idea_set_encrypt_key(reader->ideakey1, &ks);
204            memset(reader->v, 0, sizeof(reader->v));
205            idea_cbc_encrypt(reader->block3, reader->iout, 8, &ks, reader->v, IDEA_DECRYPT);
206            memcpy(&reader->kdt05_00[0x5C+2+6],reader->iout,8);
207            rdr_log_dump_dbg(reader, D_READER, reader->kdt05_00, sizeof(reader->kdt05_00), "DT05_00: ");
208        }
209        if(reader->dt5num==0x10)
210        {
211            memcpy(reader->kdt05_10,&reader->out[16],6*16);
212            memcpy(reader->ideakey1,reader->out,16);
213            memcpy(reader->block3,cta_res+26+0x70,8);
214            idea_set_encrypt_key(reader->ideakey1, &ks);
215            memset(reader->v, 0, sizeof(reader->v));
216            idea_cbc_encrypt(reader->block3, reader->iout, 8, &ks, reader->v, IDEA_DECRYPT);
217            memcpy(&reader->kdt05_10[6*16],reader->iout,8);
218            rdr_log_dump_dbg(reader, D_READER, reader->kdt05_10, sizeof(reader->kdt05_10), "DT05_10: ");
219        }
220        if(cta_res[8] != 0x07)
221        {
222            reader->prid[reader->nprov][0] = 0;
223            reader->prid[reader->nprov][1] = 0;
224            reader->prid[reader->nprov][2] = cta_res[19];
225            reader->prid[reader->nprov][3] = cta_res[20];
226        }
227        break;
228
229    default:
230        return OK;
231    }
232    return ERROR;
233}
234
235static int32_t CAS7do_cmd(struct s_reader *reader, unsigned char dt,unsigned char len,unsigned char *res, uint16_t *rlen,int32_t sub,unsigned char retlen)
236{
237    //unsigned char dtdata[0x10];
238    memset(reader->dtdata,0xCC,len);
239
240    reader->dtdata[7]=0x04;
241    reader->dtdata[8]=0x04;
242
243    reader->dtdata[ 9]=(sub>>16)&0xFF;
244    reader->dtdata[10]=(sub>>8)&0xFF;
245    reader->dtdata[11]=(sub)&0xFF;
246
247    reader->dtdata[12]=dt;
248
249    do_cas7_cmd(reader,res,rlen,reader->dtdata,sizeof(reader->dtdata),retlen);
250
251    return true;
252}
253
254static int32_t CAS7GetDataType(struct s_reader *reader, unsigned char dt)
255{
256    def_resp;
257
258    int32_t sub=0x00;
259    unsigned char retlen=0x10;
260    while(true)
261    {
262        CAS7do_cmd(reader,dt,0x10,cta_res,&cta_lr,sub,retlen);
263        // check auf 90 am ende ??
264
265        uint32_t newsub=(cta_res[9]<<16)+(cta_res[10]<<8)+(cta_res[11]);
266        if(newsub==0xFFFFFF)
267        {
268            break;
269        }
270
271        if(cta_res[12]==dt) // seqcounter check ??
272        {
273            unsigned char oretlen=retlen;
274            retlen=cta_res[13]+0x10+0x2;
275            while(retlen%0x10!=0x00)retlen++;
276
277            if(retlen==oretlen)
278            {
279                sub=newsub+1;
280                retlen=0x10;
281                ParseDataType(reader,dt,cta_res,cta_lr);
282            }
283        }
284        else
285        {
286            break;
287        }
288    }
289
290    return true;
291}
292
293void sub_6AD78(uint32_t *dinit) // gbox function
294{
295    uint32_t v0=(uint32_t)*dinit;
296    double f0;
297    f0=v0;
298    double f12=16807;
299    double f15=2147483647;
300    f12=f0*f12;
301    double v12;
302    v12=fmod(f12,f15);
303    *dinit=v12;
304}
305
306void calc_cas7_exponent(uint32_t *dinit, unsigned char *out, uint8_t  len)
307{
308    memset(out,0x00,len);
309
310    sub_6AD78(dinit);
311
312    int R4=0;
313    int R5=0;
314    while(true)
315    {
316        uint32_t R0=(uint32_t)*dinit;
317        int R3=R4+3;
318        R5+=4;
319        if(R3>len)break;
320
321        out[R5-1]=((R0    )&0xFF);
322        out[R5-2]=((R0>> 8)&0xFF);
323        out[R5-3]=((R0>>16)&0xFF);
324        out[R5-4]=((R0>>24)&0xFF);
325        R4+=4;
326        sub_6AD78(dinit);
327
328    }
329
330    uint32_t R0=(uint32_t)*dinit;
331    while(R4<len)
332    {
333        out[R4]=R0&0xFF;
334        R4++;
335        R0>>=8;
336    }
337
338    out[0]&=0x03;
339    out[0x10]|=0x01;
340
341}
342
343void CAS7_getCamKey(struct s_reader *reader)
344{
345    def_resp;
346    uint8_t cmd0e[] = {0xCC,0xCC,0xCC,0xCC,0x00,0x00,0x09,0x0E,0x83,0x00,0x00,0x00,0x00,0x00,0x64,0x65,0x6D,0x6F,0x34,0x11,0x9D,
347    0x7E,0xEE,0xCE,0x53,0x09,0x80,0xAE,0x6B,0x5A,0xEE,0x3A,0x41,0xCE,0x09,0x75,0xEF,0xA6,0xBF,0x1E,0x98,0x4F,
348    0xA4,0x11,0x6F,0x43,0xCA,0xCD,0xD0,0x6E,0x69,0xFA,0x25,0xC1,0xF9,0x11,0x8E,0x7A,0xD0,0x19,0xC0,0xEB,0x00,
349    0xC0,0x57,0x2A,0x40,0xB7,0xFF,0x8A,0xBB,0x25,0x21,0xD7,0x50,0xE7,0x35,0xA1,0x85,0xCD,0xA6,0xD3,0xDE,0xB3,
350    0x3D,0x16,0xD4,0x94,0x76,0x8A,0x82,0x8C,0x70,0x25,0xD4,0x00,0xD0,0x64,0x8C,0x26,0xB9,0x5F,0x44,0xFF,0x73,
351    0x70,0xAB,0x43,0xF5,0x68,0xA2,0xB1,0xB5,0x8A,0x8E,0x02,0x5F,0x96,0x06,0xA8,0xC3,0x4F,0x15,0xCD,0x99,0xC2,
352    0x69,0xB8,0x35,0x68,0x11,0x4C,0x84,0x3E,0x94,0x1E,0x00,0x08,0x00,0x00,0xCC,0xCC,0xCC,0xCC};
353    do_cas7_cmd(reader,cta_res,&cta_lr,cmd0e,sizeof(cmd0e),0x20);
354    reader->dword_83DBC= (cta_res[18]<<24);
355    reader->dword_83DBC+=(cta_res[19]<<16);
356    reader->dword_83DBC+=(cta_res[20]<< 8);
357    reader->dword_83DBC+=(cta_res[21]    );
358    calc_cas7_exponent(&reader->dword_83DBC,reader->cas7expo,0x11);
359    memcpy(reader->cardid,cta_res+14,4);
360    rdr_log_dump_dbg(reader, D_READER, reader->cardid, 0x04, "CardSerial: ");
361    memcpy(reader->hexserial + 2, reader->cardid,4);
362    memcpy(reader->sa[0],reader->cardid,2);
363    unsigned long datal=(cta_res[9]<<24)+(cta_res[10]<<16)+(cta_res[11]<<8)+(cta_res[12]);
364    datal++;
365    reader->data2[0]=(datal>>24)&0xFF;
366    reader->data2[1]=(datal>>16)&0xFF;
367    reader->data2[2]=(datal>> 8)&0xFF;
368    reader->data2[3]=(datal    )&0xFF;
369
370    BN_CTX *ctx0 = BN_CTX_new();
371#ifdef WITH_LIBCRYPTO
372    BN_CTX_start(ctx0);
373#endif
374    BIGNUM *bnN0 = BN_CTX_get(ctx0);
375    BIGNUM *bnE0 = BN_CTX_get(ctx0);
376    BIGNUM *bnCT0 = BN_CTX_get(ctx0);
377    BIGNUM *bnPT0 = BN_CTX_get(ctx0);
378    BN_bin2bn(&mod50[0], 0x50, bnN0);
379    BN_bin2bn(&reader->cas7expo[0], 0x11, bnE0);
380    BN_bin2bn(&data50[0], 0x50, bnCT0);
381    BN_mod_exp(bnPT0, bnCT0, bnE0, bnN0, ctx0);
382    memset(reader->data,0x00,sizeof(reader->data));
383    BN_bn2bin(bnPT0, reader->data+ (0x50- BN_num_bytes(bnPT0)));
384    BN_CTX_end(ctx0);
385    BN_CTX_free(ctx0);
386   
387    memcpy(&reader->step1[0],d00ff,4);
388    memcpy(&reader->step1[4],reader->data,0x50);
389    memcpy(&reader->step1[4+0x50],irdid,0x04);
390    memcpy(&reader->step1[4+4+0x50],data1,0x04);
391    memcpy(&reader->step1[4+4+4+0x50],reader->data2,0x04);
392
393    BN_CTX *ctx1 = BN_CTX_new();
394#ifdef WITH_LIBCRYPTO
395    BN_CTX_start(ctx1);
396#endif
397    BIGNUM *bnN1 = BN_CTX_get(ctx1);
398    BIGNUM *bnE1 = BN_CTX_get(ctx1);
399    BIGNUM *bnCT1 = BN_CTX_get(ctx1);
400    BIGNUM *bnPT1 = BN_CTX_get(ctx1);
401    BN_bin2bn(&key60[0], 0x60, bnN1);
402    BN_bin2bn(&exp60[0], 0x60, bnE1);
403    BN_bin2bn(&reader->step1[0], 0x60, bnCT1);
404    BN_mod_exp(bnPT1, bnCT1, bnE1, bnN1, ctx1);
405    BN_bn2bin(bnPT1, reader->data+ (0x60- BN_num_bytes(bnPT1)));
406    BN_CTX_end(ctx1);
407    BN_CTX_free(ctx1);
408
409    memcpy(&reader->step2[0],d00ff,4);
410    memcpy(&reader->step2[4],reader->cardid,4);
411    memcpy(&reader->step2[8],reader->data,0x60);
412
413    BN_CTX *ctx2 = BN_CTX_new();
414#ifdef WITH_LIBCRYPTO
415    BN_CTX_start(ctx2);
416#endif
417    BIGNUM *bnN2 = BN_CTX_get(ctx2);
418    BIGNUM *bnE2 = BN_CTX_get(ctx2);
419    BIGNUM *bnCT2 = BN_CTX_get(ctx2);
420    BIGNUM *bnPT2 = BN_CTX_get(ctx2);
421    BN_bin2bn(&reader->kdt05_10[0], 0x68, bnN2);
422    BN_bin2bn(&exponent[0], 3, bnE2);
423    BN_bin2bn(&reader->step2[0], 0x68, bnCT2);
424    BN_mod_exp(bnPT2, bnCT2, bnE2, bnN2, ctx2);
425    BN_bn2bin(bnPT2, reader->data+ (0x68- BN_num_bytes(bnPT2)));
426    BN_CTX_end(ctx2);
427    BN_CTX_free(ctx2);
428
429    memcpy(&reader->step3[0],d00ff,4);
430    memcpy(&reader->step3[4],reader->data,0x68);
431
432    BN_CTX *ctx3 = BN_CTX_new();
433#ifdef WITH_LIBCRYPTO
434    BN_CTX_start(ctx3);
435#endif
436    BIGNUM *bnN3 = BN_CTX_get(ctx3);
437    BIGNUM *bnE3 = BN_CTX_get(ctx3);
438    BIGNUM *bnCT3 = BN_CTX_get(ctx3);
439    BIGNUM *bnPT3 = BN_CTX_get(ctx3);
440    BN_bin2bn(&reader->kdt05_00[0], 0x6c, bnN3);
441    BN_bin2bn(&exponent[0], 3, bnE3);
442    BN_bin2bn(&reader->step3[0], 0x6c, bnCT3);
443    BN_mod_exp(bnPT3, bnCT3, bnE3, bnN3, ctx3);
444    BN_bn2bin(bnPT3, reader->data+ (0x6c- BN_num_bytes(bnPT3)));
445    BN_CTX_end(ctx3);
446    BN_CTX_free(ctx3);
447
448    uint8_t cmd03[] = {0xCC,0xCC,0xCC,0xCC, 0x00,0x00,0x0A,0x03,0x6C,
449    0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,
450    0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,
451    0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,
452    0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,
453    0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,
454    0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,
455    0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,
456    0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC };
457
458    memcpy(&cmd03[9],reader->data,0x6c);
459    do_cas7_cmd(reader,cta_res,&cta_lr,cmd03,sizeof(cmd03),0x90);
460    memcpy(reader->encrypted,&cta_res[10],0x68);
461
462    BN_CTX *ctx = BN_CTX_new();
463#ifdef WITH_LIBCRYPTO
464    BN_CTX_start(ctx);
465#endif
466    BIGNUM *bnN = BN_CTX_get(ctx);
467    BIGNUM *bnE = BN_CTX_get(ctx);
468    BIGNUM *bnCT = BN_CTX_get(ctx);
469    BIGNUM *bnPT = BN_CTX_get(ctx);
470    BN_bin2bn(&reader->kdt05_10[0], 104, bnN);
471    BN_bin2bn(&exponent[0], 3, bnE);
472    BN_bin2bn(&reader->encrypted[0], 104, bnCT);
473    BN_mod_exp(bnPT, bnCT, bnE, bnN, ctx);
474    memset(reader->result, 0, 104);
475    BN_bn2bin(bnPT, reader->result + (104 - BN_num_bytes(bnPT)));
476    BN_CTX_end(ctx);
477    BN_CTX_free(ctx);
478
479    //uchar stillencrypted[0x50];
480    memcpy(reader->stillencrypted,&reader->result[12],0x50);
481
482    //uchar resultrsa[0x50];
483    BN_CTX *ctxs = BN_CTX_new();
484#ifdef WITH_LIBCRYPTO
485    BN_CTX_start(ctxs);
486#endif
487    BIGNUM *bnNs  = BN_CTX_get(ctxs);
488    BIGNUM *bnEs  = BN_CTX_get(ctxs);
489    BIGNUM *bnCTs = BN_CTX_get(ctxs);
490    BIGNUM *bnPTs = BN_CTX_get(ctxs);
491    BN_bin2bn(&mod50[0], sizeof(mod50), bnNs);
492    BN_bin2bn(&reader->cas7expo[0], 0x11, bnEs);
493    BN_bin2bn(&reader->stillencrypted[0], 0x50, bnCTs);
494    BN_mod_exp(bnPTs, bnCTs, bnEs, bnNs, ctxs);
495    BN_bn2bin(bnPTs, reader->resultrsa + (0x50- BN_num_bytes(bnPTs)));
496    BN_CTX_end(ctxs);
497    BN_CTX_free(ctxs);
498
499    unsigned char mdc_hash[MDC2_DIGEST_LENGTH];
500    memset(mdc_hash,0x00,MDC2_DIGEST_LENGTH);
501
502    MDC2_CTX c;
503    MDC2_Init(&c);
504    MDC2_Update(&c, reader->resultrsa, sizeof(reader->resultrsa));
505    MDC2_Final(&(mdc_hash[0]), &c);
506
507    memcpy(&reader->cas7_aes_key[16],mdc_hash,16);
508    memcpy(reader->cas7_aes_key,mdc_hash,16);
509}
510
511static int32_t nagra7_card_init(struct s_reader *reader, ATR *newatr)
512{
513    get_atr;
514    int8_t is_pure_nagra = 0;
515    int8_t is_tiger = 0;
516    int8_t is_n3_na = 0;
517    memset(reader->irdId, 0xff, 4);
518    memset(reader->hexserial, 0, 6);
519    reader->cas7_seq=0x00;
520    cs_clear_entitlement(reader);
521    if(memcmp(atr + 11, "DNASP4", 6) == 0)
522    {
523        memcpy(reader->rom, atr + 11, 15);
524        rdr_log(reader,"Rom revision: %.15s", reader->rom);
525    }
526    else
527    {
528        return ERROR;
529    }
530
531    if(!reader->csystem_data)
532    {
533        if(!cs_malloc(&reader->csystem_data, sizeof(struct nagra_data)))
534        {
535            rdr_log(reader, "cs_malloc error");
536            return ERROR;
537        }
538    }
539    struct nagra_data *csystem_data = reader->csystem_data;
540    csystem_data->is_pure_nagra = is_pure_nagra;
541    csystem_data->is_tiger      = is_tiger;
542    csystem_data->is_n3_na      = is_n3_na;
543
544    reader->nprov = 1;
545    CAS7GetDataType(reader, 0x09);
546    CAS7GetDataType(reader, 0x05);
547    CAS7_getCamKey(reader);
548    CAS7GetDataType(reader, 0x09);
549    CAS7GetDataType(reader, 0x02); // sysid+caid
550    CAS7GetDataType(reader, 0x03);
551    return OK;
552}
553
554typedef struct
555{
556    char date1[11];
557    char date2[11];
558    uint8_t type;
559    uint16_t value;
560    uint16_t price;
561} ncmed_rec;
562
563static int32_t nagra7_card_info(struct s_reader *reader)
564{
565    int32_t i;
566    char tmp[64];
567
568    int crcdigits; // checksum digits
569    crcdigits = (((unsigned long long) b2ll(6, reader->hexserial + 2) % 2300) / 100 + ((unsigned long long) b2ll(6, reader->hexserial + 2)));
570    rdr_log(reader, "ROM:    %c %c %c %c %c %c %c %c", reader->rom[0], reader->rom[1], reader->rom[2], reader->rom[3], reader->rom[4], reader->rom[5], reader->rom[6], reader->rom[7]);
571    rdr_log(reader, "REV:    %c %c %c %c %c %c", reader->rom[9], reader->rom[10], reader->rom[11], reader->rom[12], reader->rom[13], reader->rom[14]);
572    //rdr_log_sensitive(reader, "SER:    {%s} (%llu-%i)", cs_hexdump(0, reader->hexserial + 2, 4, tmp, sizeof(tmp)),(unsigned long long) b2ll(4, reader->hexserial + 2), crcdigits);
573    rdr_log_sensitive(reader, "SER:    {%s}  {%llu}", cs_hexdump(0, reader->hexserial + 2, 4, tmp, sizeof(tmp)),(unsigned long long) b2ll(4, reader->hexserial + 2));
574    rdr_log_dbg(reader, D_READER, "checksum digits: %i", crcdigits);
575    rdr_log(reader, "CAID:   %04X", reader->caid);
576    rdr_log(reader, "Prv.ID: %s(sysid)", cs_hexdump(1, reader->prid[0], 4, tmp, sizeof(tmp)));
577
578    if (reader->irdId[0] == 0xFF && reader->irdId[1] == 0xFF && reader->irdId[2] == 0xFF && reader->irdId[3] == 0xFF)
579        {
580            rdr_log(reader, "IRD ID: FF FF FF FF");
581        } 
582    else 
583        {
584            rdr_log_sensitive(reader, "IRD ID: {%s}", cs_hexdump(1, reader->irdId, 4, tmp, sizeof(tmp)));
585        }
586
587    cs_clear_entitlement(reader); //reset the entitlements
588    rdr_log(reader, "-----------------------------------------");
589    rdr_log(reader, "|id  |tier    |valid from  |valid to    |");
590    rdr_log(reader, "+----+--------+------------+------------+");
591
592    CAS7GetDataType(reader, 0x0C);
593    rdr_log(reader, "-----------------------------------------");
594
595    CAS7GetDataType(reader, 0x06);
596    for(i = 1; i < reader->nprov; i++)
597    {
598        rdr_log(reader, "Prv.ID: %s", cs_hexdump(1, reader->prid[i], 4, tmp, sizeof(tmp)));
599    }
600    if (reader->caid)
601        {
602            rdr_log(reader, "ready for requests");
603        }
604   
605    return OK;
606}
607
608void nagra7_post_process(struct s_reader *reader)
609{
610    struct nagra_data *csystem_data = reader->csystem_data;
611    if((csystem_data->cam_state[0]&64)==64)
612    {
613        rdr_log(reader, "renew Session Key: CAS7");
614        CAS7_getCamKey(reader);
615    }
616}
617
618static int32_t nagra7_do_ecm(struct s_reader *reader, const ECM_REQUEST *er, struct s_ecm_answer *ea)
619{
620    def_resp;
621    struct nagra_data *csystem_data = reader->csystem_data;
622
623    uint8_t ecmreq[0xC0];
624    memset(ecmreq,0xCC,0xC0);
625
626    ecmreq[ 7]=0x05;
627    ecmreq[ 8]=0x8A;
628    ecmreq[ 9]=0x00;
629    ecmreq[10]=0x00;
630    ecmreq[11]=0x00;
631    ecmreq[12]=0x00;
632    ecmreq[13]=0x01;
633    memcpy(&ecmreq[14],er->ecm + 4, er->ecm[4]+1);
634
635    do_cas7_cmd(reader,cta_res,&cta_lr,ecmreq,sizeof(ecmreq),0xB0);
636    if(cta_res[cta_lr-2] != 0x90 && cta_res[cta_lr-1] != 0x00){
637        rdr_log(reader, "(ECM) Reader will be restart now cause: %02X %02X card answer!!!", cta_res[cta_lr-2], cta_res[cta_lr-1]);
638        reader->card_status = CARD_NEED_INIT;
639        add_job(reader->client, ACTION_READER_RESTART, NULL, 0);
640    }
641
642    if(cta_res[27]==0x5C)
643    {
644        uint8_t _cwe0[8];
645        uint8_t _cwe1[8];
646        int32_t i;
647        if (cta_res[78] == 0x01)
648        {
649            rdr_log (reader,"Swap dcw is at use !");  //; csystem_data->swapCW == 1;
650            memcpy(_cwe0,&cta_res[52],0x08);
651            memcpy(_cwe1,&cta_res[28],0x08);
652        }
653        else
654        {
655            memcpy(_cwe0,&cta_res[28],0x08);
656            memcpy(_cwe1,&cta_res[52],0x08);
657        }
658        if (array_has_nonzero_byte(_cwe_key, 128) > 0)
659        {
660            i = cta_res[24];
661            memcpy(_cwe_key, _cwe_key+(i*16), 16);
662            rdr_log_dump_dbg(reader, D_READER, _cwe_key, sizeof(_cwe_key), "Using CWPK-%d from config:",i);
663        }
664        _3DES(_cwe0,_cwe_key);
665        _3DES(_cwe1,_cwe_key);
666        int chkok=1;
667
668        if(((_cwe0[0]+_cwe0[1]+_cwe0[2])&0xFF)!=_cwe0[3])
669        {
670            chkok=0;
671            rdr_log_dbg(reader, D_READER, "CW0 checksum error [0]");
672        }
673        if(((_cwe0[4]+_cwe0[5]+_cwe0[6])&0xFF)!=_cwe0[7])
674        {
675            chkok=0;
676            rdr_log_dbg(reader, D_READER, "CW0 checksum error [1]");
677        }
678        if(((_cwe1[0]+_cwe1[1]+_cwe1[2])&0xFF)!=_cwe1[3])
679        {
680            chkok=0;
681            rdr_log_dbg(reader, D_READER, "CW1 checksum error [0]");
682        }
683        if(((_cwe1[4]+_cwe1[5]+_cwe1[6])&0xFF)!=_cwe1[7])
684        {
685            chkok=0;
686            rdr_log_dbg(reader, D_READER, "CW1 checksum error [1]");
687        }
688
689        csystem_data->cam_state[0]=cta_res[4];
690        if(chkok==1)
691        {
692            rdr_log_dbg(reader, D_READER, "CW Decrypt ok");
693            memcpy(ea->cw,_cwe0,0x08);
694            memcpy(ea->cw+8,_cwe1,0x08);
695            return OK;
696        }
697    }
698
699    return ERROR;
700}
701
702int32_t nagra7_get_emm_type(EMM_PACKET *ep, struct s_reader *rdr)  //returns 1 if shared emm matches SA, unique emm matches serial, or global or unknown
703{
704    switch(ep->emm[0])
705    {
706    case 0x83:
707    case 0x87:
708        memset(ep->hexserial, 0, 8);
709        ep->hexserial[0] = ep->emm[5];
710        ep->hexserial[1] = ep->emm[4];
711        ep->hexserial[2] = ep->emm[3];
712        if(ep->emm[7] == 0x10)
713        {
714            ep->type = SHARED;
715            return (!memcmp(rdr->hexserial + 2, ep->hexserial, 3));
716        }
717        else
718        {
719            ep->hexserial[3] = ep->emm[6];
720            ep->type = UNIQUE;
721            return (!memcmp(rdr->hexserial + 2, ep->hexserial, 4));
722        }
723    case 0x82:
724    case 0x84:
725        ep->type = GLOBAL;
726        return 1;
727    default:
728        ep->type = UNKNOWN;
729        return 1;
730    }
731}
732
733static int32_t nagra7_get_emm_filter(struct s_reader *rdr, struct s_csystem_emm_filter **emm_filters, unsigned int *filter_count)
734{
735    if(*emm_filters == NULL)
736    {
737        const unsigned int max_filter_count = 3;
738        if(!cs_malloc(emm_filters, max_filter_count * sizeof(struct s_csystem_emm_filter)))
739        {
740            return ERROR;
741        }
742
743        struct s_csystem_emm_filter *filters = *emm_filters;
744        *filter_count = 0;
745
746        int32_t idx = 0;
747
748        filters[idx].type = EMM_GLOBAL;
749        filters[idx].enabled   = 1;
750        filters[idx].filter[0] = 0x86;
751        filters[idx].mask[0]   = 0xF9;   // 0x82, 0x84 and 0x86
752        idx++;
753
754        filters[idx].type = EMM_SHARED;
755        filters[idx].enabled   = 1;
756        filters[idx].filter[0] = 0x87;
757        filters[idx].filter[1] = rdr->hexserial[4];
758        filters[idx].filter[2] = rdr->hexserial[3];
759        filters[idx].filter[3] = rdr->hexserial[2];
760        filters[idx].filter[4] = 0x00;
761        filters[idx].filter[5] = 0x10;
762        filters[idx].mask[0]   = 0xFB;   // 0x83 and 0x87
763        memset(&filters[idx].mask[1], 0xFF, 5);
764        idx++;
765
766        filters[idx].type = EMM_UNIQUE;
767        filters[idx].enabled   = 1;
768        filters[idx].filter[0] = 0x87;
769        filters[idx].filter[1] = rdr->hexserial[4];
770        filters[idx].filter[2] = rdr->hexserial[3];
771        filters[idx].filter[3] = rdr->hexserial[2];
772        filters[idx].filter[4] = rdr->hexserial[5];
773        filters[idx].filter[5] = 0x00;
774        filters[idx].mask[0]   = 0xFB;   // 0x83 and 0x87
775        memset(&filters[idx].mask[1], 0xFF, 5);
776        idx++;
777
778        *filter_count = idx;
779    }
780
781    return OK;
782}
783
784static int32_t nagra7_do_emm(struct s_reader *reader, EMM_PACKET *ep)
785{
786    def_resp;
787    uint8_t emmreq[0xC0];
788    memset(emmreq,0xCC,0xC0);
789    emmreq[ 7]=0x05;
790    emmreq[ 8]=0x8A;
791    emmreq[ 9]=0x00;
792    emmreq[10]=0x00;
793    emmreq[11]=0x00;
794    emmreq[12]=0x00;
795    emmreq[13]=0x01;
796    memcpy(&emmreq[14],ep->emm + 9, ep->emm[9]+1);
797    do_cas7_cmd(reader,cta_res,&cta_lr,emmreq,sizeof(emmreq),0xB0);
798    if(cta_res[cta_lr-2] != 0x90 && cta_res[cta_lr-1] != 0x00){
799        rdr_log(reader, "(EMM) Reader will be restart now cause: %02X %02X card answer!!!", cta_res[cta_lr-2], cta_res[cta_lr-1]);
800        reader->card_status = CARD_NEED_INIT;
801        add_job(reader->client, ACTION_READER_RESTART, NULL, 0);
802    }
803    return OK;
804}
805
806const struct s_cardsystem reader_nagracak7 =
807{
808    .desc           = "Nagra_Merlin",
809    .caids          = (uint16_t[]){ 0x18, 0x0 },
810    .do_emm         = nagra7_do_emm,
811    .do_ecm         = nagra7_do_ecm,
812    .post_process   = nagra7_post_process,
813    .card_info      = nagra7_card_info,
814    .card_init      = nagra7_card_init,
815    .get_emm_type   = nagra7_get_emm_type,
816    .get_emm_filter = nagra7_get_emm_filter,
817};
818
819#endif
Note: See TracBrowser for help on using the repository browser.