?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- fix Building without Nagra not possible at Nagra_Merlin https://trac.streamboard...
[oscam.git] / reader-nagra-common.c
blob0b044398a39fb0829eac204732c4bf02e1840c20
1 #include "globals.h"
2 #include "reader-common.h"
3 #include "reader-nagra-common.h"
4
5 int32_t get_prov_idx(struct s_reader *rdr, const uint8_t *provid)
6 {
7 int prov;
8 for(prov = 0; prov < rdr->nprov; prov++) // search for provider index
9 {
10 if(!memcmp(provid, &rdr->prid[prov][2], 2))
11 {
12 return (prov);
13 }
14 }
15 return (-1);
16 }
17
18 int32_t nagra_get_emm_type(EMM_PACKET *ep, struct s_reader *rdr)
19 {
20 if(rdr->cak7type == 3 || rdr->autype == 1)
21 {
22 int i;
23
24 switch(ep->emm[0])
25 {
26 case 0x82:
27 memset(ep->hexserial, 0, 8);
28 memcpy(ep->hexserial, ep->emm + 3, 6);
29 if(!memcmp(rdr->hexserial, ep->hexserial, 6))
30 {
31 ep->type = UNIQUE;
32 return 1;
33 }
34 else if ((ep->emm[3] == 0x00) && (ep->emm[4] == 0x00) && (ep->emm[5] == 0x00) && (ep->emm[6] == 0x00) && (ep->emm[7] == 0x00) && (ep->emm[8] == 0xD3) && (ep->emm[9] == 0x87))
35 {
36 ep->type = GLOBAL;
37 return 1;
38 }
39 return 0;
40
41 case 0x84:
42 ep->type = SHARED;
43 memset(ep->hexserial, 0, 8);
44 memcpy(ep->hexserial, ep->emm + 5, 3);
45 i = get_prov_idx(rdr, ep->emm + 3);
46
47 if(i == -1)
48 {
49 return 0;
50 }
51
52 return (!memcmp(rdr->sa[i], ep->hexserial, 3));
53
54 case 0x83:
55 ep->type = GLOBAL;
56 uint8_t filtr[] = {0x83, 0x00, 0x74};
57 return (!memcmp(ep->emm, filtr, 3));
58
59 case 0x90:
60 ep->type = UNIQUE;
61 if(rdr->cwpkcaid_length && rdr->nuid_length)
62 {
63 memset(ep->hexserial, 0x00, 0x08);
64 ep->hexserial[0] = ep->emm[5];
65 ep->hexserial[1] = ep->emm[4];
66 ep->hexserial[2] = ep->emm[3];
67 ep->hexserial[3] = ep->emm[6];
68 return (!memcmp(rdr->nuid, ep->hexserial, 4));
69 }
70 return 0;
71
72 default:
73 ep->type = UNKNOWN;
74 return 0;
75 }
76 }
77 else if(rdr->cak7type == 1)
78 {
79 int i;
80 switch(ep->emm[0])
81 {
82 case 0x82:
83 ep->type = GLOBAL;
84 if(rdr->emm82 == 1 && ep->emm[3] == 0x00 && ep->emm[4] == 0x00 && ep->emm[5] == 0x00)
85 {
86 return 1;
87 }
88 return 0;
89
90 case 0x83:
91 if(ep->emm[7] == 0x10)
92 {
93 ep->type = SHARED;
94
95 for(i = 0; i < rdr->nemm83s; i++)
96 {
97 if(!memcmp(rdr->emm83s[i] + 1, ep->emm + 3, 0x03))
98 {
99 return 1;
100 }
101 }
102 }
103 else
104 {
105 ep->type = UNIQUE;
106
107 for(i = 0; i < rdr->nemm83u; i++)
108 {
109 if(!memcmp(rdr->emm83u[i] + 1, ep->emm + 3, 0x04))
110 {
111 return 1;
112 }
113 }
114 }
115 return 0;
116
117 case 0x84:
118 ep->type = GLOBAL;
119
120 for(i = 0; i < rdr->nemm84; i++)
121 {
122 if(!memcmp(rdr->emm84[i] + 1, ep->emm + 3, 0x02))
123 {
124 return 1;
125 }
126 }
127 return 0;
128
129 case 0x87:
130 ep->type = SHARED;
131
132 for(i = 0; i < rdr->nemm87; i++)
133 {
134 if(!memcmp(rdr->emm87[i] + 1, ep->emm + 3, 0x04))
135 {
136 return 1;
137 }
138 }
139 return 0;
140
141 case 0x90:
142 ep->type = UNIQUE;
143 if(rdr->cwpkcaid_length && rdr->nuid_length)
144 {
145 memset(ep->hexserial, 0x00, 0x08);
146 ep->hexserial[0] = ep->emm[5];
147 ep->hexserial[1] = ep->emm[4];
148 ep->hexserial[2] = ep->emm[3];
149 ep->hexserial[3] = ep->emm[6];
150 return (!memcmp(rdr->nuid, ep->hexserial, 4));
151 }
152 return 0;
153
154 default:
155 ep->type = UNKNOWN;
156 return 0;
157 }
158 }
159 else if(rdr->autype == 2)
160 {
161 int i;
162 switch(ep->emm[0])
163 {
164 case 0x82:
165 ep->type = GLOBAL;
166 if(ep->emm[3] == 0x00 && ep->emm[4] == 0x00 && ep->emm[5] == 0x00)
167 {
168 return 1;
169 }
170 return 0;
171
172 case 0x83:
173 memset(ep->hexserial, 0x00, 0x08);
174 ep->hexserial[0] = ep->emm[5];
175 ep->hexserial[1] = ep->emm[4];
176 ep->hexserial[2] = ep->emm[3];
177 if(ep->emm[7] == 0x10)
178 {
179 ep->type = SHARED;
180
181 for(i = 0; i < rdr->nprov; i++)
182 {
183 if(!memcmp(rdr->sa[i], "\x00\x00\x00", 3))
184 {
185 continue;
186 }
187
188 if(!memcmp(rdr->sa[i], ep->hexserial, 0x03))
189 {
190 return 1;
191 }
192 }
193 }
194 else
195 {
196 ep->hexserial[3] = ep->emm[6];
197 ep->type = UNIQUE;
198
199 return (!memcmp(rdr->hexserial + 2, ep->hexserial, 0x04));
200 }
201 return 0;
202
203 case 0x84:
204 ep->type = GLOBAL;
205 return 1;
206
207 case 0x87:
208 memset(ep->hexserial, 0x00, 0x08);
209 ep->hexserial[0] = ep->emm[5];
210 ep->hexserial[1] = ep->emm[4];
211 ep->hexserial[2] = ep->emm[3];
212 ep->hexserial[3] = ep->emm[6];
213 ep->type = SHARED;
214
215 for(i = 0; i < rdr->nprov; i++)
216 {
217 if(!memcmp(rdr->sa[i], "\x00\x00\x00", 3))
218 {
219 continue;
220 }
221 if(!memcmp(rdr->sa[i], ep->hexserial, 0x04))
222 {
223 return 1;
224 }
225 }
226 return 0;
227
228 default:
229 ep->type = UNKNOWN;
230 return 0;
231 }
232 }
233 else
234 {
235 int i;
236 switch(ep->emm[0])
237 {
238 case 0x82:
239 memset(ep->hexserial, 0x00, 0x08);
240 ep->hexserial[0] = ep->emm[5];
241 ep->hexserial[1] = ep->emm[6];
242 ep->hexserial[2] = ep->emm[7];
243 ep->hexserial[3] = ep->emm[8];
244 if (!memcmp(rdr->hexserial + 2, ep->hexserial, 0x04))
245 {
246 ep->type = UNIQUE;
247 return 1;
248 }
249 else if ((ep->emm[3] == 0x00) && (ep->emm[4] == 0x00) && (ep->emm[5] == 0x00) && (ep->emm[6] == 0x00) && (ep->emm[7] == 0x00) && ((ep->emm[8] == 0x04) || (ep->emm[8] == 0xD3)) && ((ep->emm[9] == 0x84) || (ep->emm[9] == 0x8F) || (ep->emm[9] == 0x87)))
250 {
251 ep->type = GLOBAL;
252 return 1;
253 }
254 return 0;
255
256 case 0x84:
257 memset(ep->hexserial, 0x00, 0x08);
258 memcpy(ep->hexserial, ep->emm + 5, 3);
259 if ((ep->emm[2] == 0x77) && (ep->emm[3] == 0x00))
260 {
261 ep->type = SHARED;
262 i = get_prov_idx(rdr, ep->emm + 3);
263
264 if(i == -1)
265 {
266 return 0;
267 }
268
269 return (!memcmp(rdr->sa[i], ep->hexserial, 3));
270 }
271 else if ((ep->emm[3] == 0x00) && ((ep->emm[4] == 0x71) || (ep->emm[4] == 0x32) || (ep->emm[4] == 0xEC)) && (ep->emm[5] == 0x00) && (ep->emm[6] == 0x00) && (ep->emm[7] == 0x00) && (ep->emm[8] == 0x04) && (ep->emm[9] == 0x84))
272 {
273 ep->type = GLOBAL;
274 return 1;
275 }
276 return 0;
277
278 case 0x83:
279 memset(ep->hexserial, 0x00, 0x08);
280 ep->hexserial[0] = ep->emm[5];
281 ep->hexserial[1] = ep->emm[4];
282 ep->hexserial[2] = ep->emm[3];
283 ep->hexserial[3] = ep->emm[6];
284 if(ep->emm[7] == 0x10)
285 {
286 ep->type = SHARED;
287
288 for(i = 0; i < rdr->nprov; i++)
289 {
290 if(!memcmp(rdr->sa[i], "\x00\x00\x00", 3))
291 {
292 continue;
293 }
294
295 if(!memcmp(rdr->sa[i], ep->hexserial, 0x03))
296 {
297 return 1;
298 }
299 }
300 }
301 else if (!memcmp(rdr->hexserial + 2, ep->hexserial, 0x04))
302 {
303 ep->type = UNIQUE;
304 return 1;
305 }
306 else if ((ep->emm[5] == 0x04) && (ep->emm[6] == 0x70))
307 {
308 ep->type = GLOBAL;
309 return 1;
310 }
311 return 0;
312
313 case 0x87:
314 memset(ep->hexserial, 0x00, 0x08);
315 ep->hexserial[0] = ep->emm[5];
316 ep->hexserial[1] = ep->emm[4];
317 ep->hexserial[2] = ep->emm[3];
318 ep->hexserial[3] = ep->emm[6];
319 ep->type = SHARED;
320
321 for(i = 0; i < rdr->nprov; i++)
322 {
323 if(!memcmp(rdr->sa[i], "\x00\x00\x00", 3))
324 {
325 continue;
326 }
327 if(!memcmp(rdr->sa[i], ep->hexserial, 0x03))
328 {
329 return 1;
330 }
331 }
332 return 0;
333
334 default:
335 ep->type = UNKNOWN;
336 return 0;
337 }
338 }
339 }
340
341 int32_t nagra_get_emm_filter(struct s_reader *rdr, struct s_csystem_emm_filter **emm_filters, unsigned int *filter_count)
342 {
343 if(rdr->cak7type == 3 || rdr->autype == 1)
344 {
345 if(*emm_filters == NULL)
346 {
347 const unsigned int max_filter_count = 2 + (2 * rdr->nprov);
348 if(!cs_malloc(emm_filters, max_filter_count * sizeof(struct s_csystem_emm_filter)))
349 {
350 return ERROR;
351 }
352
353 struct s_csystem_emm_filter *filters = *emm_filters;
354 *filter_count = 0;
355
356 int32_t idx = 0;
357
358 filters[idx].type = EMM_UNIQUE;
359 filters[idx].enabled = 1;
360 filters[idx].filter[0] = 0x82;
361 filters[idx].mask[0] = 0xFF;
362 memcpy(&filters[idx].filter[1], rdr->hexserial, 6);
363 memset(&filters[idx].mask[1], 0xFF, 6);
364 idx++;
365
366 int32_t prov;
367 for(prov = 0; prov < rdr->nprov; prov++)
368 {
369 if(!memcmp(rdr->sa[prov], "\x00\x00\x00", 3))
370 {
371 continue;
372 }
373
374 filters[idx].type = EMM_GLOBAL;
375 filters[idx].enabled = 1;
376 filters[idx].filter[0] = 0x83;
377 filters[idx].mask[0] = 0xFF;
378 memcpy(&filters[idx].filter[1], &rdr->prid[prov][2], 2);
379 memset(&filters[idx].mask[1], 0xFF, 2);
380 idx++;
381
382 filters[idx].type = EMM_SHARED;
383 filters[idx].enabled = 1;
384 filters[idx].filter[0] = 0x84;
385 filters[idx].mask[0] = 0xFF;
386 memcpy(&filters[idx].filter[1], &rdr->prid[prov][2], 2);
387 memset(&filters[idx].mask[1], 0xFF, 2);
388 memcpy(&filters[idx].filter[3], &rdr->sa[prov], 3);
389 memset(&filters[idx].mask[3], 0xFF, 3);
390 idx++;
391 }
392
393 if(rdr->cwpkcaid_length && rdr->nuid_length)
394 {
395 filters[idx].type = EMM_UNIQUE;
396 filters[idx].enabled = 1;
397 filters[idx].filter[0] = 0x90;
398 filters[idx].filter[1] = rdr->nuid[2];
399 filters[idx].filter[2] = rdr->nuid[1];
400 filters[idx].filter[3] = rdr->nuid[0];
401 filters[idx].filter[4] = rdr->nuid[3];
402 memset(&filters[idx].mask[0], 0xFF, 5);
403 idx++;
404 }
405
406 *filter_count = idx;
407 }
408
409 return OK;
410 }
411 else if(rdr->cak7type == 1)
412 {
413 if(*emm_filters == NULL)
414 {
415 const unsigned int max_filter_count = 2 + (4 * rdr->nprov);
416 if(!cs_malloc(emm_filters, max_filter_count * sizeof(struct s_csystem_emm_filter)))
417 {
418 return ERROR;
419 }
420
421 struct s_csystem_emm_filter *filters = *emm_filters;
422 *filter_count = 0;
423
424 int32_t idx = 0;
425
426 if(rdr->emm82 == 1)
427 {
428 filters[idx].type = EMM_GLOBAL;
429 filters[idx].enabled = 1;
430 filters[idx].filter[0] = 0x82;
431 filters[idx].mask[0] = 0xFF;
432 idx++;
433 }
434
435 int32_t i;
436 for(i = 0; i < rdr->nemm83u; i++)
437 {
438 filters[idx].type = EMM_UNIQUE;
439 filters[idx].enabled = 1;
440 memcpy(&filters[idx].filter[0], rdr->emm83u[i], 6);
441 memset(&filters[idx].mask[0], 0xFF, 6);
442 idx++;
443 }
444
445 for(i = 0; i < rdr->nemm83s; i++)
446 {
447 filters[idx].type = EMM_SHARED;
448 filters[idx].enabled = 1;
449 memcpy(&filters[idx].filter[0], rdr->emm83s[i], 6);
450 memset(&filters[idx].mask[0], 0xFF, 6);
451 idx++;
452 }
453
454 for(i = 0; i < rdr->nemm84; i++)
455 {
456 filters[idx].type = EMM_GLOBAL;
457 filters[idx].enabled = 1;
458 memcpy(&filters[idx].filter[0], rdr->emm84[i], 3);
459 memset(&filters[idx].mask[0], 0xFF, 3);
460 idx++;
461 }
462
463 for(i = 0; i < rdr->nemm87; i++)
464 {
465 filters[idx].type = EMM_SHARED;
466 filters[idx].enabled = 1;
467 memcpy(&filters[idx].filter[0], rdr->emm87[i], 6);
468 memset(&filters[idx].mask[0], 0xFF, 6);
469 idx++;
470 }
471
472 if(rdr->cwpkcaid_length && rdr->nuid_length)
473 {
474 filters[idx].type = EMM_UNIQUE;
475 filters[idx].enabled = 1;
476 filters[idx].filter[0] = 0x90;
477 filters[idx].filter[1] = rdr->nuid[2];
478 filters[idx].filter[2] = rdr->nuid[1];
479 filters[idx].filter[3] = rdr->nuid[0];
480 filters[idx].filter[4] = rdr->nuid[3];
481 memset(&filters[idx].mask[0], 0xFF, 5);
482 idx++;
483 }
484
485 *filter_count = idx;
486 }
487
488 return OK;
489 }
490 else if(rdr->autype == 2)
491 {
492 if(*emm_filters == NULL)
493 {
494 const unsigned int max_filter_count = 3 + (2 * rdr->nprov);
495 if(!cs_malloc(emm_filters, max_filter_count * sizeof(struct s_csystem_emm_filter)))
496 {
497 return ERROR;
498 }
499
500 struct s_csystem_emm_filter *filters = *emm_filters;
501 *filter_count = 0;
502
503 int32_t idx = 0;
504
505 filters[idx].type = EMM_GLOBAL;
506 filters[idx].enabled = 1;
507 filters[idx].filter[0] = 0x82;
508 filters[idx].mask[0] = 0xFF;
509 idx++;
510
511 filters[idx].type = EMM_GLOBAL;
512 filters[idx].enabled = 1;
513 filters[idx].filter[0] = 0x84;
514 filters[idx].mask[0] = 0xFF;
515 idx++;
516
517 filters[idx].type = EMM_UNIQUE;
518 filters[idx].enabled = 1;
519 filters[idx].filter[0] = 0x83;
520 filters[idx].filter[1] = rdr->hexserial[4];
521 filters[idx].filter[2] = rdr->hexserial[3];
522 filters[idx].filter[3] = rdr->hexserial[2];
523 filters[idx].filter[4] = rdr->hexserial[5];
524 filters[idx].filter[5] = 0x00;
525 memset(&filters[idx].mask[0], 0xFF, 6);
526 idx++;
527
528 int i;
529 for(i = 0; i < rdr->nprov; i++)
530 {
531 if(!memcmp(rdr->sa[i], "\x00\x00\x00", 3))
532 {
533 continue;
534 }
535
536 filters[idx].type = EMM_SHARED;
537 filters[idx].enabled = 1;
538 filters[idx].filter[0] = 0x83;
539 filters[idx].filter[1] = rdr->sa[i][2];
540 filters[idx].filter[2] = rdr->sa[i][1];
541 filters[idx].filter[3] = rdr->sa[i][0];
542 filters[idx].filter[4] = 0x00;
543 filters[idx].filter[5] = 0x10;
544 memset(&filters[idx].mask[0], 0xFF, 6);
545 idx++;
546
547 filters[idx].type = EMM_SHARED;
548 filters[idx].enabled = 1;
549 filters[idx].filter[0] = 0x87;
550 filters[idx].filter[1] = rdr->sa[i][2];
551 filters[idx].filter[2] = rdr->sa[i][1];
552 filters[idx].filter[3] = rdr->sa[i][0];
553 filters[idx].filter[4] = rdr->sa[i][3];
554 filters[idx].filter[5] = 0x00;
555 memset(&filters[idx].mask[0], 0xFF, 6);
556 idx++;
557 }
558
559 *filter_count = idx;
560 }
561
562 return OK;
563 }
564 else
565 {
566 if(*emm_filters == NULL)
567 {
568 const unsigned int max_filter_count = 5 + (3 * rdr->nprov);
569 if(!cs_malloc(emm_filters, max_filter_count * sizeof(struct s_csystem_emm_filter)))
570 {
571 return ERROR;
572 }
573
574 struct s_csystem_emm_filter *filters = *emm_filters;
575 *filter_count = 0;
576
577 int32_t idx = 0;
578
579 filters[idx].type = EMM_UNIQUE;
580 filters[idx].enabled = 1;
581 filters[idx].filter[0] = 0x82;
582 filters[idx].mask[0] = 0xFF;
583 memcpy(&filters[idx].filter[1], rdr->hexserial, 6);
584 memset(&filters[idx].mask[1], 0xFF, 6);
585 idx++;
586
587 filters[idx].type = EMM_UNIQUE;
588 filters[idx].enabled = 1;
589 filters[idx].filter[0] = 0x83;
590 filters[idx].filter[1] = rdr->hexserial[4];
591 filters[idx].filter[2] = rdr->hexserial[3];
592 filters[idx].filter[3] = rdr->hexserial[2];
593 filters[idx].filter[4] = rdr->hexserial[5];
594 filters[idx].filter[5] = 0x00;
595 memset(&filters[idx].mask[0], 0xFF, 6);
596 idx++;
597
598 filters[idx].type = EMM_GLOBAL;
599 filters[idx].enabled = 1;
600 filters[idx].filter[0] = 0x82;
601 filters[idx].mask[0] = 0xFF;
602 idx++;
603
604 filters[idx].type = EMM_GLOBAL;
605 filters[idx].enabled = 1;
606 filters[idx].filter[0] = 0x84;
607 filters[idx].mask[0] = 0xFF;
608 idx++;
609
610 filters[idx].type = EMM_GLOBAL;
611 filters[idx].enabled = 1;
612 filters[idx].filter[0] = 0x83;
613 filters[idx].mask[0] = 0xFF;
614 idx++;
615
616 int32_t prov;
617 for(prov = 0; prov < rdr->nprov; prov++)
618 {
619 if(!memcmp(rdr->sa[prov], "\x00\x00\x00", 3))
620 {
621 continue;
622 }
623
624 filters[idx].type = EMM_SHARED;
625 filters[idx].enabled = 1;
626 filters[idx].filter[0] = 0x84;
627 filters[idx].mask[0] = 0xFF;
628 memcpy(&filters[idx].filter[1], &rdr->prid[prov][2], 2);
629 memset(&filters[idx].mask[1], 0xFF, 2);
630 memcpy(&filters[idx].filter[3], &rdr->sa[prov], 3);
631 memset(&filters[idx].mask[3], 0xFF, 3);
632 idx++;
633
634 filters[idx].type = EMM_SHARED;
635 filters[idx].enabled = 1;
636 filters[idx].filter[0] = 0x83;
637 filters[idx].filter[1] = rdr->sa[prov][2];
638 filters[idx].filter[2] = rdr->sa[prov][1];
639 filters[idx].filter[3] = rdr->sa[prov][0];
640 filters[idx].filter[4] = 0x00;
641 filters[idx].filter[5] = 0x10;
642 memset(&filters[idx].mask[0], 0xFF, 6);
643 idx++;
644
645 filters[idx].type = EMM_SHARED;
646 filters[idx].enabled = 1;
647 filters[idx].filter[0] = 0x87;
648 filters[idx].filter[1] = rdr->sa[prov][2];
649 filters[idx].filter[2] = rdr->sa[prov][1];
650 filters[idx].filter[3] = rdr->sa[prov][0];
651 filters[idx].filter[4] = 0x00;
652 filters[idx].filter[5] = 0x00;
653 memset(&filters[idx].mask[0], 0xFF, 6);
654 idx++;
655 }
656
657 *filter_count = idx;
658 }
659
660 return OK;
661 }
662 }
Open Source Conditional Access Module