API tools faq
paste
Advertisement
Guest User

cak7.patch

a guest
Nov 12th, 2019
2,220
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 67.39 KB | None | 0 0
raw download clone embed print report
  1. Index: config.sh
  2. --- config.sh 2019-11-09 21:23:01.657445374 +0100
  3. +++ config.sh 2019-11-09 20:46:21.699589191 +0100
  4. @@ -347,7 +347,7 @@
  5. not_have_flag USE_LIBCRYPTO && echo "CONFIG_LIB_AES=y" || echo "# CONFIG_LIB_AES=n"
  6. enabled MODULE_CCCAM && echo "CONFIG_LIB_RC6=y" || echo "# CONFIG_LIB_RC6=n"
  7. not_have_flag USE_LIBCRYPTO && enabled MODULE_CCCAM && echo "CONFIG_LIB_SHA1=y" || echo "# CONFIG_LIB_SHA1=n"
  8. - enabled_any READER_DRE MODULE_SCAM READER_VIACCESS READER_NAGRA_MERLIN && echo "CONFIG_LIB_DES=y" || echo "# CONFIG_LIB_DES=n"
  9. + enabled_any READER_DRE MODULE_SCAM READER_VIACCESS READER_CONAX READER_NAGRA_MERLIN && echo "CONFIG_LIB_DES=y" || echo "# CONFIG_LIB_DES=n"
  10. enabled_any MODULE_CCCAM READER_NAGRA READER_NAGRA_MERLIN READER_SECA && echo "CONFIG_LIB_IDEA=y" || echo "# CONFIG_LIB_IDEA=n"
  11. not_have_flag USE_LIBCRYPTO && enabled_any READER_CONAX READER_CRYPTOWORKS READER_NAGRA READER_NAGRA_MERLIN && echo "CONFIG_LIB_BIGNUM=y" || echo "# CONFIG_LIB_BIGNUM=n"
  12. enabled READER_NAGRA_MERLIN && echo "CONFIG_LIB_MDC2=y" || echo "# CONFIG_LIB_MDC2=n"
  13. Index: csctapi/icc_async.c
  14. --- csctapi/icc_async.c 2019-11-09 21:22:59.837457306 +0100
  15. +++ csctapi/icc_async.c 2019-11-09 20:46:21.695589217 +0100
  16. @@ -54,6 +54,8 @@
  17. mbedtls_sha256_free(&ctx_sha256);
  18. memcpy(reader->cak7_aes_key,aes_key,32);
  19. memcpy(reader->cak7_aes_iv,aes_iv,16);
  20. + char tmp[128];
  21. + rdr_log(reader, "Initial AES: %s", cs_hexdump(1, reader->cak7_aes_key + 16, 16, tmp, sizeof(tmp)));
  22. }
  23.  
  24. void calculate_cak7_cmd(struct s_reader *reader, uint8_t *cmdin,uint8_t cmdlen,uint8_t *cmdout)
  25. @@ -74,8 +76,14 @@
  26. // head
  27. req[0]=0x80;
  28. req[1]=0xCA;
  29. - // len
  30. - req[4]=inlen;
  31. + if(reader->protocol_type == ATR_PROTOCOL_TYPE_T0)
  32. + {
  33. + req[4]=inlen + 1;
  34. + }
  35. + else
  36. + {
  37. + req[4]=inlen;
  38. + }
  39. req[sizeof(req)-1]=resplen;
  40. data[4]=(reader->cak7_seq>>16)&0xFF;
  41. data[5]=(reader->cak7_seq>>8)&0xFF;
  42. @@ -83,9 +91,60 @@
  43. calculate_cak7_cmd(reader,data,inlen,&req[5]);
  44. if(!ICC_Async_CardWrite(reader, req, sizeof(req), cta_res, p_cta_lr))
  45. {
  46. - AesCtx ctx;
  47. - AesCtxIni(&ctx, reader->cak7_aes_iv, &reader->cak7_aes_key[16], KEY128, CBC);
  48. - AesDecrypt(&ctx, cta_res, cta_res, *p_cta_lr-2);
  49. + if(reader->protocol_type == ATR_PROTOCOL_TYPE_T0)
  50. + {
  51. + if(cta_res[*p_cta_lr - 2] == 0x61)
  52. + {
  53. + uint8_t resp[] = {0x00,0xC0,0x00,0x00,0x00};
  54. + memcpy(resp + 4,&cta_res[*p_cta_lr - 1],1);
  55. + if(!ICC_Async_CardWrite(reader, resp, sizeof(resp), cta_res, p_cta_lr))
  56. + {
  57. + AesCtx ctx;
  58. + AesCtxIni(&ctx, reader->cak7_aes_iv, &reader->cak7_aes_key[16], KEY128, CBC);
  59. + AesDecrypt(&ctx, cta_res, cta_res, *p_cta_lr-2);
  60. + }
  61. + else
  62. + {
  63. + *p_cta_lr=0;
  64. + }
  65. + }
  66. + else if(cta_res[*p_cta_lr - 2] == 0x6F && cta_res[*p_cta_lr - 1] == 0x01)
  67. + {
  68. + rdr_log(reader, "card answered 6F01 - trying one more time");
  69. + if(!ICC_Async_CardWrite(reader, req, sizeof(req), cta_res, p_cta_lr))
  70. + {
  71. + if(cta_res[*p_cta_lr - 2] == 0x61)
  72. + {
  73. + uint8_t resp[] = {0x00,0xC0,0x00,0x00,0x00};
  74. + memcpy(resp + 4,&cta_res[*p_cta_lr - 1],1);
  75. + if(!ICC_Async_CardWrite(reader, resp, sizeof(resp), cta_res, p_cta_lr))
  76. + {
  77. + AesCtx ctx;
  78. + AesCtxIni(&ctx, reader->cak7_aes_iv, &reader->cak7_aes_key[16], KEY128, CBC);
  79. + AesDecrypt(&ctx, cta_res, cta_res, *p_cta_lr-2);
  80. + }
  81. + else
  82. + {
  83. + *p_cta_lr=0;
  84. + }
  85. + }
  86. + else if(cta_res[*p_cta_lr - 2] == 0x6F && cta_res[*p_cta_lr - 1] == 0x01)
  87. + {
  88. + rdr_log(reader, "card answered 6F01 - needs reinit");
  89. + }
  90. + }
  91. + else
  92. + {
  93. + *p_cta_lr=0;
  94. + }
  95. + }
  96. + }
  97. + else
  98. + {
  99. + AesCtx ctx;
  100. + AesCtxIni(&ctx, reader->cak7_aes_iv, &reader->cak7_aes_key[16], KEY128, CBC);
  101. + AesDecrypt(&ctx, cta_res, cta_res, *p_cta_lr-2);
  102. + }
  103. }
  104. else
  105. {
  106. @@ -245,29 +304,46 @@
  107. return ERROR;
  108. }
  109.  
  110. + reader->cak7type = 0;
  111. #ifdef READER_NAGRA_MERLIN
  112. - bool need_nagra_layer_switch = false;
  113. - bool is_cak7 = false;
  114. -
  115. - static const uint8_t hd03atr [] = {0x3F,0xFF,0x95,0x00,0xFF,0x91,0x81,0x71,0xA0,0x47,0x00,0x44,0x4E,0x41,0x53,0x50,0x31,0x39,0x30,0x20,0x4D,0x65,0x72,0x51,0x32,0x35,0x4F}; //HD03, HD03A (CAK6.3 Mode)
  116. - static const uint8_t hd03atr2[] = {0x3F,0xFF,0x95,0x00,0xFF,0x91,0x81,0x71,0xFE,0x57,0x00,0x44,0x4E,0x41,0x53,0x50,0x34,0x31,0x30,0x20,0x52,0x65,0x76,0x51,0x32,0x35,0x17}; //HD03, HD03A (CAK7 Mode)
  117. - static const uint8_t hd04atr [] = {0x3F,0xFF,0x95,0x00,0xFF,0x91,0x81,0x71,0xFE,0x57,0x00,0x44,0x4E,0x41,0x53,0x50,0x34,0x32,0x30,0x20,0x52,0x65,0x76,0x53,0x36,0x30,0x17}; //HD04, HD04A, HD04B (CAK7 only)
  118. - static const uint8_t hd04hatr[] = {0x3F,0xFF,0x95,0x00,0xFF,0x91,0x81,0x71,0xFE,0x57,0x00,0x44,0x4E,0x41,0x53,0x50,0x34,0x32,0x30,0x20,0x52,0x65,0x76,0x53,0x36,0x34,0x13}; //HD04H (CAK7 only)
  119. - static const uint8_t hd05atr [] = {0x3F,0xFF,0x95,0x00,0xFF,0x91,0x81,0x71,0xFE,0x57,0x00,0x44,0x4E,0x41,0x53,0x50,0x34,0x35,0x30,0x20,0x52,0x65,0x76,0x57,0x36,0x30,0x14}; //HD05, HD05A (CAK7 only)
  120.  
  121. ATR_GetRaw(atr, atrarr, &atr_size);
  122. - if(!memcmp(hd03atr, atrarr, atr_size)) need_nagra_layer_switch = true;
  123. - if(!memcmp(hd03atr2, atrarr, atr_size) || !memcmp(hd04atr, atrarr, atr_size) || !memcmp(hd04hatr, atrarr, atr_size) || !memcmp(hd05atr, atrarr, atr_size)) is_cak7 = true;
  124.  
  125. - if(is_cak7)
  126. + if((memcmp(atrarr + 8, "DNASP40", 7) == 0) || (memcmp(atrarr + 11, "DNASP41", 7) == 0))
  127. {
  128. - rdr_log(reader, "detected nagra merlin card in CAK7 mode");
  129. + rdr_log(reader, "card needs reset before init");
  130. + memset(atr, 0, 1);
  131. + call(crdr_ops->activate(reader, atr)); //try to read the atr of this layer
  132. + ATR_GetRaw(atr, atrarr, &atr_size);
  133. + rdr_log(reader,"ATR: %s", cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp)));
  134. + // Parse_ATR and InitCard need to be included in lock because they change parity of serial port
  135. + if(crdr_ops->lock)
  136. + {
  137. + crdr_ops->lock(reader);
  138. + }
  139. + int32_t ret1 = Parse_ATR(reader, atr, deprecated);
  140. + if(crdr_ops->unlock)
  141. + {
  142. + crdr_ops->unlock(reader);
  143. + }
  144. + if(ret1)
  145. + {
  146. + rdr_log(reader, "ERROR: Parse_ATR returned error");
  147. + return ERROR;
  148. + }
  149. + }
  150. +
  151. + if((memcmp(atrarr + 8, "DNASP4", 6) == 0) || (memcmp(atrarr + 11, "DNASP4", 6) == 0))
  152. + {
  153. + rdr_log(reader, "detected card in CAK7 mode");
  154. calculate_cak7_vars(reader, atr);
  155. + reader->cak7type = 1;
  156. }
  157. - else if(need_nagra_layer_switch)
  158. + else if(((memcmp(atrarr + 7, "pp", 2) == 0 && ((atrarr[9]&0x0F) >= 10)) || (memcmp(atrarr + 11, "DNASP18", 7) == 0) || (memcmp(atrarr + 11, "DNASP19", 7) == 0) || (memcmp(atrarr + 11, "DNASP1A", 7) == 0)) && reader->cak7_mode)
  159. {
  160. - rdr_log(reader, "detected nagra merlin card in legacy mode -> try switch nagra layer to CAK7");
  161. - uint8_t changerom_handshake[] = { 0x80, 0xCA, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 };
  162. + rdr_log(reader, "detected card in CAK6/Seca mode -> try switch to Nagra CAK7");
  163. + uint8_t changerom_handshake[22];
  164. + memset(changerom_handshake, 0x00, 22);
  165.  
  166. calculate_changerom_cmd(reader, atr, &changerom_handshake[5]);
  167. memset(reader->rom, 0, 15);
  168. @@ -275,6 +351,8 @@
  169. memset(cta_res, 0, CTA_RES_LEN);
  170. uint16_t cta_lr;
  171.  
  172. + changerom_handshake[0] = 0x80;
  173. + changerom_handshake[1] = 0xCA;
  174. changerom_handshake[4] = 0x11; // 0x11: length of data we will send
  175. uint8_t cta_res1_ok = 0x61;
  176. uint8_t cta_res2_ok = 0x10;
  177. @@ -287,6 +365,9 @@
  178. cta_res2_ok = 0x00;
  179. }
  180.  
  181. + changerom_handshake[21] = 0x10;
  182. +
  183. + reader->cak7type = 1;
  184. if(!ICC_Async_CardWrite(reader, changerom_handshake, sizeof(changerom_handshake), cta_res, &cta_lr))
  185. {
  186. if(cta_res[cta_lr-2] == cta_res1_ok && cta_res[cta_lr-1] == cta_res2_ok)
  187. @@ -295,17 +376,31 @@
  188. memset(atr, 0, 1);
  189. call(crdr_ops->activate(reader, atr)); //try to read the atr of this layer
  190. ATR_GetRaw(atr, atrarr, &atr_size);
  191. - rdr_log(reader,"Nagra layer ATR: %s", cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp)));
  192. + rdr_log(reader,"ATR: %s", cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp)));
  193. calculate_cak7_vars(reader, atr);
  194. + if(reader->protocol_type == ATR_PROTOCOL_TYPE_T0)
  195. + {
  196. + reader->cak7type = 3;
  197. + }
  198. + else
  199. + {
  200. + reader->cak7type = 1;
  201. + }
  202. +
  203. if(crdr_ops->lock)
  204. {
  205. crdr_ops->lock(reader);
  206. }
  207. - Parse_ATR(reader, atr, deprecated);
  208. + int32_t ret2 = Parse_ATR(reader, atr, deprecated);
  209. if(crdr_ops->unlock)
  210. {
  211. crdr_ops->unlock(reader);
  212. }
  213. + if(ret2)
  214. + {
  215. + rdr_log(reader, "ERROR: Parse_ATR returned error");
  216. + return ERROR;
  217. + }
  218. }
  219. else
  220. {
  221. @@ -362,7 +457,7 @@
  222. case ATR_PROTOCOL_TYPE_T1:
  223. ret = Protocol_T1_Command(reader, command, command_len, rsp, lr);
  224. type = 1;
  225. - if(ret != OK && !crdr_ops->skip_t1_command_retries)
  226. + if(ret != OK && !crdr_ops->skip_t1_command_retries && reader->cak7type == 0)
  227. {
  228. //try to resync
  229. rdr_log(reader, "Resync error: readtimeouts %d/%d (max/min) us, writetimeouts %d/%d (max/min) us", reader->maxreadtimeout, reader->minreadtimeout, reader->maxwritetimeout, reader->minwritetimeout);
  230. @@ -398,7 +493,7 @@
  231. }
  232. try++;
  233. }
  234. - while((try < 3) && (ret != OK)); // always do one retry when failing
  235. + while((try < 3) && (ret != OK) && (((type == 0 || type == 1) && reader->cak7type == 0) || type == 14)); // always do one retry when failing
  236. if(crdr_ops->unlock)
  237. {
  238. crdr_ops->unlock(reader);
  239. Index: csctapi/ifd_pcsc.c
  240. --- csctapi/ifd_pcsc.c 2019-11-09 21:22:59.841457280 +0100
  241. +++ csctapi/ifd_pcsc.c 2019-11-09 20:46:21.695589217 +0100
  242. @@ -364,7 +364,7 @@
  243. {
  244. .desc = "pcsc",
  245. .typ = R_PCSC,
  246. - .skip_extra_atr_parsing = 1,
  247. + .skip_extra_atr_parsing = 0,
  248. .skip_t1_command_retries = 1,
  249. .skip_setting_ifsc = 1,
  250. .reader_init = pcsc_init,
  251. Index: csctapi/io_serial.c
  252. --- csctapi/io_serial.c 2019-11-09 21:22:59.837457306 +0100
  253. +++ csctapi/io_serial.c 2019-11-09 20:46:21.695589217 +0100
  254. @@ -490,7 +490,10 @@
  255. {
  256. const struct s_cardreader *crdr_ops = reader->crdr;
  257. if (!crdr_ops) return ERROR;
  258. -
  259. + if(reader->wdelay)
  260. + {
  261. + delay = reader->wdelay;
  262. + }
  263. if(timeout == 0) // General fix for readers not communicating timeout and delay
  264. {
  265. if(reader->char_delay != 0) { timeout = reader->char_delay; }
  266. Index: globals.h
  267. --- globals.h 2019-11-09 21:23:00.801450986 +0100
  268. +++ globals.h 2019-11-09 20:50:35.605919623 +0100
  269. @@ -1475,9 +1475,11 @@
  270. uint8_t keepalive;
  271. uint8_t changes_since_shareupdate;
  272. int32_t resetcycle; // ECM until reset
  273. + int32_t wdelay; // ECM until reset
  274. int32_t resetcounter; // actual count
  275. uint32_t auprovid; // AU only for this provid
  276. int8_t audisabled; // exclude reader from auto AU
  277. + int8_t autype;
  278. int8_t needsemmfirst; // 0: reader descrambles without emm first, 1: reader needs emms before it can descramble
  279. struct timeb emm_last; // time of last successfully written emm
  280. int8_t smargopatch;
  281. @@ -1499,18 +1501,53 @@
  282. #ifdef READER_NAGRA_MERLIN
  283. uint8_t mod1[112];
  284. uint8_t mod1_length;
  285. + uint8_t cmd0eprov[2];
  286. + uint8_t cmd0eprov_length;
  287. + uint8_t mod2[112];
  288. + uint8_t mod2_length;
  289. + uint8_t tmprsa[112];
  290. uint8_t data50[80];
  291. uint8_t data50_length;
  292. uint8_t mod50[80];
  293. uint8_t mod50_length;
  294. + uint8_t key3588[136];
  295. + uint8_t key3588_length;
  296. uint8_t key60[96];
  297. uint8_t key60_length;
  298. uint8_t exp60[96];
  299. uint8_t exp60_length;
  300. + uint8_t key68[104];
  301. + uint8_t key68_length;
  302. + uint8_t exp68[104];
  303. + uint8_t exp68_length;
  304. + uint8_t key3des[16];
  305. + uint8_t klucz68[24];
  306. + uint8_t pairtype;
  307. + uint8_t pairbyte;
  308. + uint8_t key3460[96];
  309. + uint8_t key3460_length;
  310. + uint8_t key3310[16];
  311. + uint8_t key3310_length;
  312. uint8_t nuid[4];
  313. uint8_t nuid_length;
  314. - uint8_t cwekey[16];
  315. - uint8_t cwekey_length;
  316. + uint8_t cwekey0[16];
  317. + uint8_t cwekey0_length;
  318. + uint8_t cwekey1[16];
  319. + uint8_t cwekey1_length;
  320. + uint8_t cwekey2[16];
  321. + uint8_t cwekey2_length;
  322. + uint8_t cwekey3[16];
  323. + uint8_t cwekey3_length;
  324. + uint8_t cwekey4[16];
  325. + uint8_t cwekey4_length;
  326. + uint8_t cwekey5[16];
  327. + uint8_t cwekey5_length;
  328. + uint8_t cwekey6[16];
  329. + uint8_t cwekey6_length;
  330. + uint8_t cwekey7[16];
  331. + uint8_t cwekey7_length;
  332. + uint8_t idird[4];
  333. + uint8_t idird_length;
  334. uint8_t kdt05_00[216];
  335. uint8_t kdt05_10[208];
  336. uint8_t cardid[8];
  337. @@ -1523,6 +1560,9 @@
  338. uint8_t iout[8];
  339. uint32_t dword_83DBC;
  340. uint8_t data2[4];
  341. + uint8_t ecmheader[4];
  342. + uint8_t timestmp1[4];
  343. + uint8_t timestmp2[4];
  344. uint8_t cak7expo[0x11];
  345. uint8_t data[0x80];
  346. uint8_t step1[0x60];
  347. @@ -1536,6 +1576,10 @@
  348. uint8_t cak7_camstate;
  349. uint8_t cak7_aes_key[32];
  350. uint8_t cak7_aes_iv[16];
  351. + int8_t forcecwswap;
  352. + int8_t evensa;
  353. + int8_t forceemmg;
  354. +
  355. #endif
  356. #ifdef CS_CACHEEX
  357. CECSP cacheex; // CacheEx Settings
  358. @@ -1560,6 +1604,8 @@
  359. int32_t l_port;
  360. CAIDTAB ctab;
  361. uint32_t boxid;
  362. + int8_t cak7_mode;
  363. + uint8_t cak7type;
  364. int8_t nagra_read; // read nagra ncmed records: 0 Disabled (default), 1 read all records, 2 read valid records only
  365. int8_t detect_seca_nagra_tunneled_card;
  366. int8_t force_irdeto;
  367. @@ -1567,6 +1613,8 @@
  368. uint8_t boxkey_length;
  369. uint8_t rsa_mod[120]; // rsa modulus for nagra cards.
  370. uint8_t rsa_mod_length;
  371. + uint8_t cwpk_mod[16]; // cwpk modulus for conax cards.
  372. + uint8_t cwpk_mod_length;
  373. uint8_t des_key[128]; // 3des key for Viaccess 16 bytes, des key for Dre 128 bytes
  374. uint8_t des_key_length;
  375. uint8_t atr[64];
  376. @@ -1578,8 +1626,18 @@
  377. SIDTABS lb_sidtabs;
  378. uint8_t hexserial[8];
  379. int32_t nprov;
  380. + int32_t nsa;
  381. + int32_t nemm84;
  382. + int32_t nemm83u;
  383. + int32_t nemm83s;
  384. + int32_t nemm87;
  385. uint8_t prid[CS_MAXPROV][8];
  386. uint8_t sa[CS_MAXPROV][4]; // viaccess & seca
  387. + uint8_t emm84[CS_MAXPROV][3];
  388. + uint8_t emm83u[CS_MAXPROV][6];
  389. + uint8_t emm83s[CS_MAXPROV][6];
  390. + uint8_t emm87[CS_MAXPROV][6];
  391. + uint8_t emm82;
  392. uint8_t read_old_classes; // viaccess
  393. uint8_t maturity; // viaccess & seca maturity level
  394. uint16_t caid;
  395. Index: module-webif.c
  396. --- module-webif.c 2019-11-09 21:22:59.841457280 +0100
  397. +++ module-webif.c 2019-11-09 20:54:16.108582329 +0100
  398. @@ -2250,6 +2250,8 @@
  399. // Reset Cycle
  400. tpl_printf(vars, TPLADD, "RESETCYCLE", "%d", rdr->resetcycle);
  401.  
  402. + tpl_printf(vars, TPLADD, "WDELAY", "%d", rdr->wdelay);
  403. +
  404. // Disable Serverfilter
  405. if(!apicall)
  406. {
  407. @@ -2384,6 +2386,9 @@
  408. tpl_addVar(vars, TPLADD, "AUDISABLEDVALUE", (rdr->audisabled == 1) ? "1" : "0");
  409. }
  410.  
  411. + tpl_printf(vars, TPLADD, "TMP", "AUTYPE%d", rdr->autype);
  412. + tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
  413. +
  414. // AUprovid
  415. if(rdr->auprovid)
  416. { tpl_printf(vars, TPLADD, "AUPROVID", "%06X", rdr->auprovid); }
  417. @@ -2445,8 +2450,32 @@
  418. for(i = 0; i < len ; i++)
  419. { tpl_printf(vars, TPLAPPEND, "BOXKEY", "%02X", rdr->boxkey[i]); }
  420. }
  421. +#ifdef READER_CONAX
  422. + // CWPK Key
  423. + len = rdr->cwpk_mod_length;
  424. + if(len > 0)
  425. + {
  426. + for(i = 0; i < len; i++) { tpl_printf(vars, TPLAPPEND, "CWPKKEY", "%02X", rdr->cwpk_mod[i]); }
  427. + }
  428. +#endif
  429.  
  430. #ifdef READER_NAGRA_MERLIN
  431. + // idird (CAK7)
  432. + len = rdr->idird_length;
  433. + if(len > 0)
  434. + {
  435. + for(i = 0; i < len ; i++)
  436. + { tpl_printf(vars, TPLAPPEND, "IDIRD", "%02X", rdr->idird[i]); }
  437. + }
  438. +
  439. + // cmd0e_provider (CAK7)
  440. + len = rdr->cmd0eprov_length;
  441. + if(len > 0)
  442. + {
  443. + for(i = 0; i < len ; i++)
  444. + { tpl_printf(vars, TPLAPPEND, "CMD0EPROV", "%02X", rdr->cmd0eprov[i]); }
  445. + }
  446. +
  447. // mod1 (CAK7)
  448. len = rdr->mod1_length;
  449. if(len > 0)
  450. @@ -2455,6 +2484,38 @@
  451. { tpl_printf(vars, TPLAPPEND, "MOD1", "%02X", rdr->mod1[i]); }
  452. }
  453.  
  454. + // mod2 (CAK7)
  455. + len = rdr->mod2_length;
  456. + if(len > 0)
  457. + {
  458. + for(i = 0; i < len ; i++)
  459. + { tpl_printf(vars, TPLAPPEND, "MOD2", "%02X", rdr->mod2[i]); }
  460. + }
  461. +
  462. + // key3588 (CAK7)
  463. + len = rdr->key3588_length;
  464. + if(len > 0)
  465. + {
  466. + for(i = 0; i < len ; i++)
  467. + { tpl_printf(vars, TPLAPPEND, "KEY3588", "%02X", rdr->key3588[i]); }
  468. + }
  469. +
  470. + // key3310 (CAK7)
  471. + len = rdr->key3310_length;
  472. + if(len > 0)
  473. + {
  474. + for(i = 0; i < len ; i++)
  475. + { tpl_printf(vars, TPLAPPEND, "KEY3310", "%02X", rdr->key3310[i]); }
  476. + }
  477. +
  478. + // key3460 (CAK7)
  479. + len = rdr->key3460_length;
  480. + if(len > 0)
  481. + {
  482. + for(i = 0; i < len ; i++)
  483. + { tpl_printf(vars, TPLAPPEND, "KEY3460", "%02X", rdr->key3460[i]); }
  484. + }
  485. +
  486. // data50 (CAK7)
  487. len = rdr->data50_length;
  488. if(len > 0)
  489. @@ -2471,39 +2532,95 @@
  490. { tpl_printf(vars, TPLAPPEND, "MOD50", "%02X", rdr->mod50[i]); }
  491. }
  492.  
  493. - // key60 (CAK7)
  494. - len = rdr->key60_length;
  495. + // nuid (CAK7)
  496. + len = rdr->nuid_length;
  497. if(len > 0)
  498. {
  499. for(i = 0; i < len ; i++)
  500. - { tpl_printf(vars, TPLAPPEND, "KEY60", "%02X", rdr->key60[i]); }
  501. + { tpl_printf(vars, TPLAPPEND, "NUID", "%02X", rdr->nuid[i]); }
  502. }
  503.  
  504. - // exp60 (CAK7)
  505. - len = rdr->exp60_length;
  506. + // cwekey0 (CAK7)
  507. + len = rdr->cwekey0_length;
  508. if(len > 0)
  509. {
  510. for(i = 0; i < len ; i++)
  511. - { tpl_printf(vars, TPLAPPEND, "EXP60", "%02X", rdr->exp60[i]); }
  512. + { tpl_printf(vars, TPLAPPEND, "CWEKEY0", "%02X", rdr->cwekey0[i]); }
  513. }
  514.  
  515. - // nuid (CAK7)
  516. - len = rdr->nuid_length;
  517. + // cwekey1 (CAK7)
  518. + len = rdr->cwekey1_length;
  519. if(len > 0)
  520. {
  521. for(i = 0; i < len ; i++)
  522. - { tpl_printf(vars, TPLAPPEND, "NUID", "%02X", rdr->nuid[i]); }
  523. + { tpl_printf(vars, TPLAPPEND, "CWEKEY1", "%02X", rdr->cwekey1[i]); }
  524. + }
  525. +
  526. + // cwekey2 (CAK7)
  527. + len = rdr->cwekey2_length;
  528. + if(len > 0)
  529. + {
  530. + for(i = 0; i < len ; i++)
  531. + { tpl_printf(vars, TPLAPPEND, "CWEKEY2", "%02X", rdr->cwekey2[i]); }
  532. + }
  533. +
  534. + // cwekey3 (CAK7)
  535. + len = rdr->cwekey3_length;
  536. + if(len > 0)
  537. + {
  538. + for(i = 0; i < len ; i++)
  539. + { tpl_printf(vars, TPLAPPEND, "CWEKEY3", "%02X", rdr->cwekey3[i]); }
  540. + }
  541. +
  542. + // cwekey4 (CAK7)
  543. + len = rdr->cwekey4_length;
  544. + if(len > 0)
  545. + {
  546. + for(i = 0; i < len ; i++)
  547. + { tpl_printf(vars, TPLAPPEND, "CWEKEY4", "%02X", rdr->cwekey4[i]); }
  548. + }
  549. +
  550. + // cwekey5 (CAK7)
  551. + len = rdr->cwekey5_length;
  552. + if(len > 0)
  553. + {
  554. + for(i = 0; i < len ; i++)
  555. + { tpl_printf(vars, TPLAPPEND, "CWEKEY5", "%02X", rdr->cwekey5[i]); }
  556. + }
  557. +
  558. + // cwekey6 (CAK7)
  559. + len = rdr->cwekey6_length;
  560. + if(len > 0)
  561. + {
  562. + for(i = 0; i < len ; i++)
  563. + { tpl_printf(vars, TPLAPPEND, "CWEKEY6", "%02X", rdr->cwekey6[i]); }
  564. }
  565.  
  566. - // cwekey (CAK7)
  567. - len = rdr->cwekey_length;
  568. + // cwekey7 (CAK7)
  569. + len = rdr->cwekey7_length;
  570. if(len > 0)
  571. {
  572. for(i = 0; i < len ; i++)
  573. - { tpl_printf(vars, TPLAPPEND, "CWEKEY", "%02X", rdr->cwekey[i]); }
  574. + { tpl_printf(vars, TPLAPPEND, "CWEKEY7", "%02X", rdr->cwekey7[i]); }
  575. }
  576. +
  577. + // force_cw_swap
  578. + if(rdr->forcecwswap)
  579. + { tpl_addVar(vars, TPLADD, "FORCECWSWAPCHECKED", "checked"); }
  580. +
  581. + // only_even_SA
  582. + if(rdr->evensa)
  583. + { tpl_addVar(vars, TPLADD, "EVENSACHECKED", "checked"); }
  584. +
  585. + // force_EMM_82
  586. + if(rdr->forceemmg)
  587. + { tpl_addVar(vars, TPLADD, "FORCEEMMGCHECKED", "checked"); }
  588. #endif
  589.  
  590. + // cak7_mode
  591. + if(rdr->cak7_mode)
  592. + { tpl_addVar(vars, TPLADD, "NAGRACAK7MODECHECKED", "checked"); }
  593. +
  594. // ins7E
  595. if(rdr->ins7E[0x1A])
  596. {
  597. Index: oscam-config-reader.c
  598. --- oscam-config-reader.c 2019-11-09 21:23:00.801450986 +0100
  599. +++ oscam-config-reader.c 2019-11-09 20:59:17.782692596 +0100
  600. @@ -227,6 +227,43 @@
  601. { fprintf_conf(f, token, "\n"); }
  602. }
  603.  
  604. +static void cwpkkey_fn(const char *token, char *value, void *setting, FILE *f)
  605. +{
  606. + struct s_reader *rdr = setting;
  607. + if(value)
  608. + {
  609. + int32_t len = strlen(value);
  610. + // rdr_log(rdr, "CWPK config key length: %16X", len);
  611. + if(len == 0 || len > 32)
  612. + {
  613. + rdr->cwpk_mod_length = 0;
  614. + memset(rdr->cwpk_mod, 0, sizeof(rdr->cwpk_mod));
  615. + }
  616. + else
  617. + {
  618. + if(key_atob_l(value, rdr->cwpk_mod, len))
  619. + {
  620. + fprintf(stderr, "reader cwpkkey parse error, %s=%s\n", token, value);
  621. + rdr->cwpk_mod_length = 0;
  622. + memset(rdr->cwpk_mod, 0, sizeof(rdr->cwpk_mod));
  623. + }
  624. + else
  625. + {
  626. + rdr->cwpk_mod_length = len/2;
  627. + }
  628. + }
  629. + return;
  630. + }
  631. + int32_t len = rdr->cwpk_mod_length;
  632. + if(len > 0)
  633. + {
  634. + char tmp[len * 2 + 1];
  635. + fprintf_conf(f, "cwpkkey", "%s\n", cs_hexdump(0, rdr->cwpk_mod, len, tmp, sizeof(tmp)));
  636. + }
  637. + else if(cfg.http_full_cfg)
  638. + { fprintf_conf(f, "cwpkkey", "\n"); }
  639. +}
  640. +
  641. static void rsakey_fn(const char *token, char *value, void *setting, FILE *f)
  642. {
  643. struct s_reader *rdr = setting;
  644. @@ -372,6 +409,150 @@
  645. { fprintf_conf(f, "mod1", "\n"); }
  646. }
  647.  
  648. +static void mod2_fn(const char *token, char *value, void *setting, FILE *f)
  649. +{
  650. + struct s_reader *rdr = setting;
  651. + if(value)
  652. + {
  653. + int32_t len = strlen(value);
  654. + if(len != 224)
  655. + {
  656. + rdr->mod2_length = 0;
  657. + memset(rdr->mod2, 0, 112);
  658. + }
  659. + else
  660. + {
  661. + if(key_atob_l(value, rdr->mod2, len))
  662. + {
  663. + fprintf(stderr, "reader mod2 parse error, %s=%s\n", token, value);
  664. + rdr->mod2_length = 0;
  665. + memset(rdr->mod2, 0, sizeof(rdr->mod2));
  666. + }
  667. + else
  668. + {
  669. + rdr->mod2_length = len/2;
  670. + }
  671. + }
  672. + return;
  673. + }
  674. + int32_t len = rdr->mod2_length;
  675. + if(len > 0)
  676. + {
  677. + char tmp[len * 2 + 1];
  678. + fprintf_conf(f, "mod2", "%s\n", cs_hexdump(0, rdr->mod2, len, tmp, sizeof(tmp)));
  679. + }
  680. + else if(cfg.http_full_cfg)
  681. + { fprintf_conf(f, "mod2", "\n"); }
  682. +}
  683. +
  684. +static void idird_fn(const char *token, char *value, void *setting, FILE *f)
  685. +{
  686. + struct s_reader *rdr = setting;
  687. + if(value)
  688. + {
  689. + int32_t len = strlen(value);
  690. + if(len != 8)
  691. + {
  692. + rdr->idird_length = 0;
  693. + memset(rdr->idird, 0, 4);
  694. + }
  695. + else
  696. + {
  697. + if(key_atob_l(value, rdr->idird, len))
  698. + {
  699. + fprintf(stderr, "reader idird parse error, %s=%s\n", token, value);
  700. + rdr->idird_length = 0;
  701. + memset(rdr->idird, 0, sizeof(rdr->idird));
  702. + }
  703. + else
  704. + {
  705. + rdr->idird_length = len/2;
  706. + }
  707. + }
  708. + return;
  709. + }
  710. + int32_t len = rdr->idird_length;
  711. + if(len > 0)
  712. + {
  713. + char tmp[len * 2 + 1];
  714. + fprintf_conf(f, "idird", "%s\n", cs_hexdump(0, rdr->idird, len, tmp, sizeof(tmp)));
  715. + }
  716. + else if(cfg.http_full_cfg)
  717. + { fprintf_conf(f, "idird", "\n"); }
  718. +}
  719. +
  720. +static void cmd0eprov_fn(const char *token, char *value, void *setting, FILE *f)
  721. +{
  722. + struct s_reader *rdr = setting;
  723. + if(value)
  724. + {
  725. + int32_t len = strlen(value);
  726. + if(len != 4)
  727. + {
  728. + rdr->cmd0eprov_length = 0;
  729. + memset(rdr->cmd0eprov, 0, 2);
  730. + }
  731. + else
  732. + {
  733. + if(key_atob_l(value, rdr->cmd0eprov, len))
  734. + {
  735. + fprintf(stderr, "reader cmd0eprov parse error, %s=%s\n", token, value);
  736. + rdr->cmd0eprov_length = 0;
  737. + memset(rdr->cmd0eprov, 0, sizeof(rdr->cmd0eprov));
  738. + }
  739. + else
  740. + {
  741. + rdr->cmd0eprov_length = len/2;
  742. + }
  743. + }
  744. + return;
  745. + }
  746. + int32_t len = rdr->cmd0eprov_length;
  747. + if(len > 0)
  748. + {
  749. + char tmp[len * 2 + 1];
  750. + fprintf_conf(f, "cmd0eprov", "%s\n", cs_hexdump(0, rdr->cmd0eprov, len, tmp, sizeof(tmp)));
  751. + }
  752. + else if(cfg.http_full_cfg)
  753. + { fprintf_conf(f, "cmd0eprov", "\n"); }
  754. +}
  755. +
  756. +static void key3588_fn(const char *token, char *value, void *setting, FILE *f)
  757. +{
  758. + struct s_reader *rdr = setting;
  759. + if(value)
  760. + {
  761. + int32_t len = strlen(value);
  762. + if(len != 272)
  763. + {
  764. + rdr->key3588_length = 0;
  765. + memset(rdr->key3588, 0, 136);
  766. + }
  767. + else
  768. + {
  769. + if(key_atob_l(value, rdr->key3588, len))
  770. + {
  771. + fprintf(stderr, "reader key3588 parse error, %s=%s\n", token, value);
  772. + rdr->key3588_length = 0;
  773. + memset(rdr->key3588, 0, sizeof(rdr->key3588));
  774. + }
  775. + else
  776. + {
  777. + rdr->key3588_length = len/2;
  778. + }
  779. + }
  780. + return;
  781. + }
  782. + int32_t len = rdr->key3588_length;
  783. + if(len > 0)
  784. + {
  785. + char tmp[len * 2 + 1];
  786. + fprintf_conf(f, "key3588", "%s\n", cs_hexdump(0, rdr->key3588, len, tmp, sizeof(tmp)));
  787. + }
  788. + else if(cfg.http_full_cfg)
  789. + { fprintf_conf(f, "key3588", "\n"); }
  790. +}
  791. +
  792. static void data50_fn(const char *token, char *value, void *setting, FILE *f)
  793. {
  794. struct s_reader *rdr = setting;
  795. @@ -444,7 +625,7 @@
  796. { fprintf_conf(f, "mod50", "\n"); }
  797. }
  798.  
  799. -static void key60_fn(const char *token, char *value, void *setting, FILE *f)
  800. +static void key3460_fn(const char *token, char *value, void *setting, FILE *f)
  801. {
  802. struct s_reader *rdr = setting;
  803. if(value)
  804. @@ -452,68 +633,68 @@
  805. int32_t len = strlen(value);
  806. if(len != 192)
  807. {
  808. - rdr->key60_length = 0;
  809. - memset(rdr->key60, 0, 96);
  810. + rdr->key3460_length = 0;
  811. + memset(rdr->key3460, 0, 96);
  812. }
  813. else
  814. {
  815. - if(key_atob_l(value, rdr->key60, len))
  816. + if(key_atob_l(value, rdr->key3460, len))
  817. {
  818. - fprintf(stderr, "reader key60 parse error, %s=%s\n", token, value);
  819. - rdr->key60_length = 0;
  820. - memset(rdr->key60, 0, sizeof(rdr->key60));
  821. + fprintf(stderr, "reader key3460 parse error, %s=%s\n", token, value);
  822. + rdr->key3460_length = 0;
  823. + memset(rdr->key3460, 0, sizeof(rdr->key3460));
  824. }
  825. else
  826. {
  827. - rdr->key60_length = len/2;
  828. + rdr->key3460_length = len/2;
  829. }
  830. }
  831. return;
  832. }
  833. - int32_t len = rdr->key60_length;
  834. + int32_t len = rdr->key3460_length;
  835. if(len > 0)
  836. {
  837. char tmp[len * 2 + 1];
  838. - fprintf_conf(f, "key60", "%s\n", cs_hexdump(0, rdr->key60, len, tmp, sizeof(tmp)));
  839. + fprintf_conf(f, "key3460", "%s\n", cs_hexdump(0, rdr->key3460, len, tmp, sizeof(tmp)));
  840. }
  841. else if(cfg.http_full_cfg)
  842. - { fprintf_conf(f, "key60", "\n"); }
  843. + { fprintf_conf(f, "key3460", "\n"); }
  844. }
  845.  
  846. -static void exp60_fn(const char *token, char *value, void *setting, FILE *f)
  847. +static void key3310_fn(const char *token, char *value, void *setting, FILE *f)
  848. {
  849. struct s_reader *rdr = setting;
  850. if(value)
  851. {
  852. int32_t len = strlen(value);
  853. - if(len != 192)
  854. + if(len != 32)
  855. {
  856. - rdr->exp60_length = 0;
  857. - memset(rdr->exp60, 0, 96);
  858. + rdr->key3310_length = 0;
  859. + memset(rdr->key3310, 0, 16);
  860. }
  861. else
  862. {
  863. - if(key_atob_l(value, rdr->exp60, len))
  864. + if(key_atob_l(value, rdr->key3310, len))
  865. {
  866. - fprintf(stderr, "reader exp60 parse error, %s=%s\n", token, value);
  867. - rdr->exp60_length = 0;
  868. - memset(rdr->exp60, 0, sizeof(rdr->exp60));
  869. + fprintf(stderr, "reader key3310 parse error, %s=%s\n", token, value);
  870. + rdr->key3310_length = 0;
  871. + memset(rdr->key3310, 0, sizeof(rdr->key3310));
  872. }
  873. else
  874. {
  875. - rdr->exp60_length = len/2;
  876. + rdr->key3310_length = len/2;
  877. }
  878. }
  879. return;
  880. }
  881. - int32_t len = rdr->exp60_length;
  882. + int32_t len = rdr->key3310_length;
  883. if(len > 0)
  884. {
  885. char tmp[len * 2 + 1];
  886. - fprintf_conf(f, "exp60", "%s\n", cs_hexdump(0, rdr->exp60, len, tmp, sizeof(tmp)));
  887. + fprintf_conf(f, "key3310", "%s\n", cs_hexdump(0, rdr->key3310, len, tmp, sizeof(tmp)));
  888. }
  889. else if(cfg.http_full_cfg)
  890. - { fprintf_conf(f, "exp60", "\n"); }
  891. + { fprintf_conf(f, "key3310", "\n"); }
  892. }
  893.  
  894. static void nuid_fn(const char *token, char *value, void *setting, FILE *f)
  895. @@ -552,7 +733,187 @@
  896. { fprintf_conf(f, "nuid", "\n"); }
  897. }
  898.  
  899. -static void cwekey_fn(const char *token, char *value, void *setting, FILE *f)
  900. +static void cwekey0_fn(const char *token, char *value, void *setting, FILE *f)
  901. +{
  902. + struct s_reader *rdr = setting;
  903. + if(value)
  904. + {
  905. + int32_t len = strlen(value);
  906. + if(len != 32)
  907. + {
  908. + rdr->cwekey0_length = 0;
  909. + memset(rdr->cwekey0, 0, 16);
  910. + }
  911. + else
  912. + {
  913. + if(key_atob_l(value, rdr->cwekey0, len))
  914. + {
  915. + fprintf(stderr, "reader cwekey0 parse error, %s=%s\n", token, value);
  916. + rdr->cwekey0_length = 0;
  917. + memset(rdr->cwekey0, 0, sizeof(rdr->cwekey0));
  918. + }
  919. + else
  920. + {
  921. + rdr->cwekey0_length = len/2;
  922. + }
  923. + }
  924. + return;
  925. + }
  926. + int32_t len = rdr->cwekey0_length;
  927. + if(len > 0)
  928. + {
  929. + char tmp[len * 2 + 1];
  930. + fprintf_conf(f, "cwekey0", "%s\n", cs_hexdump(0, rdr->cwekey0, len, tmp, sizeof(tmp)));
  931. + }
  932. + else if(cfg.http_full_cfg)
  933. + { fprintf_conf(f, "cwekey0", "\n"); }
  934. +}
  935. +
  936. +static void cwekey1_fn(const char *token, char *value, void *setting, FILE *f)
  937. +{
  938. + struct s_reader *rdr = setting;
  939. + if(value)
  940. + {
  941. + int32_t len = strlen(value);
  942. + if(len != 32)
  943. + {
  944. + rdr->cwekey1_length = 0;
  945. + memset(rdr->cwekey1, 0, 16);
  946. + }
  947. + else
  948. + {
  949. + if(key_atob_l(value, rdr->cwekey1, len))
  950. + {
  951. + fprintf(stderr, "reader cwekey1 parse error, %s=%s\n", token, value);
  952. + rdr->cwekey1_length = 0;
  953. + memset(rdr->cwekey1, 0, sizeof(rdr->cwekey1));
  954. + }
  955. + else
  956. + {
  957. + rdr->cwekey1_length = len/2;
  958. + }
  959. + }
  960. + return;
  961. + }
  962. + int32_t len = rdr->cwekey1_length;
  963. + if(len > 0)
  964. + {
  965. + char tmp[len * 2 + 1];
  966. + fprintf_conf(f, "cwekey1", "%s\n", cs_hexdump(0, rdr->cwekey1, len, tmp, sizeof(tmp)));
  967. + }
  968. + else if(cfg.http_full_cfg)
  969. + { fprintf_conf(f, "cwekey1", "\n"); }
  970. +}
  971. +
  972. +static void cwekey2_fn(const char *token, char *value, void *setting, FILE *f)
  973. +{
  974. + struct s_reader *rdr = setting;
  975. + if(value)
  976. + {
  977. + int32_t len = strlen(value);
  978. + if(len != 32)
  979. + {
  980. + rdr->cwekey2_length = 0;
  981. + memset(rdr->cwekey2, 0, 16);
  982. + }
  983. + else
  984. + {
  985. + if(key_atob_l(value, rdr->cwekey2, len))
  986. + {
  987. + fprintf(stderr, "reader cwekey2 parse error, %s=%s\n", token, value);
  988. + rdr->cwekey2_length = 0;
  989. + memset(rdr->cwekey2, 0, sizeof(rdr->cwekey2));
  990. + }
  991. + else
  992. + {
  993. + rdr->cwekey2_length = len/2;
  994. + }
  995. + }
  996. + return;
  997. + }
  998. + int32_t len = rdr->cwekey2_length;
  999. + if(len > 0)
  1000. + {
  1001. + char tmp[len * 2 + 1];
  1002. + fprintf_conf(f, "cwekey2", "%s\n", cs_hexdump(0, rdr->cwekey2, len, tmp, sizeof(tmp)));
  1003. + }
  1004. + else if(cfg.http_full_cfg)
  1005. + { fprintf_conf(f, "cwekey2", "\n"); }
  1006. +}
  1007. +
  1008. +static void cwekey3_fn(const char *token, char *value, void *setting, FILE *f)
  1009. +{
  1010. + struct s_reader *rdr = setting;
  1011. + if(value)
  1012. + {
  1013. + int32_t len = strlen(value);
  1014. + if(len != 32)
  1015. + {
  1016. + rdr->cwekey3_length = 0;
  1017. + memset(rdr->cwekey3, 0, 16);
  1018. + }
  1019. + else
  1020. + {
  1021. + if(key_atob_l(value, rdr->cwekey3, len))
  1022. + {
  1023. + fprintf(stderr, "reader cwekey3 parse error, %s=%s\n", token, value);
  1024. + rdr->cwekey3_length = 0;
  1025. + memset(rdr->cwekey3, 0, sizeof(rdr->cwekey3));
  1026. + }
  1027. + else
  1028. + {
  1029. + rdr->cwekey3_length = len/2;
  1030. + }
  1031. + }
  1032. + return;
  1033. + }
  1034. + int32_t len = rdr->cwekey3_length;
  1035. + if(len > 0)
  1036. + {
  1037. + char tmp[len * 2 + 1];
  1038. + fprintf_conf(f, "cwekey3", "%s\n", cs_hexdump(0, rdr->cwekey3, len, tmp, sizeof(tmp)));
  1039. + }
  1040. + else if(cfg.http_full_cfg)
  1041. + { fprintf_conf(f, "cwekey3", "\n"); }
  1042. +}
  1043. +
  1044. +static void cwekey4_fn(const char *token, char *value, void *setting, FILE *f)
  1045. +{
  1046. + struct s_reader *rdr = setting;
  1047. + if(value)
  1048. + {
  1049. + int32_t len = strlen(value);
  1050. + if(len != 32)
  1051. + {
  1052. + rdr->cwekey4_length = 0;
  1053. + memset(rdr->cwekey4, 0, 16);
  1054. + }
  1055. + else
  1056. + {
  1057. + if(key_atob_l(value, rdr->cwekey4, len))
  1058. + {
  1059. + fprintf(stderr, "reader cwekey4 parse error, %s=%s\n", token, value);
  1060. + rdr->cwekey4_length = 0;
  1061. + memset(rdr->cwekey4, 0, sizeof(rdr->cwekey4));
  1062. + }
  1063. + else
  1064. + {
  1065. + rdr->cwekey4_length = len/2;
  1066. + }
  1067. + }
  1068. + return;
  1069. + }
  1070. + int32_t len = rdr->cwekey4_length;
  1071. + if(len > 0)
  1072. + {
  1073. + char tmp[len * 2 + 1];
  1074. + fprintf_conf(f, "cwekey4", "%s\n", cs_hexdump(0, rdr->cwekey4, len, tmp, sizeof(tmp)));
  1075. + }
  1076. + else if(cfg.http_full_cfg)
  1077. + { fprintf_conf(f, "cwekey4", "\n"); }
  1078. +}
  1079. +
  1080. +static void cwekey5_fn(const char *token, char *value, void *setting, FILE *f)
  1081. {
  1082. struct s_reader *rdr = setting;
  1083. if(value)
  1084. @@ -560,32 +921,104 @@
  1085. int32_t len = strlen(value);
  1086. if(len != 32)
  1087. {
  1088. - rdr->cwekey_length = 0;
  1089. - memset(rdr->cwekey, 0, 16);
  1090. + rdr->cwekey5_length = 0;
  1091. + memset(rdr->cwekey5, 0, 16);
  1092. }
  1093. else
  1094. {
  1095. - if(key_atob_l(value, rdr->cwekey, len))
  1096. + if(key_atob_l(value, rdr->cwekey5, len))
  1097. {
  1098. - fprintf(stderr, "reader cwekey parse error, %s=%s\n", token, value);
  1099. - rdr->cwekey_length = 0;
  1100. - memset(rdr->cwekey, 0, sizeof(rdr->cwekey));
  1101. + fprintf(stderr, "reader cwekey5 parse error, %s=%s\n", token, value);
  1102. + rdr->cwekey5_length = 0;
  1103. + memset(rdr->cwekey5, 0, sizeof(rdr->cwekey5));
  1104. }
  1105. else
  1106. {
  1107. - rdr->cwekey_length = len/2;
  1108. + rdr->cwekey5_length = len/2;
  1109. }
  1110. }
  1111. return;
  1112. }
  1113. - int32_t len = rdr->cwekey_length;
  1114. + int32_t len = rdr->cwekey5_length;
  1115. if(len > 0)
  1116. {
  1117. char tmp[len * 2 + 1];
  1118. - fprintf_conf(f, "cwekey", "%s\n", cs_hexdump(0, rdr->cwekey, len, tmp, sizeof(tmp)));
  1119. + fprintf_conf(f, "cwekey5", "%s\n", cs_hexdump(0, rdr->cwekey5, len, tmp, sizeof(tmp)));
  1120. }
  1121. else if(cfg.http_full_cfg)
  1122. - { fprintf_conf(f, "cwekey", "\n"); }
  1123. + { fprintf_conf(f, "cwekey5", "\n"); }
  1124. +}
  1125. +
  1126. +static void cwekey6_fn(const char *token, char *value, void *setting, FILE *f)
  1127. +{
  1128. + struct s_reader *rdr = setting;
  1129. + if(value)
  1130. + {
  1131. + int32_t len = strlen(value);
  1132. + if(len != 32)
  1133. + {
  1134. + rdr->cwekey6_length = 0;
  1135. + memset(rdr->cwekey6, 0, 16);
  1136. + }
  1137. + else
  1138. + {
  1139. + if(key_atob_l(value, rdr->cwekey6, len))
  1140. + {
  1141. + fprintf(stderr, "reader cwekey6 parse error, %s=%s\n", token, value);
  1142. + rdr->cwekey6_length = 0;
  1143. + memset(rdr->cwekey6, 0, sizeof(rdr->cwekey6));
  1144. + }
  1145. + else
  1146. + {
  1147. + rdr->cwekey6_length = len/2;
  1148. + }
  1149. + }
  1150. + return;
  1151. + }
  1152. + int32_t len = rdr->cwekey6_length;
  1153. + if(len > 0)
  1154. + {
  1155. + char tmp[len * 2 + 1];
  1156. + fprintf_conf(f, "cwekey6", "%s\n", cs_hexdump(0, rdr->cwekey6, len, tmp, sizeof(tmp)));
  1157. + }
  1158. + else if(cfg.http_full_cfg)
  1159. + { fprintf_conf(f, "cwekey6", "\n"); }
  1160. +}
  1161. +
  1162. +static void cwekey7_fn(const char *token, char *value, void *setting, FILE *f)
  1163. +{
  1164. + struct s_reader *rdr = setting;
  1165. + if(value)
  1166. + {
  1167. + int32_t len = strlen(value);
  1168. + if(len != 32)
  1169. + {
  1170. + rdr->cwekey7_length = 0;
  1171. + memset(rdr->cwekey7, 0, 16);
  1172. + }
  1173. + else
  1174. + {
  1175. + if(key_atob_l(value, rdr->cwekey7, len))
  1176. + {
  1177. + fprintf(stderr, "reader cwekey7 parse error, %s=%s\n", token, value);
  1178. + rdr->cwekey7_length = 0;
  1179. + memset(rdr->cwekey7, 0, sizeof(rdr->cwekey7));
  1180. + }
  1181. + else
  1182. + {
  1183. + rdr->cwekey7_length = len/2;
  1184. + }
  1185. + }
  1186. + return;
  1187. + }
  1188. + int32_t len = rdr->cwekey7_length;
  1189. + if(len > 0)
  1190. + {
  1191. + char tmp[len * 2 + 1];
  1192. + fprintf_conf(f, "cwekey7", "%s\n", cs_hexdump(0, rdr->cwekey7, len, tmp, sizeof(tmp)));
  1193. + }
  1194. + else if(cfg.http_full_cfg)
  1195. + { fprintf_conf(f, "cwekey7", "\n"); }
  1196. }
  1197. #endif
  1198.  
  1199. @@ -1091,6 +1524,7 @@
  1200. DEF_OPT_INT32("reconnecttimeout" , OFS(tcp_rto), DEFAULT_TCP_RECONNECT_TIMEOUT),
  1201. DEF_OPT_INT32("reconnectdelay" , OFS(tcp_reconnect_delay), 60000),
  1202. DEF_OPT_INT32("resetcycle" , OFS(resetcycle), 0),
  1203. + DEF_OPT_INT32("wdelay" , OFS(wdelay), 0),
  1204. DEF_OPT_INT8("disableserverfilter" , OFS(ncd_disable_server_filt), 0),
  1205. DEF_OPT_INT8("connectoninit" , OFS(ncd_connect_on_init), 0),
  1206. DEF_OPT_UINT8("keepalive" , OFS(keepalive), 0),
  1207. @@ -1115,16 +1549,33 @@
  1208. DEF_OPT_FUNC("boxid" , 0, boxid_fn),
  1209. DEF_OPT_FUNC("boxkey" , 0, boxkey_fn),
  1210. DEF_OPT_FUNC("rsakey" , 0, rsakey_fn),
  1211. + DEF_OPT_FUNC("cwpkkey" , 0, cwpkkey_fn),
  1212. DEF_OPT_FUNC("deskey" , 0, deskey_fn),
  1213. #ifdef READER_NAGRA_MERLIN
  1214. DEF_OPT_FUNC("mod1" , 0, mod1_fn),
  1215. + DEF_OPT_FUNC("idird" , 0, idird_fn),
  1216. + DEF_OPT_FUNC("cmd0eprov" , 0, cmd0eprov_fn),
  1217. + DEF_OPT_FUNC("mod2" , 0, mod2_fn),
  1218. + DEF_OPT_FUNC("key3588" , 0, key3588_fn),
  1219. + DEF_OPT_FUNC("key3460" , 0, key3460_fn),
  1220. + DEF_OPT_FUNC("key3310" , 0, key3310_fn),
  1221. DEF_OPT_FUNC("data50" , 0, data50_fn),
  1222. DEF_OPT_FUNC("mod50" , 0, mod50_fn),
  1223. - DEF_OPT_FUNC("key60" , 0, key60_fn),
  1224. - DEF_OPT_FUNC("exp60" , 0, exp60_fn),
  1225. DEF_OPT_FUNC("nuid" , 0, nuid_fn),
  1226. - DEF_OPT_FUNC("cwekey" , 0, cwekey_fn),
  1227. + DEF_OPT_FUNC("cwekey0" , 0, cwekey0_fn),
  1228. + DEF_OPT_FUNC("cwekey1" , 0, cwekey1_fn),
  1229. + DEF_OPT_FUNC("cwekey2" , 0, cwekey2_fn),
  1230. + DEF_OPT_FUNC("cwekey3" , 0, cwekey3_fn),
  1231. + DEF_OPT_FUNC("cwekey4" , 0, cwekey4_fn),
  1232. + DEF_OPT_FUNC("cwekey5" , 0, cwekey5_fn),
  1233. + DEF_OPT_FUNC("cwekey6" , 0, cwekey6_fn),
  1234. + DEF_OPT_FUNC("cwekey7" , 0, cwekey7_fn),
  1235. + DEF_OPT_INT8("forcecwswap" , OFS(forcecwswap), 0),
  1236. + DEF_OPT_INT8("evensa" , OFS(evensa), 0),
  1237. + DEF_OPT_INT8("forceemmg" , OFS(forceemmg), 0),
  1238. #endif
  1239. +
  1240. + DEF_OPT_INT8("cak7_mode" , OFS(cak7_mode), 0),
  1241. DEF_OPT_FUNC_X("ins7e" , OFS(ins7E), ins7E_fn, SIZEOF(ins7E)),
  1242. DEF_OPT_FUNC_X("ins7e11" , OFS(ins7E11), ins7E_fn, SIZEOF(ins7E11)),
  1243. DEF_OPT_FUNC_X("ins2e06" , OFS(ins2e06), ins7E_fn, SIZEOF(ins2e06)),
  1244. @@ -1200,6 +1651,7 @@
  1245. #endif
  1246. DEF_OPT_INT8("deprecated" , OFS(deprecated), 0),
  1247. DEF_OPT_INT8("audisabled" , OFS(audisabled), 0),
  1248. + DEF_OPT_INT8("autype" , OFS(autype), 0),
  1249. DEF_OPT_FUNC("auprovid" , 0, auprovid_fn),
  1250. DEF_OPT_INT8("ndsversion" , OFS(ndsversion), 0),
  1251. DEF_OPT_FUNC("ratelimitecm" , 0, ratelimitecm_fn),
  1252. @@ -1230,15 +1682,18 @@
  1253. // These are written only when the reader is physical reader
  1254. static const char *hw_only_settings[] =
  1255. {
  1256. - "readnano", "resetcycle", "smargopatch", "autospeed", "sc8in1_dtrrts_patch", "boxid","fix07",
  1257. + "readnano", "resetcycle", "wdelay", "smargopatch", "autospeed", "sc8in1_dtrrts_patch", "boxid","fix07",
  1258. "fix9993", "rsakey", "deskey", "ins7e", "ins7e11", "ins2e06", "force_irdeto", "needsemmfirst", "boxkey",
  1259. "atr", "detect", "nagra_read", "mhz", "cardmhz", "readtiers", "read_old_classes", "use_gpio", "needsglobalfirst",
  1260. #ifdef READER_NAGRA_MERLIN
  1261. - "mod1", "data50", "mod50", "key60", "exp60", "nuid", "cwekey",
  1262. + "mod1", "idird", "cmd0eprov", "mod2", "key3588", "key3460", "key3310", "data50", "mod50", "nuid", "cwekey0", "cwekey1", "cwekey2", "cwekey3", "cwekey4", "cwekey5", "cwekey6", "cwekey7",
  1263. #endif
  1264. #if defined(READER_DRE) || defined(READER_DRECAS)
  1265. "exec_cmd_file",
  1266. #endif
  1267. +#if READER_CONAX
  1268. + "cwpkkey",
  1269. +#endif
  1270. #ifdef WITH_AZBOX
  1271. "mode",
  1272. #endif
  1273. @@ -1248,7 +1703,7 @@
  1274. // These are written only when the reader is network reader
  1275. static const char *network_only_settings[] =
  1276. {
  1277. - "user", "inactivitytimeout", "reconnecttimeout",
  1278. + "user", "inactivitytimeout", "reconnecttimeout", "autype",
  1279. 0
  1280. };
  1281. if(is_network_reader(reader))
  1282. Index: reader-common.c
  1283. --- reader-common.c 2019-11-09 21:23:01.657445374 +0100
  1284. +++ reader-common.c 2019-11-09 20:46:21.695589217 +0100
  1285. @@ -37,6 +37,7 @@
  1286. reader->csystem = NULL;
  1287. memset(reader->hexserial, 0, sizeof(reader->hexserial));
  1288. memset(reader->prid, 0xFF, sizeof(reader->prid));
  1289. + memset(reader->sa, 0, sizeof(reader->sa));
  1290. reader->caid = 0;
  1291. reader->nprov = 0;
  1292. cs_clear_entitlement(reader);
  1293. Index: reader-conax.c
  1294. --- reader-conax.c 2019-11-09 21:23:02.077442621 +0100
  1295. +++ reader-conax.c 2019-11-09 21:16:00.252204938 +0100
  1296. @@ -2,6 +2,91 @@
  1297. #ifdef READER_CONAX
  1298. #include "cscrypt/bn.h"
  1299. #include "reader-common.h"
  1300. +#include "cscrypt/des.h"
  1301. +
  1302. +static int32_t CWPK_CNX(struct s_reader *reader,uint8_t *msg)
  1303. +{
  1304. +int32_t ret = 0;
  1305. +
  1306. +uint8_t CWp1[8];
  1307. +uint8_t CWp2[8];
  1308. +uint8_t CWs1[8];
  1309. +uint8_t CWs2[8];
  1310. +
  1311. +CWp1[0] = msg[7];
  1312. +CWp1[1] = msg[8];
  1313. +CWp1[2] = msg[9];
  1314. +CWp1[3] = msg[10];
  1315. +CWp1[4] = msg[11];
  1316. +CWp1[5] = msg[12];
  1317. +CWp1[6] = msg[13];
  1318. +CWp1[7] = msg[14];
  1319. +
  1320. +CWp2[0] = msg[22];
  1321. +CWp2[1] = msg[23];
  1322. +CWp2[2] = msg[24];
  1323. +CWp2[3] = msg[25];
  1324. +CWp2[4] = msg[26];
  1325. +CWp2[5] = msg[27];
  1326. +CWp2[6] = msg[28];
  1327. +CWp2[7] = msg[29];
  1328. +
  1329. +des_ecb3_decrypt(CWp1,reader->cwpk_mod);
  1330. +des_ecb3_decrypt(CWp2,reader->cwpk_mod);
  1331. +CWs1[0] = CWp1[4];
  1332. +CWs1[1] = CWp1[5];
  1333. +CWs1[2] = CWp1[6];
  1334. +CWs1[3] = CWp1[7];
  1335. +CWs1[4] = CWp1[0];
  1336. +CWs1[5] = CWp1[1];
  1337. +CWs1[6] = CWp1[2];
  1338. +CWs1[7] = CWp1[3];
  1339. +
  1340. +CWs2[0] = CWp2[4];
  1341. +CWs2[1] = CWp2[5];
  1342. +CWs2[2] = CWp2[6];
  1343. +CWs2[3] = CWp2[7];
  1344. +CWs2[4] = CWp2[0];
  1345. +CWs2[5] = CWp2[1];
  1346. +CWs2[6] = CWp2[2];
  1347. +CWs2[7] = CWp2[3];
  1348. +
  1349. +int chkok = 1;
  1350. +if(((CWs1[0] + CWs1[1] + CWs1[2]) & 0xFF) != CWs1[3])
  1351. +{
  1352. + chkok = 0;
  1353. + rdr_log(reader, "CW0 checksum error [0]");
  1354. +}
  1355. +if(((CWs1[4] + CWs1[5] + CWs1[6]) & 0xFF) != CWs1[7])
  1356. +{
  1357. + chkok = 0;
  1358. + rdr_log(reader, "CW0 checksum error [1]");
  1359. +}
  1360. +if(((CWs2[0] + CWs2[1] + CWs2[2]) & 0xFF) != CWs2[3])
  1361. +{
  1362. + chkok = 0;
  1363. + rdr_log(reader, "CW1 checksum error [0]");
  1364. +}
  1365. +if(((CWs2[4] + CWs2[5] + CWs2[6]) & 0xFF) != CWs2[7])
  1366. +{
  1367. + chkok = 0;
  1368. + rdr_log(reader, "CW1 checksum error [1]");
  1369. +}
  1370. +
  1371. +if(chkok == 1)
  1372. +{
  1373. + memcpy(&msg[7],CWs1,0x08);
  1374. + memcpy(&msg[22],CWs2,0x08);
  1375. +
  1376. + ret = 0;
  1377. +}
  1378. +if(chkok != 1)
  1379. +{
  1380. + ret = -8;
  1381. +}
  1382. +
  1383. +return ret;
  1384. +}
  1385.  
  1386. static int32_t RSA_CNX(struct s_reader *reader, uint8_t *msg, uint8_t *mod, uint8_t *exp, uint32_t cta_lr, uint32_t modbytes, uint32_t expbytes)
  1387. {
  1388. @@ -114,6 +199,26 @@
  1389. return (cta_lr - 2);
  1390. }
  1391.  
  1392. +static int32_t check_pairing(struct s_reader *reader, const uint8_t *cmd, const uint8_t *data, uint8_t *cta_res)
  1393. +{
  1394. + uint16_t cta_lr;
  1395. +
  1396. + if(reader->cwpk_mod_length)
  1397. + {
  1398. + write_cmd(cmd, data);
  1399. + rdr_log(reader, "CWPK Pairing is active");
  1400. + }
  1401. + else if(reader->rsa_mod_length)
  1402. + {
  1403. + rdr_log(reader, "RSA Pairing is active");
  1404. + }
  1405. + else
  1406. + {
  1407. + rdr_log(reader, "Pairing is not active");
  1408. + }
  1409. + return OK;
  1410. +}
  1411. +
  1412. static uint8_t PairingECMRotation(struct s_reader *reader, const ECM_REQUEST *er, int32_t n)
  1413. {
  1414. uint8_t cta_res[CTA_RES_LEN] = { 0x00 };
  1415. @@ -147,6 +252,7 @@
  1416. uint8_t cta_res[CTA_RES_LEN];
  1417. int32_t i, j, n;
  1418. static const uint8_t ins26[] = { 0xDD, 0x26, 0x00, 0x00, 0x03, 0x10, 0x01, 0x40 };
  1419. + static const uint8_t inscp[] = { 0xDD, 0x26, 0x00, 0x00, 0x04, 0x6C, 0x02, 0x10,0x00 };
  1420. uint8_t ins82[] = { 0xDD, 0x82, 0x00, 0x00, 0x11, 0x11, 0x0f, 0x01, 0xb0, 0x0f, 0xff,
  1421. 0xff, 0xfb, 0x00, 0x00, 0x09, 0x04, 0x0b, 0x00, 0xe0, 0x30, 0x2b };
  1422.  
  1423. @@ -213,6 +319,7 @@
  1424. rdr_log(reader, "Provider: %d Provider-Id: %06X", j + 1, b2i(4, reader->prid[j]));
  1425. rdr_log_sensitive(reader, "Provider: %d SharedAddress: {%08X}", j + 1, b2i(4, reader->sa[j]));
  1426. }
  1427. + check_pairing(reader, inscp, inscp + 5, cta_res);
  1428.  
  1429. return OK;
  1430. }
  1431. @@ -239,16 +346,37 @@
  1432. uint8_t exp[] = { 0x01, 0x00, 0x01 };
  1433. uint8_t buf[256];
  1434.  
  1435. + char ppp = 0x00;
  1436. +
  1437. if((n = check_sct_len(er->ecm, 3)) < 0)
  1438. { return ERROR; }
  1439.  
  1440. buf[0] = 0x14;
  1441. buf[1] = n + 1;
  1442.  
  1443. - if(0x0 != PairingECMRotation(reader, er, n))
  1444. - { buf[2] = 2; } // card will answer with encrypted dw
  1445. + if(reader->cwpk_mod_length)
  1446. + {
  1447. + buf[2] = 4;
  1448. + ppp = 0x01;
  1449. + }
  1450. + else if(0x0 != reader->rsa_mod[0])
  1451. + {
  1452. + if(0x0 != PairingECMRotation(reader, er, n))
  1453. + {
  1454. + buf[2] = 2;
  1455. + ppp = 0x03;
  1456. + }
  1457. + else
  1458. + {
  1459. + buf[2] = 0;
  1460. + ppp = 0x02;
  1461. + }
  1462. + }
  1463. else
  1464. - { buf[2] = 0; }
  1465. + {
  1466. + buf[2] = 0;
  1467. + ppp = 0x02;
  1468. + }
  1469.  
  1470. memcpy(buf + 3, er->ecm, n);
  1471. insA2[4] = n + 3;
  1472. @@ -263,13 +391,20 @@
  1473. if((cta_res[cta_lr - 2] == 0x98) || ((cta_res[cta_lr - 2] == 0x90)))
  1474. {
  1475. /*checks if answer is encrypted with RSA algo and decrypts it if needed*/
  1476. - if(0x81 == cta_res[0] && 2 == cta_res[2] >> 5) /*81 XX 5X*/
  1477. + if(0x81 == cta_res[0] && 2 == cta_res[2] >> 5 && 0x03 == ppp) /*81 XX 5X*/
  1478. {
  1479. if(0x00 == cta_res[cta_lr - 1])
  1480. { rc = RSA_CNX(reader, cta_res, reader->rsa_mod, exp, cta_lr, 64u, 3u); }
  1481. else
  1482. { rc = -4; } /*card has no right to decode this channel*/
  1483. }
  1484. + if(0x01 == ppp && 0x00 == cta_res[cta_lr - 1])
  1485. + {
  1486. + /*trying to decode using CWPK*/
  1487. + rc = CWPK_CNX(reader, cta_res); /*enabled when no loging needed*/
  1488. + }
  1489. + if(0x12 == cta_res[cta_lr - 1])
  1490. + { rc = -4; }
  1491.  
  1492. if(0 == rc)
  1493. {
  1494. @@ -341,6 +476,10 @@
  1495. case -4:
  1496. rdr_log(reader, "card has no right to decode this channel");
  1497. break;
  1498. +
  1499. + case -8:
  1500. + rdr_log(reader, "CWPK is faulty");
  1501. + break;
  1502. }
  1503.  
  1504. /* answer 9011 - conax smart card need reset */
  1505. Index: reader-nagra.c
  1506. --- reader-nagra.c 2019-11-09 21:23:02.077442621 +0100
  1507. +++ reader-nagra.c 2019-11-09 20:46:21.711589109 +0100
  1508. @@ -792,7 +792,7 @@
  1509. }
  1510. memcpy(reader->rom, cta_res + 2, 15);
  1511. }
  1512. - else if(reader->detect_seca_nagra_tunneled_card && memcmp(atr + 7, "pp", 2) == 0 && ((atr[9]&0x0F) >= 10))
  1513. + else if(!reader->cak7_mode && reader->detect_seca_nagra_tunneled_card && memcmp(atr + 7, "pp", 2) == 0 && ((atr[9]&0x0F) >= 10))
  1514. {
  1515. rdr_log(reader, "detect seca/nagra tunneled card");
  1516.  
  1517. Index: reader-nagra-common.c
  1518. --- reader-nagra-common.c 2019-11-09 21:23:02.069442673 +0100
  1519. +++ reader-nagra-common.c 2019-11-09 20:46:21.711589109 +0100
  1520. @@ -2,83 +2,470 @@
  1521. #include "reader-common.h"
  1522. #include "reader-nagra-common.h"
  1523.  
  1524. -// returns 1 if shared emm matches SA, unique emm matches serial, or global or unknown
  1525. +int32_t get_prov_idx(struct s_reader *rdr, const uint8_t *provid)
  1526. +{
  1527. + int prov;
  1528. + for(prov = 0; prov < rdr->nprov; prov++) // search for provider index
  1529. + {
  1530. + if(!memcmp(provid, &rdr->prid[prov][2], 2))
  1531. + {
  1532. + return (prov);
  1533. + }
  1534. + }
  1535. + return (-1);
  1536. +}
  1537. +
  1538. int32_t nagra_get_emm_type(EMM_PACKET *ep, struct s_reader *rdr)
  1539. {
  1540. - switch(ep->emm[0])
  1541. + if(rdr->cak7type == 3 || rdr->autype == 1)
  1542. {
  1543. - case 0x83:
  1544. - memset(ep->hexserial, 0x00, 0x08);
  1545. - ep->hexserial[0] = ep->emm[5];
  1546. - ep->hexserial[1] = ep->emm[4];
  1547. - ep->hexserial[2] = ep->emm[3];
  1548. - if(ep->emm[7] == 0x10)
  1549. - {
  1550. - ep->type = SHARED;
  1551. - return (!memcmp(rdr->sa[0], ep->hexserial, 0x03));
  1552. - }
  1553. - else
  1554. - {
  1555. - ep->hexserial[3] = ep->emm[6];
  1556. + int i;
  1557. +
  1558. + switch(ep->emm[0])
  1559. + {
  1560. + case 0x82:
  1561. ep->type = UNIQUE;
  1562. - return (!memcmp(rdr->hexserial + 2, ep->hexserial, 0x04));
  1563. - }
  1564. + memset(ep->hexserial, 0, 8);
  1565. + memcpy(ep->hexserial, ep->emm + 3, 6);
  1566.  
  1567. - case 0x82:
  1568. - ep->type = GLOBAL;
  1569. - return 1;
  1570. + return (!memcmp(rdr->hexserial, ep->hexserial, 6));
  1571.  
  1572. - default:
  1573. - ep->type = UNKNOWN;
  1574. - return 1;
  1575. + case 0x84:
  1576. + ep->type = SHARED;
  1577. + memset(ep->hexserial, 0, 8);
  1578. + memcpy(ep->hexserial, ep->emm + 5, 3);
  1579. + i = get_prov_idx(rdr, ep->emm + 3);
  1580. +
  1581. + if(i == -1)
  1582. + {
  1583. + return 0;
  1584. + }
  1585. +
  1586. + return (!memcmp(rdr->sa[i], ep->hexserial, 3));
  1587. +
  1588. + case 0x83:
  1589. + ep->type = GLOBAL;
  1590. + uint8_t filtr[] = {0x83, 0x00, 0x74};
  1591. + return (!memcmp(ep->emm, filtr, 3));
  1592. +
  1593. + default:
  1594. + ep->type = UNKNOWN;
  1595. + return 0;
  1596. + }
  1597. + }
  1598. + else if(rdr->cak7type == 1)
  1599. + {
  1600. + int i;
  1601. + switch(ep->emm[0])
  1602. + {
  1603. + case 0x82:
  1604. + ep->type = GLOBAL;
  1605. + if(rdr->emm82 == 1)
  1606. + {
  1607. + return 1;
  1608. + }
  1609. + return 0;
  1610. +
  1611. + case 0x83:
  1612. + if(ep->emm[7] == 0x10)
  1613. + {
  1614. + ep->type = SHARED;
  1615. +
  1616. + for(i = 0; i < rdr->nemm83s; i++)
  1617. + {
  1618. + if(!memcmp(rdr->emm83s[i] + 1, ep->emm + 3, 0x03))
  1619. + {
  1620. + return 1;
  1621. + }
  1622. + }
  1623. + }
  1624. + else
  1625. + {
  1626. + ep->type = UNIQUE;
  1627. +
  1628. + for(i = 0; i < rdr->nemm83u; i++)
  1629. + {
  1630. + if(!memcmp(rdr->emm83u[i] + 1, ep->emm + 3, 0x04))
  1631. + {
  1632. + return 1;
  1633. + }
  1634. + }
  1635. + }
  1636. + return 0;
  1637. +
  1638. + case 0x84:
  1639. + ep->type = GLOBAL;
  1640. +
  1641. + for(i = 0; i < rdr->nemm84; i++)
  1642. + {
  1643. + if(!memcmp(rdr->emm84[i] + 1, ep->emm + 3, 0x02))
  1644. + {
  1645. + return 1;
  1646. + }
  1647. + }
  1648. + return 0;
  1649. +
  1650. + case 0x87:
  1651. + ep->type = SHARED;
  1652. +
  1653. + for(i = 0; i < rdr->nemm87; i++)
  1654. + {
  1655. + if(!memcmp(rdr->emm87[i] + 1, ep->emm + 3, 0x03))
  1656. + {
  1657. + return 1;
  1658. + }
  1659. + }
  1660. + return 0;
  1661. +
  1662. + default:
  1663. + ep->type = UNKNOWN;
  1664. + return 0;
  1665. + }
  1666. + }
  1667. + else if(rdr->autype == 2)
  1668. + {
  1669. + int i;
  1670. + switch(ep->emm[0])
  1671. + {
  1672. + case 0x82:
  1673. + ep->type = GLOBAL;
  1674. + return 1;
  1675. +
  1676. + case 0x83:
  1677. + memset(ep->hexserial, 0x00, 0x08);
  1678. + ep->hexserial[0] = ep->emm[5];
  1679. + ep->hexserial[1] = ep->emm[4];
  1680. + ep->hexserial[2] = ep->emm[3];
  1681. + if(ep->emm[7] == 0x10)
  1682. + {
  1683. + ep->type = SHARED;
  1684. +
  1685. + for(i = 0; i < rdr->nprov; i++)
  1686. + {
  1687. + if(!memcmp(rdr->sa[i], "\x00\x00\x00", 3))
  1688. + {
  1689. + continue;
  1690. + }
  1691. +
  1692. + if(!memcmp(rdr->sa[i], ep->hexserial, 0x03))
  1693. + {
  1694. + return 1;
  1695. + }
  1696. + }
  1697. + }
  1698. + else
  1699. + {
  1700. + ep->hexserial[3] = ep->emm[6];
  1701. + ep->type = UNIQUE;
  1702. +
  1703. + return (!memcmp(rdr->hexserial + 2, ep->hexserial, 0x04));
  1704. + }
  1705. + return 0;
  1706. +
  1707. + case 0x84:
  1708. + ep->type = GLOBAL;
  1709. + return 1;
  1710. +
  1711. + case 0x87:
  1712. + memset(ep->hexserial, 0x00, 0x08);
  1713. + ep->hexserial[0] = ep->emm[5];
  1714. + ep->hexserial[1] = ep->emm[4];
  1715. + ep->hexserial[2] = ep->emm[3];
  1716. + ep->type = SHARED;
  1717. +
  1718. + for(i = 0; i < rdr->nprov; i++)
  1719. + {
  1720. + if(!memcmp(rdr->sa[i], "\x00\x00\x00", 3))
  1721. + {
  1722. + continue;
  1723. + }
  1724. + if(!memcmp(rdr->sa[i], ep->hexserial, 0x03))
  1725. + {
  1726. + return 1;
  1727. + }
  1728. + }
  1729. + return 0;
  1730. +
  1731. + default:
  1732. + ep->type = UNKNOWN;
  1733. + return 0;
  1734. + }
  1735. + }
  1736. + else
  1737. + {
  1738. + switch(ep->emm[0])
  1739. + {
  1740. + case 0x83:
  1741. + memset(ep->hexserial, 0x00, 0x08);
  1742. + ep->hexserial[0] = ep->emm[5];
  1743. + ep->hexserial[1] = ep->emm[4];
  1744. + ep->hexserial[2] = ep->emm[3];
  1745. + if(ep->emm[7] == 0x10)
  1746. + {
  1747. + ep->type = SHARED;
  1748. + return (!memcmp(rdr->sa[0], ep->hexserial, 0x03));
  1749. + }
  1750. + else
  1751. + {
  1752. + ep->hexserial[3] = ep->emm[6];
  1753. + ep->type = UNIQUE;
  1754. + return (!memcmp(rdr->hexserial + 2, ep->hexserial, 0x04));
  1755. + }
  1756. +
  1757. + case 0x82:
  1758. + ep->type = GLOBAL;
  1759. + return 1;
  1760. +
  1761. + default:
  1762. + ep->type = UNKNOWN;
  1763. + return 0;
  1764. + }
  1765. }
  1766. }
  1767.  
  1768. int32_t nagra_get_emm_filter(struct s_reader *rdr, struct s_csystem_emm_filter **emm_filters, unsigned int *filter_count)
  1769. {
  1770. - if(*emm_filters == NULL)
  1771. + if(rdr->cak7type == 3 || rdr->autype == 1)
  1772. + {
  1773. + if(*emm_filters == NULL)
  1774. + {
  1775. + const unsigned int max_filter_count = 1 + (2 * rdr->nprov);
  1776. + if(!cs_malloc(emm_filters, max_filter_count * sizeof(struct s_csystem_emm_filter)))
  1777. + {
  1778. + return ERROR;
  1779. + }
  1780. +
  1781. + struct s_csystem_emm_filter *filters = *emm_filters;
  1782. + *filter_count = 0;
  1783. +
  1784. + int32_t idx = 0;
  1785. +
  1786. + filters[idx].type = EMM_UNIQUE;
  1787. + filters[idx].enabled = 1;
  1788. + filters[idx].filter[0] = 0x82;
  1789. + filters[idx].mask[0] = 0xFF;
  1790. + memcpy(&filters[idx].filter[1], rdr->hexserial, 6);
  1791. + memset(&filters[idx].mask[1], 0xFF, 6);
  1792. + idx++;
  1793. +
  1794. + int32_t prov;
  1795. + for(prov = 0; prov < rdr->nprov; prov++)
  1796. + {
  1797. + if(!memcmp(rdr->sa[prov], "\x00\x00\x00", 3))
  1798. + {
  1799. + continue;
  1800. + }
  1801. +
  1802. + filters[idx].type = EMM_GLOBAL;
  1803. + filters[idx].enabled = 1;
  1804. + filters[idx].filter[0] = 0x83;
  1805. + filters[idx].mask[0] = 0xFF;
  1806. + memcpy(&filters[idx].filter[1], &rdr->prid[prov][2], 2);
  1807. + memset(&filters[idx].mask[1], 0xFF, 2);
  1808. + idx++;
  1809. +
  1810. + filters[idx].type = EMM_SHARED;
  1811. + filters[idx].enabled = 1;
  1812. + filters[idx].filter[0] = 0x84;
  1813. + filters[idx].mask[0] = 0xFF;
  1814. + memcpy(&filters[idx].filter[1], &rdr->prid[prov][2], 2);
  1815. + memset(&filters[idx].mask[1], 0xFF, 2);
  1816. + memcpy(&filters[idx].filter[3], &rdr->sa[prov], 3);
  1817. + memset(&filters[idx].mask[3], 0xFF, 3);
  1818. + idx++;
  1819. + }
  1820. +
  1821. + *filter_count = idx;
  1822. + }
  1823. +
  1824. + return OK;
  1825. + }
  1826. + else if(rdr->cak7type == 1)
  1827. {
  1828. - const unsigned int max_filter_count = 3;
  1829. - if(!cs_malloc(emm_filters, max_filter_count * sizeof(struct s_csystem_emm_filter)))
  1830. + if(*emm_filters == NULL)
  1831. {
  1832. - return ERROR;
  1833. + const unsigned int max_filter_count = 1 + (4 * rdr->nprov);
  1834. + if(!cs_malloc(emm_filters, max_filter_count * sizeof(struct s_csystem_emm_filter)))
  1835. + {
  1836. + return ERROR;
  1837. + }
  1838. +
  1839. + struct s_csystem_emm_filter *filters = *emm_filters;
  1840. + *filter_count = 0;
  1841. +
  1842. + int32_t idx = 0;
  1843. +
  1844. + if(rdr->emm82 == 1)
  1845. + {
  1846. + filters[idx].type = EMM_GLOBAL;
  1847. + filters[idx].enabled = 1;
  1848. + filters[idx].filter[0] = 0x82;
  1849. + filters[idx].mask[0] = 0xFF;
  1850. + idx++;
  1851. + }
  1852. +
  1853. + int32_t i;
  1854. + for(i = 0; i < rdr->nemm83u; i++)
  1855. + {
  1856. + filters[idx].type = EMM_UNIQUE;
  1857. + filters[idx].enabled = 1;
  1858. + memcpy(&filters[idx].filter[0], rdr->emm83u[i], 6);
  1859. + memset(&filters[idx].mask[0], 0xFF, 6);
  1860. + idx++;
  1861. + }
  1862. +
  1863. + for(i = 0; i < rdr->nemm83s; i++)
  1864. + {
  1865. + filters[idx].type = EMM_SHARED;
  1866. + filters[idx].enabled = 1;
  1867. + memcpy(&filters[idx].filter[0], rdr->emm83s[i], 6);
  1868. + memset(&filters[idx].mask[0], 0xFF, 6);
  1869. + idx++;
  1870. + }
  1871. +
  1872. + for(i = 0; i < rdr->nemm84; i++)
  1873. + {
  1874. + filters[idx].type = EMM_GLOBAL;
  1875. + filters[idx].enabled = 1;
  1876. + memcpy(&filters[idx].filter[0], rdr->emm84[i], 3);
  1877. + memset(&filters[idx].mask[0], 0xFF, 3);
  1878. + idx++;
  1879. + }
  1880. +
  1881. + for(i = 0; i < rdr->nemm87; i++)
  1882. + {
  1883. + filters[idx].type = EMM_SHARED;
  1884. + filters[idx].enabled = 1;
  1885. + memcpy(&filters[idx].filter[0], rdr->emm87[i], 6);
  1886. + memset(&filters[idx].mask[0], 0xFF, 6);
  1887. + idx++;
  1888. + }
  1889. +
  1890. + *filter_count = idx;
  1891. }
  1892.  
  1893. - struct s_csystem_emm_filter *filters = *emm_filters;
  1894. - *filter_count = 0;
  1895. -
  1896. - int32_t idx = 0;
  1897. -
  1898. - filters[idx].type = EMM_UNIQUE;
  1899. - filters[idx].enabled = 1;
  1900. - filters[idx].filter[0] = 0x83;
  1901. - filters[idx].filter[1] = rdr->hexserial[4];
  1902. - filters[idx].filter[2] = rdr->hexserial[3];
  1903. - filters[idx].filter[3] = rdr->hexserial[2];
  1904. - filters[idx].filter[4] = rdr->hexserial[5];
  1905. - filters[idx].filter[5] = 0x00;
  1906. - memset(&filters[idx].mask[0], 0xFF, 6);
  1907. - idx++;
  1908. -
  1909. - filters[idx].type = EMM_SHARED;
  1910. - filters[idx].enabled = 1;
  1911. - filters[idx].filter[0] = 0x83;
  1912. - filters[idx].filter[1] = rdr->sa[0][2];
  1913. - filters[idx].filter[2] = rdr->sa[0][1];
  1914. - filters[idx].filter[3] = rdr->sa[0][0];
  1915. - filters[idx].filter[4] = 0x00;
  1916. - filters[idx].filter[5] = 0x10;
  1917. - memset(&filters[idx].mask[0], 0xFF, 6);
  1918. - idx++;
  1919. -
  1920. - filters[idx].type = EMM_GLOBAL;
  1921. - filters[idx].enabled = 1;
  1922. - filters[idx].filter[0] = 0x82;
  1923. - filters[idx].mask[0] = 0xFF;
  1924. - idx++;
  1925. + return OK;
  1926. + }
  1927. + else if(rdr->autype == 2)
  1928. + {
  1929. + if(*emm_filters == NULL)
  1930. + {
  1931. + const unsigned int max_filter_count = 3 + (2 * rdr->nprov);
  1932. + if(!cs_malloc(emm_filters, max_filter_count * sizeof(struct s_csystem_emm_filter)))
  1933. + {
  1934. + return ERROR;
  1935. + }
  1936. +
  1937. + struct s_csystem_emm_filter *filters = *emm_filters;
  1938. + *filter_count = 0;
  1939. +
  1940. + int32_t idx = 0;
  1941. +
  1942. + filters[idx].type = EMM_GLOBAL;
  1943. + filters[idx].enabled = 1;
  1944. + filters[idx].filter[0] = 0x82;
  1945. + filters[idx].mask[0] = 0xFF;
  1946. + idx++;
  1947. +
  1948. + filters[idx].type = EMM_GLOBAL;
  1949. + filters[idx].enabled = 1;
  1950. + filters[idx].filter[0] = 0x84;
  1951. + filters[idx].mask[0] = 0xFF;
  1952. + idx++;
  1953. +
  1954. + filters[idx].type = EMM_UNIQUE;
  1955. + filters[idx].enabled = 1;
  1956. + filters[idx].filter[0] = 0x83;
  1957. + filters[idx].filter[1] = rdr->hexserial[4];
  1958. + filters[idx].filter[2] = rdr->hexserial[3];
  1959. + filters[idx].filter[3] = rdr->hexserial[2];
  1960. + filters[idx].filter[4] = rdr->hexserial[5];
  1961. + filters[idx].filter[5] = 0x00;
  1962. + memset(&filters[idx].mask[0], 0xFF, 6);
  1963. + idx++;
  1964. +
  1965. + int i;
  1966. + for(i = 0; i < rdr->nprov; i++)
  1967. + {
  1968. + if(!memcmp(rdr->sa[i], "\x00\x00\x00", 3))
  1969. + {
  1970. + continue;
  1971. + }
  1972. +
  1973. + filters[idx].type = EMM_SHARED;
  1974. + filters[idx].enabled = 1;
  1975. + filters[idx].filter[0] = 0x83;
  1976. + filters[idx].filter[1] = rdr->sa[i][2];
  1977. + filters[idx].filter[2] = rdr->sa[i][1];
  1978. + filters[idx].filter[3] = rdr->sa[i][0];
  1979. + filters[idx].filter[4] = 0x00;
  1980. + filters[idx].filter[5] = 0x10;
  1981. + memset(&filters[idx].mask[0], 0xFF, 6);
  1982. + idx++;
  1983. +
  1984. + filters[idx].type = EMM_SHARED;
  1985. + filters[idx].enabled = 1;
  1986. + filters[idx].filter[0] = 0x87;
  1987. + filters[idx].filter[1] = rdr->sa[i][2];
  1988. + filters[idx].filter[2] = rdr->sa[i][1];
  1989. + filters[idx].filter[3] = rdr->sa[i][0];
  1990. + filters[idx].filter[4] = 0x00;
  1991. + filters[idx].filter[5] = 0x00;
  1992. + memset(&filters[idx].mask[0], 0xFF, 6);
  1993. + idx++;
  1994. + }
  1995. +
  1996. + *filter_count = idx;
  1997. + }
  1998.  
  1999. - *filter_count = idx;
  2000. + return OK;
  2001. }
  2002. + else
  2003. + {
  2004. + if(*emm_filters == NULL)
  2005. + {
  2006. + const unsigned int max_filter_count = 3;
  2007. + if(!cs_malloc(emm_filters, max_filter_count * sizeof(struct s_csystem_emm_filter)))
  2008. + {
  2009. + return ERROR;
  2010. + }
  2011. +
  2012. + struct s_csystem_emm_filter *filters = *emm_filters;
  2013. + *filter_count = 0;
  2014.  
  2015. - return OK;
  2016. + int32_t idx = 0;
  2017. +
  2018. + filters[idx].type = EMM_UNIQUE;
  2019. + filters[idx].enabled = 1;
  2020. + filters[idx].filter[0] = 0x83;
  2021. + filters[idx].filter[1] = rdr->hexserial[4];
  2022. + filters[idx].filter[2] = rdr->hexserial[3];
  2023. + filters[idx].filter[3] = rdr->hexserial[2];
  2024. + filters[idx].filter[4] = rdr->hexserial[5];
  2025. + filters[idx].filter[5] = 0x00;
  2026. + memset(&filters[idx].mask[0], 0xFF, 6);
  2027. + idx++;
  2028. +
  2029. + filters[idx].type = EMM_SHARED;
  2030. + filters[idx].enabled = 1;
  2031. + filters[idx].filter[0] = 0x83;
  2032. + filters[idx].filter[1] = rdr->sa[0][2];
  2033. + filters[idx].filter[2] = rdr->sa[0][1];
  2034. + filters[idx].filter[3] = rdr->sa[0][0];
  2035. + filters[idx].filter[4] = 0x00;
  2036. + filters[idx].filter[5] = 0x10;
  2037. + memset(&filters[idx].mask[0], 0xFF, 6);
  2038. + idx++;
  2039. +
  2040. + filters[idx].type = EMM_GLOBAL;
  2041. + filters[idx].enabled = 1;
  2042. + filters[idx].filter[0] = 0x82;
  2043. + filters[idx].mask[0] = 0xFF;
  2044. + idx++;
  2045. +
  2046. + *filter_count = idx;
  2047. + }
  2048. +
  2049. + return OK;
  2050. + }
  2051. }
  2052. Index: webif/pages_index.txt
  2053. --- webif/pages_index.txt 2019-11-09 21:23:00.045455943 +0100
  2054. +++ webif/pages_index.txt 2019-11-09 20:46:21.651589515 +0100
  2055. @@ -199,6 +199,7 @@
  2056. READERCONFIGIRDETO readerconfig/readerconfig_hwreader_irdeto.html READER_IRDETO
  2057. READERCONFIGNAGRA readerconfig/readerconfig_hwreader_nagra.html READER_NAGRA
  2058. READERCONFIGNAGRACAK7 readerconfig/readerconfig_hwreader_nagracak7.html READER_NAGRA_MERLIN
  2059. +READERCONFIGCONAX readerconfig/readerconfig_hwreader_conax.html READER_CONAX
  2060. READERCONFIGNANO readerconfig/readerconfig_hwreader_nano.html WITH_CARDREADER
  2061. READERPINCODE readerconfig/readerconfig_hwreader_pincode.html READER_CONAX,READER_CRYPTOWORKS,READER_VIACCESS,READER_SECA
  2062. READERCONFIGRSAKEY readerconfig/readerconfig_hwreader_rsakey.html READER_NAGRA,READER_IRDETO,READER_CONAX
  2063. Index: webif/readerconfig/readerconfig_cccambit.html
  2064. --- webif/readerconfig/readerconfig_cccambit.html 2019-11-09 21:22:59.881457018 +0100
  2065. +++ webif/readerconfig/readerconfig_cccambit.html 2019-11-09 20:46:21.575590031 +0100
  2066. @@ -1,3 +1,12 @@
  2067. + <TR><TD><A>AU NAGRA type:</A></TD>
  2068. + <TD>
  2069. + <select name="autype">
  2070. + <option value="0" ##AUTYPE0##>0 - Standard</option>
  2071. + <option value="1" ##AUTYPE1##>1 - For Seca/Nagra cards</option>
  2072. + <option value="2" ##AUTYPE2##>2 - For CAK7 cards</option>
  2073. + </select>
  2074. + </TD>
  2075. + </TR>
  2076. <TR><TD><A>Inactivity timeout:</A></TD><TD><input name="inactivitytimeout" class="withunit short" type="text" maxlength="10" value="##INACTIVITYTIMEOUT##"> s</TD></TR>
  2077. <TR><TD><A>Reconnect timeout:</A></TD><TD><input name="reconnecttimeout" class="withunit short" type="text" maxlength="10" value="##RECEIVETIMEOUT##"> s</TD></TR>
  2078. <TR><TD><A>Request timeout:</A></TD><TD><input name="cccreconnect" class="withunit short" type="text" maxlength="10" value="##CCCRECONNECT##"> ms</TD></TR>
  2079. Index: webif/readerconfig/readerconfig_hwreader_conax.html
  2080. --- webif/readerconfig/readerconfig_hwreader_conax.html 1970-01-01 01:00:00.000000000 +0100
  2081. +++ webif/readerconfig/readerconfig_hwreader_conax.html 2019-11-09 21:01:21.369905256 +0100
  2082. @@ -0,0 +1,2 @@
  2083. +<TR><TH COLSPAN="2">Reader specific settings for Conax</TH></TR>
  2084. +<TR><TD><A>CWPK:</A></TD><TD><input name="cwpkkey" class="longer" type="text" maxlength="32" value="##CWPKKEY##"></TD></TR>
  2085. Index: webif/readerconfig/readerconfig_hwreader.html
  2086. --- webif/readerconfig/readerconfig_hwreader.html 2019-11-09 21:22:59.881457018 +0100
  2087. +++ webif/readerconfig/readerconfig_hwreader.html 2019-11-09 20:46:21.575590031 +0100
  2088. @@ -17,10 +17,12 @@
  2089. ##TPLREADERPINCODE##
  2090. ##TPLREADERCONFIGNANO##
  2091. <TR><TD><A>Reset after No. ECM:</A></TD><TD><input name="resetcycle" class="short" type="text" maxlength="5" value="##RESETCYCLE##"></TD></TR>
  2092. + <TR><TD><A>Write Delay:</A></TD><TD><input name="wdelay" class="short" type="text" maxlength="5" value="##WDELAY##"></TD></TR>
  2093. <TR><TD><A>Deprecated:</A></TD><TD><input name="deprecated" type="hidden" value="0"><input name="deprecated" type="checkbox" value="1" ##DEPRECATEDCHECKED##><label></label></TD></TR>
  2094. ##TPLREADERCONFIGCRYPTOWORKS##
  2095. ##TPLREADERCONFIGNAGRA##
  2096. ##TPLREADERCONFIGNAGRACAK7##
  2097. +##TPLREADERCONFIGCONAX##
  2098. ##TPLREADERCONFIGIRDETO##
  2099. ##TPLREADERCONFIGVIACCESS##
  2100. ##TPLREADERCONFIGDRE##
  2101. Index: webif/readerconfig/readerconfig_hwreader_nagracak7.html
  2102. --- webif/readerconfig/readerconfig_hwreader_nagracak7.html 2019-11-09 21:22:59.837457306 +0100
  2103. +++ webif/readerconfig/readerconfig_hwreader_nagracak7.html 2019-11-09 20:46:21.583589977 +0100
  2104. @@ -1,8 +1,24 @@
  2105. <TR><TH COLSPAN="2">Reader specific settings for Nagra Merlin</TH></TR>
  2106. + <TR><TD><A>Init card in CAK7 mode:</A></TD><TD><input name="cak7_mode" type="hidden" value="0"><input name="cak7_mode" type="checkbox" value="1" ##NAGRACAK7MODECHECKED##><label></label></TD></TR>
  2107. + <TR><TD><A>Force CW swap:</A></TD><TD><input name="forcecwswap" type="hidden" value="0"><input name="forcecwswap" type="checkbox" value="1" ##FORCECWSWAPCHECKED##><label></label></TD></TR>
  2108. + <TR><TD><A>Force Even SA:</A></TD><TD><input name="evensa" type="hidden" value="0"><input name="evensa" type="checkbox" value="1" ##EVENSACHECKED##><label></label></TD></TR>
  2109. + <TR><TD><A>Force EMMs 0x82:</A></TD><TD><input name="forceemmg" type="hidden" value="0"><input name="forceemmg" type="checkbox" value="1" ##FORCEEMMGCHECKED##><label></label></TD></TR>
  2110. <TR><TD><A>mod1:</A></TD><TD><textarea name="mod1" rows="4" class="bt" maxlength="224">##MOD1##</textarea></TD></TR>
  2111. + <TR><TD><A>mod2:</A></TD><TD><textarea name="mod2" rows="4" class="bt" maxlength="224">##MOD2##</textarea></TD></TR>
  2112. + <TR><TD><A>key3588:</A></TD><TD><textarea name="key3588" rows="5" class="bt" maxlength="272">##KEY3588##</textarea></TD></TR>
  2113. + <TR><TD><A>key3460:</A></TD><TD><textarea name="key3460" rows="4" class="bt" maxlength="192">##KEY3460##</textarea></TD></TR>
  2114. + <TR><TD><A>key3310:</A></TD><TD><textarea name="key3310" rows="4" class="bt" maxlength="32">##KEY3310##</textarea></TD></TR>
  2115. <TR><TD><A>data50:</A></TD><TD><textarea name="data50" rows="2" class="bt" maxlength="160">##DATA50##</textarea></TD></TR>
  2116. <TR><TD><A>mod50:</A></TD><TD><textarea name="mod50" rows="2" class="bt" maxlength="160">##MOD50##</textarea></TD></TR>
  2117. - <TR><TD><A>key60:</A></TD><TD><textarea name="key60" rows="3" class="bt" maxlength="192">##KEY60##</textarea></TD></TR>
  2118. - <TR><TD><A>exp60:</A></TD><TD><textarea name="exp60" rows="3" class="bt" maxlength="192">##EXP60##</textarea></TD></TR>
  2119. + <TR><TD><A>Idird:</A></TD><TD><input name="idird" class="medium" type="text" maxlength="8" value="##IDIRD##"></TD></TR>
  2120. + <TR><TD><A>CMD0E ProvID:</A></TD><TD><input name="cmd0eprov" class="medium" type="text" maxlength="4" value="##CMD0EPROV##"> use only if CMD0E needs ProvID other than sysid</TD></TR>
  2121. <TR><TD><A>Nuid:</A></TD><TD><input name="nuid" class="medium" type="text" maxlength="8" value="##NUID##"></TD></TR>
  2122. - <TR><TD><A>CWPK:</A></TD><TD><input name="cwekey" class="longer" type="text" maxlength="32" value="##CWEKEY##"></TD></TR>
  2123. + <TR><TD><A>CWPK0:</A></TD><TD><input name="cwekey0" class="longer" type="text" maxlength="32" value="##CWEKEY0##"></TD></TR>
  2124. + <TR><TD><A>CWPK1:</A></TD><TD><input name="cwekey1" class="longer" type="text" maxlength="32" value="##CWEKEY1##"></TD></TR>
  2125. + <TR><TD><A>CWPK2:</A></TD><TD><input name="cwekey2" class="longer" type="text" maxlength="32" value="##CWEKEY2##"></TD></TR>
  2126. + <TR><TD><A>CWPK3:</A></TD><TD><input name="cwekey3" class="longer" type="text" maxlength="32" value="##CWEKEY3##"></TD></TR>
  2127. + <TR><TD><A>CWPK4:</A></TD><TD><input name="cwekey4" class="longer" type="text" maxlength="32" value="##CWEKEY4##"></TD></TR>
  2128. + <TR><TD><A>CWPK5:</A></TD><TD><input name="cwekey5" class="longer" type="text" maxlength="32" value="##CWEKEY5##"></TD></TR>
  2129. + <TR><TD><A>CWPK6:</A></TD><TD><input name="cwekey6" class="longer" type="text" maxlength="32" value="##CWEKEY6##"></TD></TR>
  2130. + <TR><TD><A>CWPK7:</A></TD><TD><input name="cwekey7" class="longer" type="text" maxlength="32" value="##CWEKEY7##"></TD></TR>
  2131. +
  2132. Index: webif/readerconfig/readerconfig_ncd524bit.html
  2133. --- webif/readerconfig/readerconfig_ncd524bit.html 2019-11-09 21:22:59.837457306 +0100
  2134. +++ webif/readerconfig/readerconfig_ncd524bit.html 2019-11-09 20:46:21.555590166 +0100
  2135. @@ -1,3 +1,12 @@
  2136. + <TR><TD><A>AU NAGRA type:</A></TD>
  2137. + <TD>
  2138. + <select name="autype">
  2139. + <option value="0" ##AUTYPE0##>0 - Standard</option>
  2140. + <option value="1" ##AUTYPE1##>1 - For Seca/Nagra cards</option>
  2141. + <option value="2" ##AUTYPE2##>2 - For CAK7 cards</option>
  2142. + </select>
  2143. + </TD>
  2144. + </TR>
  2145. <TR><TD><A>User:</A></TD><TD><input name="user" class="longer" type="text" maxlength="50" value="##USERNAME##"></TD></TR>
  2146. <TR><TD><A>Password:</A></TD><TD><input name="password" class="longer" type="text" maxlength="50" value="##PASSWORD##"></TD></TR>
  2147. <TR><TD><A>Key:</A></TD><TD><input name="key" class="longer" type="text" maxlength="28" value="##NCD_KEY##"></TD></TR>
  2148. Index: webif/readerconfig/readerconfig_ncd525bit.html
  2149. --- webif/readerconfig/readerconfig_ncd525bit.html 2019-11-09 21:22:59.837457306 +0100
  2150. +++ webif/readerconfig/readerconfig_ncd525bit.html 2019-11-09 20:46:21.555590166 +0100
  2151. @@ -1,3 +1,12 @@
  2152. + <TR><TD><A>AU NAGRA type:</A></TD>
  2153. + <TD>
  2154. + <select name="autype">
  2155. + <option value="0" ##AUTYPE0##>0 - Standard</option>
  2156. + <option value="1" ##AUTYPE1##>1 - For Seca/Nagra cards</option>
  2157. + <option value="2" ##AUTYPE2##>2 - For CAK7 cards</option>
  2158. + </select>
  2159. + </TD>
  2160. + </TR>
  2161. <TR><TD><A>User:</A></TD><TD><input name="user" class="longer" type="text" maxlength="50" value="##USERNAME##"></TD></TR>
  2162. <TR><TD><A>Password:</A></TD><TD><input name="password" class="longer" type="text" maxlength="50" value="##PASSWORD##"></TD></TR>
  2163. <TR><TD><A>Key:</A></TD><TD><input name="key" class="longer" type="text" maxlength="28" value="##NCD_KEY##"></TD></TR>
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!