1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen

sorgente oscam

Dieses Thema im Forum "OScam (Italiana)" wurde erstellt von alfredo1, 18. Oktober 2009.

  1. alfredo1
    Offline

    alfredo1 Ist oft hier

    Registriert:
    24. Juli 2007
    Beiträge:
    199
    Zustimmungen:
    102
    Punkte für Erfolge:
    43
    ragazzi e che ne dite tanto se fixamo questo emu visto che unica sorgente che mi trovo a disposizione .




    Line
    1 #include "globals.h"
    2 #include "reader-common.h"
    3
    4 #ifdef HAVE_AES
    5 typedef unsigned long u32;
    6 #endif
    7
    8 extern uchar cta_cmd[], cta_res[];
    9 extern ushort cta_lr;
    10
    11 #define CMD_LEN 5
    12
    13 static unsigned char nds_Seed[] = {
    14 0x56, 0x01, 0x40, 0x00, 0x20, 0x00,
    15 0xB9, 0xD5, 0xEF, 0xD5, 0xF5, 0xD5, 0xFB, 0xD5, 0x31, 0xD6, 0x43, 0xD6, 0x55, 0xD6, 0x61, 0xD6, 0x85, 0xD6, 0x9D,
    16 0xD6, 0xAF, 0xD6, 0xC7, 0xD6, 0xD9, 0xD6, 0x09, 0xD7, 0x15, 0xD7, 0x21, 0xD7, 0x27, 0xD7, 0x3F, 0xD7, 0x45, 0xD7,
    17 0xB1, 0xD7, 0xBD, 0xD7, 0xDB, 0xD7, 0x11, 0xD8, 0x23, 0xD8, 0x29, 0xD8, 0x2F, 0xD8, 0x4D, 0xD8, 0x8F, 0xD8, 0xA1,
    18 0xD8, 0xAD, 0xD8, 0xBF, 0xD8, 0xD7, 0xD8,
    19 0x01, 0x00, 0xCF, 0x13, 0xE0, 0x60, 0x54, 0xAC, 0xAB, 0x99, 0xE6, 0x0C, 0x9F, 0x5B, 0x91, 0xB9, 0x72, 0x72, 0x4D,
    20 0x5B, 0x5F, 0xD3, 0xB7, 0x5B, 0x01, 0x4D, 0xEF, 0x9E, 0x6B, 0x8A, 0xB9, 0xD1, 0xC9, 0x9F, 0xA1, 0x2A, 0x8D, 0x86,
    21 0xB6, 0xD6, 0x39, 0xB4, 0x64, 0x65, 0x13, 0x77, 0xA1, 0x0A, 0x0C, 0xCF, 0xB4, 0x2B, 0x3A, 0x2F, 0xD2, 0x09, 0x92,
    22 0x15, 0x40, 0x47, 0x66, 0x5C, 0xDA, 0xC9
    23 };
    24
    25 static const u32 Te4[256] = {
    26 0x63636363U, 0x7c7c7c7cU, 0x77777777U, 0x7b7b7b7bU,
    27 0xf2f2f2f2U, 0x6b6b6b6bU, 0x6f6f6f6fU, 0xc5c5c5c5U,
    28 0x30303030U, 0x01010101U, 0x67676767U, 0x2b2b2b2bU,
    29 0xfefefefeU, 0xd7d7d7d7U, 0xababababU, 0x76767676U,
    30 0xcacacacaU, 0x82828282U, 0xc9c9c9c9U, 0x7d7d7d7dU,
    31 0xfafafafaU, 0x59595959U, 0x47474747U, 0xf0f0f0f0U,
    32 0xadadadadU, 0xd4d4d4d4U, 0xa2a2a2a2U, 0xafafafafU,
    33 0x9c9c9c9cU, 0xa4a4a4a4U, 0x72727272U, 0xc0c0c0c0U,
    34 0xb7b7b7b7U, 0xfdfdfdfdU, 0x93939393U, 0x26262626U,
    35 0x36363636U, 0x3f3f3f3fU, 0xf7f7f7f7U, 0xccccccccU,
    36 0x34343434U, 0xa5a5a5a5U, 0xe5e5e5e5U, 0xf1f1f1f1U,
    37 0x71717171U, 0xd8d8d8d8U, 0x31313131U, 0x15151515U,
    38 0x04040404U, 0xc7c7c7c7U, 0x23232323U, 0xc3c3c3c3U,
    39 0x18181818U, 0x96969696U, 0x05050505U, 0x9a9a9a9aU,
    40 0x07070707U, 0x12121212U, 0x80808080U, 0xe2e2e2e2U,
    41 0xebebebebU, 0x27272727U, 0xb2b2b2b2U, 0x75757575U,
    42 0x09090909U, 0x83838383U, 0x2c2c2c2cU, 0x1a1a1a1aU,
    43 0x1b1b1b1bU, 0x6e6e6e6eU, 0x5a5a5a5aU, 0xa0a0a0a0U,
    44 0x52525252U, 0x3b3b3b3bU, 0xd6d6d6d6U, 0xb3b3b3b3U,
    45 0x29292929U, 0xe3e3e3e3U, 0x2f2f2f2fU, 0x84848484U,
    46 0x53535353U, 0xd1d1d1d1U, 0x00000000U, 0xededededU,
    47 0x20202020U, 0xfcfcfcfcU, 0xb1b1b1b1U, 0x5b5b5b5bU,
    48 0x6a6a6a6aU, 0xcbcbcbcbU, 0xbebebebeU, 0x39393939U,
    49 0x4a4a4a4aU, 0x4c4c4c4cU, 0x58585858U, 0xcfcfcfcfU,
    50 0xd0d0d0d0U, 0xefefefefU, 0xaaaaaaaaU, 0xfbfbfbfbU,
    51 0x43434343U, 0x4d4d4d4dU, 0x33333333U, 0x85858585U,
    52 0x45454545U, 0xf9f9f9f9U, 0x02020202U, 0x7f7f7f7fU,
    53 0x50505050U, 0x3c3c3c3cU, 0x9f9f9f9fU, 0xa8a8a8a8U,
    54 0x51515151U, 0xa3a3a3a3U, 0x40404040U, 0x8f8f8f8fU,
    55 0x92929292U, 0x9d9d9d9dU, 0x38383838U, 0xf5f5f5f5U,
    56 0xbcbcbcbcU, 0xb6b6b6b6U, 0xdadadadaU, 0x21212121U,
    57 0x10101010U, 0xffffffffU, 0xf3f3f3f3U, 0xd2d2d2d2U,
    58 0xcdcdcdcdU, 0x0c0c0c0cU, 0x13131313U, 0xececececU,
    59 0x5f5f5f5fU, 0x97979797U, 0x44444444U, 0x17171717U,
    60 0xc4c4c4c4U, 0xa7a7a7a7U, 0x7e7e7e7eU, 0x3d3d3d3dU,
    61 0x64646464U, 0x5d5d5d5dU, 0x19191919U, 0x73737373U,
    62 0x60606060U, 0x81818181U, 0x4f4f4f4fU, 0xdcdcdcdcU,
    63 0x22222222U, 0x2a2a2a2aU, 0x90909090U, 0x88888888U,
    64 0x46464646U, 0xeeeeeeeeU, 0xb8b8b8b8U, 0x14141414U,
    65 0xdedededeU, 0x5e5e5e5eU, 0x0b0b0b0bU, 0xdbdbdbdbU,
    66 0xe0e0e0e0U, 0x32323232U, 0x3a3a3a3aU, 0x0a0a0a0aU,
    67 0x49494949U, 0x06060606U, 0x24242424U, 0x5c5c5c5cU,
    68 0xc2c2c2c2U, 0xd3d3d3d3U, 0xacacacacU, 0x62626262U,
    69 0x91919191U, 0x95959595U, 0xe4e4e4e4U, 0x79797979U,
    70 0xe7e7e7e7U, 0xc8c8c8c8U, 0x37373737U, 0x6d6d6d6dU,
    71 0x8d8d8d8dU, 0xd5d5d5d5U, 0x4e4e4e4eU, 0xa9a9a9a9U,
    72 0x6c6c6c6cU, 0x56565656U, 0xf4f4f4f4U, 0xeaeaeaeaU,
    73 0x65656565U, 0x7a7a7a7aU, 0xaeaeaeaeU, 0x08080808U,
    74 0xbabababaU, 0x78787878U, 0x25252525U, 0x2e2e2e2eU,
    75 0x1c1c1c1cU, 0xa6a6a6a6U, 0xb4b4b4b4U, 0xc6c6c6c6U,
    76 0xe8e8e8e8U, 0xddddddddU, 0x74747474U, 0x1f1f1f1fU,
    77 0x4b4b4b4bU, 0xbdbdbdbdU, 0x8b8b8b8bU, 0x8a8a8a8aU,
    78 0x70707070U, 0x3e3e3e3eU, 0xb5b5b5b5U, 0x66666666U,
    79 0x48484848U, 0x03030303U, 0xf6f6f6f6U, 0x0e0e0e0eU,
    80 0x61616161U, 0x35353535U, 0x57575757U, 0xb9b9b9b9U,
    81 0x86868686U, 0xc1c1c1c1U, 0x1d1d1d1dU, 0x9e9e9e9eU,
    82 0xe1e1e1e1U, 0xf8f8f8f8U, 0x98989898U, 0x11111111U,
    83 0x69696969U, 0xd9d9d9d9U, 0x8e8e8e8eU, 0x94949494U,
    84 0x9b9b9b9bU, 0x1e1e1e1eU, 0x87878787U, 0xe9e9e9e9U,
    85 0xcecececeU, 0x55555555U, 0x28282828U, 0xdfdfdfdfU,
    86 0x8c8c8c8cU, 0xa1a1a1a1U, 0x89898989U, 0x0d0d0d0dU,
    87 0xbfbfbfbfU, 0xe6e6e6e6U, 0x42424242U, 0x68686868U,
    88 0x41414141U, 0x99999999U, 0x2d2d2d2dU, 0x0f0f0f0fU,
    89 0xb0b0b0b0U, 0x54545454U, 0xbbbbbbbbU, 0x16161616U,
    90 };
    91
    92 static unsigned char d0_b4_00_00_40_Value[0x40];
    93 static unsigned char oldHBuffer[0x10];
    94 static unsigned char d0BCKey[0x10];
    95 static unsigned char d3BEKey[0x10];
    96
    97
    98 static void nSwap (unsigned char i_key[16], unsigned char o_key[16]);
    99 static void eSwap (unsigned char i_key[16], unsigned char o_key[16]);
    100 static void nLookup (unsigned char i_key[16], unsigned char o_key[16]);
    101
    102 static void xor16 (unsigned char i_val1[16], unsigned char i_val2[16], unsigned char o_val[16]);
    103
    104 static void do_d0b4 (unsigned char *msgBody);
    105 static void extractModule (unsigned char seedBuffer[0x86], unsigned char *outBuffer);
    106 static void processD0BC (unsigned char exp_seedBuffer[0x86], unsigned char *outbuffer);
    107 static void handle_d0_Class (unsigned char *msgFrmCard, unsigned char *msgBody, unsigned char *msgStatus);
    108 static void handle_d1_Class (unsigned char *msgFrmCard, unsigned char *msgBody, unsigned char *msgStatus);
    109 static void handle_d3_Class (unsigned char *msgFrmCard, unsigned char *msgBody, unsigned char *msgStatus);
    110
    111 static unsigned char cw1[0x8];
    112 static unsigned char cw2[0x8];
    113
    114 static int ndsRouteClass (unsigned char *msgFrmCard, int msgFrmCardsize, unsigned char *cw1, unsigned char *cw2);
    115 static void get_D0_B4_PublicModule (unsigned char *module);
    116
    117 static int CommandSendCardCAM (unsigned char *command, char *answer);
    118 static int CommandSendCAMCard (unsigned char *command, char *status, unsigned char *payload);
    119
    120 static unsigned char nds_SC_UA[4] = { 0, 0, 0, 0 };
    121
    122 static unsigned int nds_SC_CAID = 0x0900;
    123 static unsigned char nds_IRD_BoxID[4] = { 0, 0, 0, 0 };
    124
    125 static unsigned char nds_supportedIns[0xFF];
    126 static unsigned char ndsCommand[0xFF];
    127
    128 static unsigned char CardAnswer[0xFF];
    129 static unsigned char d3BEKey[0x10];
    130 static char DCW1[19];
    131
    132 ///====================================================================================================
    133 /*
    134 static int card_write(uchar *cmd, const uchar *data, int wflag)
    135 {
    136 int l;
    137 uchar buf[MAX_LEN];
    138 memcpy(buf, cmd, CMD_LEN);
    139 l=wflag ? cmd[4] : 0;
    140 if (l && data) memcpy(buf+CMD_LEN, data, l);
    141 //cs_log("EMM: %s",cs_hexdump(1,buf,CMD_LEN+l));
    142 l=reader_cmd2icc(buf, CMD_LEN+l);
    143 return(l);
    144 }
    145
    146 #define write_cmd(cmd, data) \
    147 { \
    148 if (card_write(cmd, data, 1)) return(0); \
    149 }
    150
    151 #define read_cmd(cmd) \
    152 { \
    153 if (card_write(cmd, NULL, 0)) return(0); \
    154 }
    155 */
    156 //==============================================================
    157
    158 static AES_KEY aeskey;
    159
    160 static void nds_aes_set_key (char *key)
    161 {
    162 AES_set_encrypt_key ((unsigned char *)key, 128, &aeskey);
    163 }
    164
    165 static int CommandSendCardCAM(unsigned char *command, char *answer_payload)
    166 {
    167 int insLenData = command[4];
    168
    169 if (!reader_cmd2icc (command, CMD_LEN)) {
    170 answer_payload[0] = command[1];
    171 memcpy (&answer_payload[1], cta_res, insLenData);
    172 return 0; //success
    173 }
    174 else
    175 return -1;//error
    176
    177 }
    178
    179 static int CommandSendCAMCard (unsigned char *command, char *status, unsigned char *answer_payload)
    180 {
    181 int insLenData = command[4];
    182 unsigned char tmpPayLoad[0xFF];
    183
    184 memcpy (tmpPayLoad, command, 5);
    185 memcpy (tmpPayLoad + 5, answer_payload, insLenData);
    186
    187 if (!reader_cmd2icc (tmpPayLoad, CMD_LEN + insLenData)) {
    188 memcpy (status, &cta_res[cta_lr - 2], 2);
    189 }
    190 else
    191 return -1;
    192
    193 return 0;
    194 }
    195
    196 static void nSwap (unsigned char i_val[16], unsigned char o_val[16])
    197 {
    198 int i, y, a = 0;
    199 for (i = 0; i < 0x4; i++) {
    200 for (y = 0; y < 0x4; y++) {
    201 o_val[a] = i_val[(y * 4) + i];
    202 a++;
    203 }
    204 }
    205 }
    206
    207 static void nLookup (unsigned char i_key[16], unsigned char o_key[16])
    208 {
    209 int i;
    210 unsigned char flg, lastVal;
    211
    212 flg = (i_key[0xF] % 2) << 7;
    213 for (i = 0; i < 0x10; i++) {
    214 lastVal = i_key;
    215 o_key = Te4[(i_key >> 1) | flg] & 0xFF;
    216 flg = (lastVal % 2) << 7;
    217 }
    218 }
    219
    220
    221 static void xor16 (unsigned char i_val1[16], unsigned char i_val2[16], unsigned char o_val[16])
    222 {
    223 int i;
    224 for (i = 0; i < 0x10; i++) {
    225 o_val = i_val1 ^ i_val2;
    226 }
    227 }
    228
    229
    230
    231 static int ndsRouteClass (unsigned char *msgFrmCard, int msgFrmCardsize, unsigned char *cw1, unsigned char *cw2)
    232 {
    233 unsigned char *msgBody;
    234 unsigned char *msgStatus;
    235 int i;
    236 msgBody = msgFrmCard + 5;
    237 msgStatus = msgFrmCard + msgFrmCardsize - 2;
    238 switch (msgFrmCard[0]) {
    239 case 0xD0:
    240 handle_d0_Class (msgFrmCard, msgBody, msgStatus);
    241 break;
    242 case 0xD1:
    243 handle_d1_Class (msgFrmCard, msgBody, msgStatus);
    244 break;
    245 case 0xD3:
    246 handle_d3_Class (msgFrmCard, msgBody, msgStatus);
    247 if (msgFrmCard[1] == 0x54) {
    248 for (i = 0; i < 8; i++) {
    249 cw1 = msgBody;
    250 cw2 = msgBody[0x24 + i];
    251 }
    252 }
    253 break;
    254 }
    255 return 0;
    256 }
    257
    258
    259 static void get_D0_B4_PublicModule (unsigned char *module)
    260 {
    261 extractModule (nds_Seed, module);
    262 }
    263
    264 static void handle_d0_Class (unsigned char *msgFrmCard, unsigned char *msgBody, unsigned char *msgStatus)
    265 {
    266 switch (msgFrmCard[1]) {
    267 case 0xB4:
    268 do_d0b4 (msgBody);
    269 break;
    270 case 0xBC:
    271 processD0BC (nds_Seed, msgBody);
    272 break;
    273 }
    274 }
    275
    276 static void do_d0b4 (unsigned char *msgBody)
    277 {
    278 int i;
    279 for (i = 0; i < 0x40; i++) {
    280 d0_b4_00_00_40_Value = msgBody;
    281 }
    282 }
    283
    284
    285
    286 static void recalc_Module (unsigned short *buffer, unsigned short *index, unsigned short value, unsigned int sumValue)
    287 {
    288 int i = 0, a = 0;
    289 unsigned int tmpBuff;
    290 if (*index != 0) {
    291 do {
    292 tmpBuff = buffer[a];
    293 tmpBuff = tmpBuff * value;
    294 tmpBuff = tmpBuff + sumValue;
    295 buffer[a] = tmpBuff;
    296 sumValue = tmpBuff >> 16;
    297 i++;
    298 a++;
    299 } while (i < *index);
    300 }
    301 if (sumValue != 0) {
    302 buffer[*index] = sumValue;
    303 *index = *index + 1;
    304 }
    305 }
    306
    307 static void extractModule (unsigned char seedBuffer[0x86], unsigned char *outBuffer)
    308 {
    309 int i, a;
    310 unsigned short index[1], tmpVal;
    311 unsigned short tmpSeedBuffer[0x20];
    312 unsigned short tmpSeedBufferOut[0x20];
    313 a = 0;
    314 for (i = 0; i < 0x20; i++) {
    315 tmpVal = seedBuffer[a + 6];
    316 tmpSeedBuffer = seedBuffer[a + 1 + 6] << 8 | tmpVal;
    317 a = a + 2;
    318 }
    319 index[0] = 0x1;
    320 tmpSeedBufferOut[0] = 1;
    321 for (i = 0; i < 0x20; i++) {
    322 recalc_Module (tmpSeedBufferOut, index, tmpSeedBuffer, 0);
    323 }
    324 for (i = 0; i < 0x20; i++) {
    325 outBuffer[(i * 2)] = tmpSeedBufferOut & 0xFF;
    326 outBuffer[(i * 2) + 1] = (tmpSeedBufferOut >> 8) & 0xFF;
    327 }
    328
    329 }
    330
    331 static void extractExponent (unsigned char seedBuffer[0x86], unsigned char *outBuffer)
    332 {
    333 int i;
    334 for (i = 0; i < 0x40;) {
    335 outBuffer = seedBuffer[i + 0x46 + 1];
    336 outBuffer[i + 1] = seedBuffer[i + 0x46];
    337 i = i + 2;
    338 }
    339 }
    340
    341 static unsigned short lmul (unsigned short value)
    342 {
    343 unsigned int var1;
    344 var1 = ((value * 4) + value);
    345 var1 = (var1 << 4) + var1;
    346 var1 = (var1 << 8) + var1;
    347 var1 = (((var1 * 2) + value) >> 16) & 0xFFFF;
    348 return var1;
    349
    350 }
    351
    352 static void recalc_BC_Expo (unsigned short value, unsigned int index, unsigned short *expoBuffer,
    353 unsigned short *seedBuffer)
    354 {
    355 unsigned int i, a, val3;
    356 unsigned short val1, val2, tmpExp, tmpSed;
    357 if (index != 0) {
    358 tmpExp = expoBuffer[index - 1];
    359 tmpSed = seedBuffer[index];
    360 val1 = tmpSed - tmpExp;
    361 a = index - 2;
    362 for (i = 0; (signed) i < index - 1; i++) {
    363 val3 = seedBuffer[a] * val1;
    364 val3 = val3 % seedBuffer[index];
    365 val1 = val3 - expoBuffer[a];
    366 if (val1 > val3) {
    367 val1 = val1 + tmpSed;
    368 }
    369 a--;
    370 }
    371 val2 = val1 + value;
    372 if (value > val2 || val2 > seedBuffer[index]) {
    373 val2 = val2 - seedBuffer[index];
    374 }
    375 val3 = expoBuffer[index] * val2;
    376 expoBuffer[index] = val3 % seedBuffer[index];
    377
    378 }
    379 else {
    380 expoBuffer[index] = value;
    381 }
    382 }
    383
    384 static void processD0BC (unsigned char exp_seedBuffer[0x86], unsigned char *outbuffer)
    385 {
    386 unsigned short seedBuffer[0x20];
    387 unsigned short expoBuffer[0x20];
    388 unsigned short dataBuffer[0x20];
    389 unsigned int i, a, x, value, tmpVal;
    390 unsigned short seedVal;
    391 unsigned short index[1];
    392
    393 a = 0;
    394 for (i = 0; i < 0x20; i++) {
    395 expoBuffer = exp_seedBuffer[a + 0x46 + 1] << 8 | exp_seedBuffer[a + 0x46];
    396 a = a + 2;
    397 }
    398
    399 a = 0;
    400 for (i = 0; i < 0x20; i++) {
    401 seedBuffer = exp_seedBuffer[a + 0x6 + 1] << 8 | exp_seedBuffer[a + 0x6];
    402 a = a + 2;
    403 }
    404
    405 a = 0;
    406 for (i = 0; i < 0x20; i++) {
    407 dataBuffer = outbuffer[a + 1] << 8 | outbuffer[a];
    408 a = a + 2;
    409 }
    410 for (x = 0; x < 0x20; x++) {
    411 seedVal = seedBuffer[x] & 0xFFFF;
    412 value = 0;
    413 for (i = 0x20; i > 0; i--) {
    414 tmpVal = value << 16 | dataBuffer[i - 1];
    415 tmpVal = tmpVal / seedVal;
    416 value = dataBuffer[i - 1] - (tmpVal * seedVal) & 0xFFFF;
    417 }
    418
    419 tmpVal = lmul (seedVal) | 1;
    420 a = 1;
    421 while (tmpVal != 0) {
    422 if (tmpVal % 2 == 1) {
    423 a = a * value % seedVal & 0xFFFF;
    424 }
    425 value = value * value % seedVal & 0xFFFF;
    426 tmpVal = tmpVal / 2;
    427 }
    428 recalc_BC_Expo ((unsigned short) a, x, expoBuffer, seedBuffer);
    429 }
    430 a = 0x1F;
    431 index[0] = 0;
    432 for (i = 0; i < 0x20; i++) {
    433 recalc_Module (dataBuffer, index, seedBuffer[a], expoBuffer[a]);
    434 a = a - 1;
    435 }
    436 for (i = 0; i < 0x20; i++) {
    437 outbuffer[(i * 2)] = dataBuffer & 0xFF;
    438 outbuffer[(i * 2) + 1] = (dataBuffer[i] >> 8) & 0xFF;
    439 }
    440 nSwap (outbuffer, d0BCKey);
    441 nds_aes_set_key ((char *)d0BCKey);
    442 }
    443
    444
    445
    446 static void handle_d1_Class (unsigned char *msgFrmCard, unsigned char *msgBody, unsigned char *msgStatus)
    447 {
    448 int msgLen, a, rounds, roundIndex = 0;
    449 unsigned char insHeader[0x10];
    450 unsigned char insBody[0x10];
    451 unsigned char buffer[0x10];
    452 unsigned char tmpbuff1[0x10];
    453 unsigned char tmpbuff2[0x10];
    454
    455 msgLen = msgStatus - msgBody;
    456 rounds = msgLen / 0x10;
    457
    458 memset (tmpbuff1, 0, 0x10);
    459 memset (tmpbuff2, 0, 0x10);
    460 memset (buffer, 0, 0x10);
    461
    462 memset (insBody, 0, 0x10);
    463 memset (insHeader, 0, 0x10);
    464
    465 memcpy (insHeader, msgFrmCard, 0x5);
    466
    467
    468 xor16 (insHeader, oldHBuffer, tmpbuff1);
    469 memcpy (oldHBuffer, tmpbuff1, 0x10);
    470
    471 for (a = 0; a < rounds + 2; a++) {
    472 if (a == rounds) {
    473 memset (insBody, 0, 0x10);
    474 memcpy (insBody, msgBody + roundIndex, (msgLen) % 0x10);
    475 }
    476 else if (a == rounds + 1) {
    477 memset (insBody, 0, 0x10);
    478 memcpy (insBody + 5, msgStatus, 0x2);
    479 }
    480 else {
    481 memcpy (insBody, msgBody + roundIndex, 0x10);
    482 }
    483 xor16 (tmpbuff1, insBody, tmpbuff2);
    484
    485 nSwap (tmpbuff2, buffer);
    486 AES_encrypt (buffer, buffer, &aeskey);
    487 nSwap (buffer, tmpbuff2);
    488 roundIndex = roundIndex + 0x10;
    489 xor16 (tmpbuff2, oldHBuffer, tmpbuff1);
    490
    491 }
    492 memcpy (oldHBuffer, tmpbuff2, 0x10);
    493 }
    494
    495
    496
    497
    498
    499 static void handle_d3_Class (unsigned char *msgFrmCard, unsigned char *msgBody, unsigned char *msgStatus)
    500 {
    501 int i, msgLen, rounds, roundIndex = 0;
    502 unsigned char insHeader[0x10];
    503 unsigned char insBody[0x10];
    504 unsigned char insStatus[0x10];
    505 unsigned char tmpbuff1[0x10];
    506 unsigned char tmpbuff2[0x10];
    507 unsigned char wBuffer[0x10];
    508 unsigned char dispBuffer[0x100];
    509
    510 //aes_context ctx;
    511
    512 if (msgFrmCard[4] > 0x10) {
    513 msgFrmCard[4] = msgFrmCard[4] - 0x10;
    514 }
    515
    516 if (msgFrmCard[1] == 0xBE) {
    517 memset (oldHBuffer, 0, 0x10);
    518 }
    519 memcpy (tmpbuff1, oldHBuffer, 0x10); // Get from oldHbuffer
    520
    521
    522 memset (wBuffer, 0, 0x10);
    523 memset (insHeader, 0, 0x10);
    524 memcpy (insHeader, msgFrmCard, 0x5);
    525
    526 memset (insStatus, 0, 0x10);
    527 memcpy (insStatus + 5, msgStatus, 0x2);
    528
    529 memset (insBody, 0, 0x10);
    530 memcpy (insBody, msgBody, 0x10);
    531
    532 xor16 (insHeader, oldHBuffer, oldHBuffer);
    533
    534 msgLen = msgFrmCard[4];
    535 rounds = msgLen / 0x10;
    536 /*Rounds */
    537 if (msgFrmCard[1] != 0xBE) {
    538 rounds++;
    539 }
    540 for (i = 0; i < rounds; i++) {
    541 wBuffer[0] = wBuffer[0] + i;
    542 xor16 (wBuffer, oldHBuffer, wBuffer);
    543
    544 nSwap (wBuffer, tmpbuff2);
    545 AES_encrypt (tmpbuff2, tmpbuff2, &aeskey);
    546 nSwap (tmpbuff2, wBuffer);
    547 memcpy (tmpbuff1, msgBody + roundIndex, 0x10);
    548
    549 xor16 (wBuffer, tmpbuff1, dispBuffer + roundIndex);
    550 if (i == msgLen / 0x10) {
    551 memset (dispBuffer + roundIndex + (msgLen - roundIndex), 0, 0x10 - (msgLen - roundIndex));
    552 }
    553 xor16 (dispBuffer + roundIndex, oldHBuffer, oldHBuffer);
    554 nLookup (oldHBuffer, oldHBuffer);
    555
    556 roundIndex = roundIndex + 0x10;
    557 }
    558 xor16 (oldHBuffer, insStatus, oldHBuffer);
    559 nSwap (oldHBuffer, tmpbuff2);
    560 AES_encrypt (tmpbuff2, tmpbuff2, &aeskey);
    561 nSwap (tmpbuff2, oldHBuffer);
    562
    563 /*Get Phase from Last 16 Bytes */
    564 memcpy (oldHBuffer, msgStatus - 0x10, 0x10);
    565
    566 nSwap (oldHBuffer, tmpbuff2);
    567 AES_encrypt (tmpbuff2, tmpbuff2, &aeskey);
    568 nSwap (tmpbuff2, oldHBuffer);
    569
    570 memcpy (msgBody, dispBuffer, msgLen);
    571
    572 if (msgFrmCard[1] == 0xBE) {
    573 nSwap (dispBuffer, d3BEKey);
    574 nds_aes_set_key ((char *)d3BEKey);
    575 }
    576
    577 }
    578
    579
    580 static int nds_getInsParams (unsigned char *insHeader, unsigned char *dir, unsigned char *len)
    581 {
    582 int i, a, retval;
    583 retval = 1;
    584 a = 4;
    585 for (i = 0; i < nds_supportedIns[2]; i++) {
    586 if (insHeader[1] == nds_supportedIns[a + 1]) {
    587 *len = nds_supportedIns[a + 2];
    588 *dir = nds_supportedIns[a + 3];
    589 retval = 0;
    590 }
    591 a = a + 4;
    592 }
    593 return retval;
    594 }
    595
    596 static void nds_createEcmInsFromRawEcm (unsigned char *rawEcm, unsigned char *ecmIns)
    597 {
    598 unsigned char ecmINSHeader[5] = { 0xD1, 0x40, 0x40, 0x80, 0xFF };
    599 int insLen;
    600 insLen = rawEcm[2] - 0xF;
    601 ecmINSHeader[4] = insLen;
    602 memset (ecmIns, 0, 0xFF);
    603 memcpy (ecmIns, ecmINSHeader, 5);
    604 memcpy (ecmIns + 6, rawEcm + 19, insLen + 0x12);
    605 //cs_log("ECM: %s",cs_hexdump(0,ecmIns,ecmINSHeader[4]+5));
    606 }
    607
    608 static int nds_AskInsLen (unsigned char ins[5])
    609 {
    610 unsigned char oldP2;
    611 int error = 0;
    612 oldP2 = ins[3];
    613 ins[3] = 0x80; // getLengh
    614 ins[4] = 0x01; // getLengh
    615 error = CommandSendCardCAM (ins, (char *) CardAnswer);
    616 ins[3] = oldP2; // getLengh
    617 if (error) {
    618 return -1;
    619 }
    620 else {
    621 ins[4] = CardAnswer[1]; // update lenght
    622 }
    623 return 0;
    624 }
    625
    626 static int nds_buildIncomingCommandWSB (unsigned char *isoHeader, unsigned char *commandPayload,
    627 unsigned char *statusBytes, unsigned char *outCommand)
    628 {
    629 unsigned int len;
    630 memcpy(outCommand, isoHeader, 5);
    631 len = 5;
    632 memcpy(outCommand + len, commandPayload, isoHeader[4]);
    633 len += isoHeader[4];
    634 memcpy(outCommand + len, statusBytes,2);
    635 len += 2;
    636 return len;
    637 }
    638
    639 static int nds_buildIncomingCommand (unsigned char *isoHeader, unsigned char *cardResponse, unsigned char *outCommand)
    640 {
    641 unsigned int len;
    642 memcpy(outCommand, isoHeader, 5);
    643 len = 5;
    644 memcpy(outCommand + len, cardResponse + 1, isoHeader[4] + 2);
    645 len += isoHeader[4] + 2;
    646 return len;
    647 }
    648
    649 static void nds_parseUAInfo (unsigned char *uaInsData)
    650 {
    651 nds_SC_UA[0] = uaInsData[8];
    652 nds_SC_UA[1] = uaInsData[9];
    653 nds_SC_UA[2] = uaInsData[10];
    654 nds_SC_UA[3] = uaInsData[11];
    655
    656 nds_SC_CAID = (uaInsData[0x1D] << 8) | (uaInsData[0x1E]);
    657 }
    658
    659 static void nds_parseBoxIDInfo (unsigned char *boxIDData)
    660 {
    661 if (reader[ridx].pincode[0])
    662 return;
    663
    664 int i;
    665 //int index=0;
    666 for (i = 0; i < 0x8F; i++) {
    667 if ((boxIDData[i] == 0x00) && (boxIDData[i + 1] == 0xF3)) {
    668 //index=i+1;
    669 memcpy (&nds_IRD_BoxID, &boxIDData[i + 2], sizeof (nds_IRD_BoxID));
    670 }
    671 }
    672
    673 //nds_IRD_BoxID[0]=boxIDData[index+1];
    674 //nds_IRD_BoxID[1]=boxIDData[index+2];
    675 //nds_IRD_BoxID[2]=boxIDData[index+3];
    676 //nds_IRD_BoxID[3]=boxIDData[index+4];
    677 }
    678
    679
    680 static unsigned int nds_getSupportedIns (void)
    681 {
    682 unsigned int retval = 0;
    683 static unsigned char ndsBoot_GetSupportedIns[] = { 0xd0, 0x74, 0x01, 0x00, 0xFF };
    684 nds_AskInsLen (ndsBoot_GetSupportedIns);
    685 CommandSendCardCAM (ndsBoot_GetSupportedIns, (char *) CardAnswer);
    686 memcpy (nds_supportedIns, CardAnswer + 1, ndsBoot_GetSupportedIns[4]);
    687 return retval;
    688 }
    689
    690 static unsigned int nds_sendCommandToCard (unsigned char *insHeader, unsigned char *cmdPayload, unsigned char *cmdOut)
    691 {
    692 unsigned char dir, len, cmdLen;
    693 nds_getInsParams (insHeader, &dir, &len);
    694 if ((len == 0xFF) & (dir == 2)) {
    695 nds_AskInsLen (insHeader);
    696 }
    697 if (len != 0xFF) {
    698 insHeader[4] = len;
    699 }
    700 if (insHeader[0] == 0xD3) {
    701 insHeader[4] = len + 0x10;
    702 }
    703 if (dir >= 2) { //Card -> Cam
    704 CommandSendCardCAM (insHeader, (char *) CardAnswer);
    705 cmdLen = nds_buildIncomingCommand (insHeader, CardAnswer, cmdOut);
    706 }
    707 if (dir <= 1) { //Cam -> Card
    708 CommandSendCAMCard (insHeader, (char *) CardAnswer, cmdPayload);
    709 cmdLen = nds_buildIncomingCommandWSB (insHeader, cmdPayload, CardAnswer, cmdOut);
    710 }
    711
    712 ndsRouteClass (cmdOut, cmdLen, cw1, cw2);
    713 return 0;
    714 }
    715
    716 static unsigned int nds_getUAandBoxId ()
    717 {
    718 static unsigned char ndsBoot_GetPhoneInfo[] = { 0xd0, 0x36, 0x00, 0x00, 0x00 };
    719 static unsigned char ndsBoot_SendBoxid[] = { 0xd0, 0x4C, 0x00, 0x00, 0x00 };
    720 static unsigned char ndsBoxID_Payload[] = { 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x02, 0x04 };
    721 static unsigned char ndsBoot_GetUAInfo[] = { 0xd0, 0x58, 0x00, 0x00, 0x00 };
    722 nds_sendCommandToCard (ndsBoot_GetPhoneInfo, NULL, ndsCommand);
    723 nds_parseBoxIDInfo (ndsCommand);
    724 memcpy (ndsBoxID_Payload, nds_IRD_BoxID, 4);
    725 nds_sendCommandToCard (ndsBoot_SendBoxid, ndsBoxID_Payload, ndsCommand);
    726 cs_log ("BoxID: %02X%02X%02X%02X (%02X %02X)", ndsBoxID_Payload[0], ndsBoxID_Payload[1], ndsBoxID_Payload[2],
    727 ndsBoxID_Payload[3], cta_res[cta_lr - 2], cta_res[cta_lr - 1]);
    728 nds_sendCommandToCard (ndsBoot_GetUAInfo, NULL, ndsCommand);
    729 nds_parseUAInfo (ndsCommand);
    730 return 0;
    731 }
    732
    733 static unsigned int nds_getUAandBoxId_D1 ()
    734 {
    735 static unsigned char ndsBoot_SendBoxid[] = { 0xd1, 0x4C, 0x00, 0x00, 0x00 };
    736 static unsigned char ndsBoxID_Payload[] = { 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x02, 0x04 };
    737 static unsigned char ndsBoot_GetUAInfo[] = { 0xd1, 0x58, 0x00, 0x00, 0x00 };
    738 memcpy (ndsBoxID_Payload, nds_IRD_BoxID, 4);
    739 nds_sendCommandToCard (ndsBoot_GetUAInfo, NULL, ndsCommand);
    740 nds_sendCommandToCard (ndsBoot_SendBoxid, ndsBoxID_Payload, ndsCommand);
    741 cs_log ("BoxID: %02X%02X%02X%02X (%02X %02X)", ndsBoxID_Payload[0], ndsBoxID_Payload[1], ndsBoxID_Payload[2],
    742 ndsBoxID_Payload[3], cta_res[cta_lr - 2], cta_res[cta_lr - 1]);
    743 return 0;
    744 }
    745
    746
    747 static unsigned int nds_getCamCryptKeys ()
    748 {
    749 static unsigned char ndsBoot_SendModul[] = { 0xd0, 0xb4, 0x00, 0x00, 0x00 };
    750 static unsigned char ndsBoot_AskD0Key[] = { 0xd0, 0xbc, 0x00, 0x00, 0x00 };
    751 static unsigned char ndsBoot_AskD3Key[] = { 0xd3, 0xbe, 0x00, 0x00, 0x00 };
    752
    753 static unsigned char ndsModul_Payload[0x40];
    754 get_D0_B4_PublicModule (ndsModul_Payload);
    755 nds_sendCommandToCard (ndsBoot_SendModul, ndsModul_Payload, ndsCommand);
    756 nds_sendCommandToCard (ndsBoot_AskD0Key, NULL, ndsCommand);
    757
    758 nds_sendCommandToCard (ndsBoot_AskD3Key, NULL, ndsCommand);
    759
    760 return 0;
    761 }
    762
    763
    764 static int ndsBoot (void)
    765 {
    766 static unsigned char ndsBoot_Get7416[] = { 0xd0, 0x74, 0x16, 0x00, 0x00 };
    767
    768 nds_getSupportedIns ();
    769 nds_sendCommandToCard (ndsBoot_Get7416, NULL, ndsCommand);
    770 nds_getUAandBoxId ();
    771 nds_getCamCryptKeys ();
    772 nds_getUAandBoxId_D1 ();
    773
    774 return 1;
    775 }
    776
    777
    778 ///====================================================================================================
    779 int nds_card_init (uchar * atr, int atrsize)
    780 {
    781 if (atrsize < 14 || (atr[10] != 0x69 && atr[11] != 0xFF && atr[12] != 0x4A && atr[13] != 0x50))
    782 return (0);
    783
    784 if (reader[ridx].pincode[0]) {
    785 nds_IRD_BoxID[0] = (gethexval (reader[ridx].pincode[0]) << 4) | gethexval (reader[ridx].pincode[1]);
    786 nds_IRD_BoxID[1] = (gethexval (reader[ridx].pincode[2]) << 4) | gethexval (reader[ridx].pincode[3]);
    787 nds_IRD_BoxID[2] = (gethexval (reader[ridx].pincode[4]) << 4) | gethexval (reader[ridx].pincode[5]);
    788 nds_IRD_BoxID[3] = (gethexval (reader[ridx].pincode[6]) << 4) | gethexval (reader[ridx].pincode[7]);
    789 }
    790
    791 ndsBoot ();
    792 reader[ridx].caid[0] = nds_SC_CAID;
    793 reader[ridx].hexserial[0] = nds_SC_UA[0];
    794 reader[ridx].hexserial[1] = nds_SC_UA[1];
    795 reader[ridx].hexserial[2] = nds_SC_UA[2];
    796 reader[ridx].hexserial[3] = nds_SC_UA[3];
    797
    798 cs_ri_log ("type: nds, card: %c%c.%d, boxID: %02X%02X%02X%02X, caid: %04X, ascii serial: %ld, hex serial: %s",
    799 atr[17], atr[18], atr[19],
    800 nds_IRD_BoxID[0], nds_IRD_BoxID[1], nds_IRD_BoxID[2], nds_IRD_BoxID[3], reader[ridx].caid[0],
    801 (reader[ridx].hexserial[0] << 24 | reader[ridx].hexserial[1] << 16 | reader[ridx].
    802 hexserial[2] << 8 | reader[ridx].hexserial[3]), cs_hexdump (0, reader[ridx].hexserial, 4));
    803
    804 reader[ridx].nprov = 1;
    805 memset (reader[ridx].prid, 0, sizeof (reader[ridx].prid));
    806 memset (reader[ridx].sa, 0xFF, sizeof (reader[ridx].sa));
    807 memcpy (reader[ridx].sa, reader[ridx].hexserial, 3);
    808 reader[ridx].sa[0][3] = 0;
    809
    810 cs_ri_log ("NDS-Provider:%d", reader[ridx].nprov);
    811
    812 int j;
    813 for (j = 0; j < reader[ridx].nprov; j++) {
    814 cs_ri_log ("Provider:%d Provider-Id:%06X", j + 1, b2ll (4, reader[ridx].prid[j]));
    815 cs_ri_log ("Provider:%d SharedAddress:%08X", j + 1, b2ll (4, reader[ridx].sa[j]));
    816 }
    817
    818 cs_log ("ready for requests");
    819 return (1);
    820 }
    821
    822 int nds_do_ecm (ECM_REQUEST * er)
    823 {
    824 static unsigned char ndsEcm_GetDW[] = { 0xd3, 0x54, 0x00, 0x00, 0x00 };
    825
    826 unsigned char insHeader[5];
    827 nds_createEcmInsFromRawEcm (er->ecm, CardAnswer);
    828 memcpy (insHeader, CardAnswer, 5);
    829 memcpy (ndsCommand, CardAnswer + 5, insHeader[4]);
    830
    831 nds_sendCommandToCard (insHeader, ndsCommand, CardAnswer);
    832 nds_sendCommandToCard (ndsEcm_GetDW, NULL, CardAnswer);
    833
    834 if (er->ecm[0] == 0x80)
    835 memcpy (er->cw, cw1, 8);
    836
    837 if (er->ecm[0] == 0x81)
    838 memcpy (er->cw + 8, cw1, 8);
    839
    840 if (er->cw[0] == 0 && er->cw[8] == 0)
    841 return 0;
    842 return 1;
    843 }
    844
    845 static int nds_AddrMode (unsigned char *data)
    846 {
    847 switch (data[3] & 0xC0) {
    848 case 0x40:
    849 return 3;
    850 case 0x80:
    851 return 2;
    852 default:
    853 return 0;
    854 }
    855 }
    856
    857 static unsigned int nds_NumAddr (unsigned char *data)
    858 {
    859 return ((data[3] & 0x30) >> 4) + 1;
    860 }
    861
    862 static unsigned char *nds_PayloadStart (unsigned char *data)
    863 {
    864 //return &data[4 + NumAddr(data)*4 + 2];
    865 if (nds_AddrMode (data) == 0)
    866 return &data[4];
    867 else
    868 return &data[4 + nds_NumAddr (data) * 4];
    869 }
    870
    871 int nds_do_emm (EMM_PACKET * ep)
    872 {
    873 unsigned char insEMM[] = { 0xD1, 0x42, 0x00, 0x00, 0x00 };
    874
    875 int lenEMM, rc = 0;
    876
    877 unsigned char *payloaddata = nds_PayloadStart (ep->emm);
    878 switch (payloaddata[0]) {
    879 case 2:
    880 lenEMM = payloaddata[payloaddata[1] + 2];
    881 payloaddata += 3 + payloaddata[1]; // skip len specifier
    882 break;
    883 default:
    884 //EMM: bad payload type byte
    885 return 0;
    886 }
    887
    888 if (lenEMM <= 8 || lenEMM > 188) {
    889 return 0;
    890 }
    891
    892 insEMM[4] = lenEMM;
    893 nds_sendCommandToCard (insEMM, payloaddata, ndsCommand);
    894 //cs_log("EMM A: %s",cs_hexdump(1,cta_res,cta_lr));
    895 rc = ((cta_res[cta_lr - 2] == 0x90) && (cta_res[cta_lr - 1] == 0x00));
    896
    897 return (rc);
    898 }
    899
    900 static void nds_RevDateCalc (const unsigned char *Date, int *year, int *mon, int *day, int *hh, int *mm, int *ss)
    901 {
    902 *year = (Date[0] / 12) + 2000;
    903 *mon = (Date[0] % 12) + 1;
    904 *day = Date[1];
    905 *hh = Date[2] / 8;
    906 *mm = (0x100 * (Date[2] - *hh * 8) + Date[3]) / 32;
    907 *ss = (Date[3] - *mm * 32) * 2;
    908 }
    909
    910 int nds_card_info (void)
    911 {
    912 int i = 0;
    913
    914 unsigned char ins2a[] = { 0xd0, 0x2a, 0x00, 0x00, 0x00 };
    915 nds_sendCommandToCard (ins2a, NULL, ndsCommand);
    916
    917 unsigned char ins76[] = { 0xd0, 0x76, 0x00, 0x00, 0x00 };
    918 ins76[3] = 0x7f;
    919 ins76[4] = 2;
    920
    921 nds_sendCommandToCard (ins76, NULL, ndsCommand);
    922 //cs_log("A: %s...",cs_hexdump(1,cta_res,cta_lr));
    923 //cs_log("A: %s...",cs_hexdump(1,ndsCommand,cta_lr));
    924 ins76[3] = 0;
    925 ins76[4] = 0;
    926 int num = cta_res[1];
    927
    928 for (i = 0; i < num; i++) {
    929 ins76[2] = i;
    930 nds_sendCommandToCard (ins76, NULL, ndsCommand);
    931 //cs_log("A: %s...",cs_hexdump(1,cta_res,cta_lr));
    932 if (cta_res[5 + 2] == 0 && cta_res[5 + 3] == 0)
    933 break;
    934 int y, m, d, H, M, S;
    935 nds_RevDateCalc (&cta_res[5 + 4], &y, &m, &d, &H, &M, &S);
    936 cs_ri_log ("chid: %02x%02x, date: %04d-%02d-%02d %02d:%02d:%02d", cta_res[5 + 2], cta_res[5 + 3], y, m, d, H, M, S);
    937 }
    938
    939 return (1);
    940 }[/i][/i]
     
    #1
    1 Person gefällt das.
  2. phantom

    Nervigen User Advertisement

  3. delle1982
    Offline

    delle1982 Ist gelegentlich hier

    Registriert:
    8. Dezember 2008
    Beiträge:
    40
    Zustimmungen:
    2
    Punkte für Erfolge:
    0
    AW: sorgente oscam

    ciao ragazzi mi potete spiegarmi come faccio ad far caminare la Oscam con il Debian 5 e con il Smargo USB.

    Grazie non so dove iniziare. mi serverebbe un HOWTO.
     
    #2
  4. Dj Amon
    Offline

    Dj Amon Stamm User

    Registriert:
    23. Oktober 2009
    Beiträge:
    1.101
    Zustimmungen:
    733
    Punkte für Erfolge:
    0
    Beruf:
    Student
    Ort:
    Deutschland
    Homepage:
    AW: sorgente oscam

    Alfredo mi sa che hai ragione. Da qualche giorno si parla sempre piu' di questa Oscam. Sembrerebbe che con essa (naturalmente modificata e riprogrammata) tornerebbe la luce.
     
    #3
  5. didim
    Offline

    didim Ist gelegentlich hier

    Registriert:
    19. Juli 2009
    Beiträge:
    37
    Zustimmungen:
    9
    Punkte für Erfolge:
    0
    AW: sorgente oscam

    Mah...... fino adesso la oscam riesce a leggere le carte nostre ma ha lo stesso problema delle altre emu..... almeno cosi sta nel forum ufficiale, poi se hanno scoperto altro ninso:D
     
    #4
  6. felice2202
    Offline

    felice2202 Newbie

    Registriert:
    26. Oktober 2009
    Beiträge:
    11
    Zustimmungen:
    1
    Punkte für Erfolge:
    3
    AW: sorgente oscam

    adesso funziona sky?
     
    #5
    Tito68 gefällt das.
  7. qpalym
    Offline

    qpalym Freak

    Registriert:
    18. Februar 2008
    Beiträge:
    241
    Zustimmungen:
    6
    Punkte für Erfolge:
    18
    AW: sorgente oscam

    NO se non viene la nuova CCcam non funziona niente.
     
    #6
  8. alfredo1
    Offline

    alfredo1 Ist oft hier

    Registriert:
    24. Juli 2007
    Beiträge:
    199
    Zustimmungen:
    102
    Punkte für Erfolge:
    43
    AW: sorgente oscam

    ma la nuova cccam chi la dovrebbe portare ? Babbo natale o la befana?
    io lo detto su un altro 3d allora meglio la befana , perche con il babbo natale si rischia di trovarsi con un caxxo nel sedere. comunque i fatti non ti stanno danto ragione. la oscam credo che ha fatto un bel passo avanti
     
    #7
    dome und Dj Amon gefällt das.
  9. Dj Amon
    Offline

    Dj Amon Stamm User

    Registriert:
    23. Oktober 2009
    Beiträge:
    1.101
    Zustimmungen:
    733
    Punkte für Erfolge:
    0
    Beruf:
    Student
    Ort:
    Deutschland
    Homepage:
    AW: sorgente oscam


    [​IMG] Sono d' accordo con te.
     
    #8
  10. qpalym
    Offline

    qpalym Freak

    Registriert:
    18. Februar 2008
    Beiträge:
    241
    Zustimmungen:
    6
    Punkte für Erfolge:
    18
    AW: sorgente oscam


    Che passo a fatto avanti la Oscam ? Io non vedo niente , tu si ? Perfavore e inutile di continuare a discudere - tanto non si cambia niente.
     
    #9
  11. Dj Amon
    Offline

    Dj Amon Stamm User

    Registriert:
    23. Oktober 2009
    Beiträge:
    1.101
    Zustimmungen:
    733
    Punkte für Erfolge:
    0
    Beruf:
    Student
    Ort:
    Deutschland
    Homepage:
    AW: sorgente oscam

    In giro si legge che la oscam funzioni bene, ma alcuni scrivono anche che funziona per 30 secondi e poi si blocca per 5 min e cosi' via. Il fatto e' che la oscam funziona si, ma l' algoritmo non e' ancora stato azzeccato e se non si azzecca allora rimaniamo al buio. Dobbiamo lavorare su un algoritmo diverso, ma e' molto difficile.
     
    #10
  12. alfredo1
    Offline

    alfredo1 Ist oft hier

    Registriert:
    24. Juli 2007
    Beiträge:
    199
    Zustimmungen:
    102
    Punkte für Erfolge:
    43
    AW: sorgente oscam

    vi do un grande indizio. se volete la pista giusta da battere e informarvi su un certo ciarlatano . costui E´stato battezato ciarlatano dal sotto scritto hai grandi tempi dfs . in seguito se ribattezato da solo con lo stesso nome. quindi una bella ricerca su gogle su ciarlatano .
    costui vede come cliente . ma solo perche`ha un grande giro .
    non esiste cccam fixata esiste una gbox r con questa hanno risolto i poblemi gia 2 giorni dopo attacco . oscam gira propio grazie a questa fixa .
    quindi accopiata germania piamonte pista da battere server tedesco cliente leccaculo piamontese . E mi prendo tutte le respüonsabilita`di quel che ho detto .
    dite ma come fai a dirlo . lo dico perche`lo so e con me sono daccordo tutti i vecchi amici che come me si trovano ancora a vacillare nel buio .
    un altra nota fate attenzione su hotmail girano truffatori non fatevi prendere in giro con la storia del emu
    ciao
     
    #11
    1 Person gefällt das.
  13. maxmax
    Offline

    maxmax Newbie

    Registriert:
    18. Juli 2009
    Beiträge:
    14
    Zustimmungen:
    0
    Punkte für Erfolge:
    1
    AW: sorgente oscam

    Quelli si che erano tempi Digitalfreesat :dfingers::diablo:
     
    #12

Diese Seite empfehlen