Changeset 498 for trunk/reader-dre.c


Ignore:
Timestamp:
Nov 7, 2009, 3:07:12 PM (10 years ago)
Author:
dingo35
Message:

Drecrypt update; ecm Dre1 working, emm Dre1 untested, ecm Dre2 untested, emm Dre2 untested

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/reader-dre.c

    r497 r498  
    171171    card = "Platforma HD / DW old";
    172172    reader[ridx].caid[0] = 0x4ae1;  //TODO not sure
    173     mode = 41;          //TODO not sure
     173    mode = 51;
    174174    break;          //59 type card
    175175  default:
     
    303303//   ecmtest[index] = hans;
    304304//    if ((dre_cmd(ecmtest)))
    305 //      cs_log("HANS SUCCESS");
    306305//  }
    307306//  ecmtest[index] = save;
    308307//}
    309 
     308/*
    310309  EMM_PACKET *eptmp;
    311310  eptmp = malloc (sizeof (EMM_PACKET));
     
    313312//  memcpy (reader[ridx].hexserial, tempser, 8);
    314313  dre_do_emm (eptmp);
    315   free (eptmp);
     314  free (eptmp);*/
    316315//############### PLAYGROUND ////
    317316  cs_log ("ready for requests");
    318317  return (1);
    319318}
    320 
    321 /*
    322 static int get_prov_index (char *provid)    //returns provider id or -1 if not found
    323 {
    324   int prov;
    325   for (prov = 0; prov < reader[ridx].nprov; prov++) //search for provider index
    326     if (!memcmp (provid, &reader[ridx].prid[prov][2], 2))
    327       return (prov);
    328   return (-1);
    329 }
    330 */
    331319
    332320int dre_do_ecm (ECM_REQUEST * er)
     
    350338      if ((cta_res[cta_lr - 2] != 0x90) || (cta_res[cta_lr - 1] != 0x00))
    351339    return (0);     //exit if response is not 90 00 //TODO: if response is 9027 ppv mode is possible!
    352       //memcpy(er->cw,cta_res+3,16);
    353       //or swap bytes:
    354340      memcpy (er->cw, cta_res + 11, 8);
    355341      memcpy (er->cw + 8, cta_res + 3, 8);
    356342
    357       //  return 0; //FIXME only used for testing CWs
    358343      return 1;
    359344    }
     
    393378  //return 0;                   //FIXME STUB
    394379  /*
    395   uchar emmtest[] = { 0x87, 0x00, 0x8C, 0xC8, 0x4D, 0x25, 0x5A, 0x02, 0xA9, 0xA5, 0x34, 0x31, 0xAB, 0x9C, 0x9B, 0x59,
    396     0x5D, 0x47, 0x95, 0xB3, 0xB1, 0x61, 0x47, 0xE6, 0x85, 0xE0, 0x17, 0xC8, 0x25, 0x70, 0x59, 0x73,
    397     0x12, 0x1F, 0x2B, 0x9B, 0x02, 0x5A, 0x9D, 0x3A, 0x05, 0x56, 0x85, 0x58, 0x00, 0xC8, 0x4D, 0x25,
    398     0x5A, 0x06, 0x02, 0x23, 0xB4, 0x37, 0x1E, 0xE0, 0x7E, 0x59, 0xFC, 0x38, 0xCA, 0x13, 0x21, 0x0D,
    399     0x3E, 0x09, 0xDF, 0xB4, 0x45, 0x6C, 0x99, 0x7E, 0x3E, 0xDA, 0xA4, 0xC7, 0xB9, 0x7B, 0xAB, 0x4A,
    400     0xB5, 0xE2, 0x1D, 0xA3, 0xCD, 0x03, 0xAF, 0xDA, 0xBA, 0xEA, 0x3B, 0x85, 0x58, 0x00, 0xC8, 0x4D,
    401     0x25, 0x5A, 0x05, 0xF4, 0xAF, 0x8B, 0x8F, 0x2F, 0x6C, 0xF2, 0x43, 0x8C, 0x86, 0x03, 0xFD, 0x1C,
    402     0xDF, 0x7A, 0xE4, 0xB6, 0x0B, 0xF9, 0x70, 0x72, 0xFC, 0x2A, 0xEC, 0x0F, 0x6D, 0x8D, 0x82, 0xC6,
    403     0x4C, 0x16, 0x81, 0xDC, 0xC9, 0x3C, 0x34, 0x84, 0x35, 0x9A, 0xA7, 0xED, 0xB1, 0x39, 0xBC
    404   }; //UNIQE EMM
    405 */
    406 
     380     uchar emmtest[] = { 0x87, 0x00, 0x8C, 0xC8, 0x4D, 0x25, 0x5A, 0x02, 0xA9, 0xA5, 0x34, 0x31, 0xAB, 0x9C, 0x9B, 0x59,
     381     0x5D, 0x47, 0x95, 0xB3, 0xB1, 0x61, 0x47, 0xE6, 0x85, 0xE0, 0x17, 0xC8, 0x25, 0x70, 0x59, 0x73,
     382     0x12, 0x1F, 0x2B, 0x9B, 0x02, 0x5A, 0x9D, 0x3A, 0x05, 0x56, 0x85, 0x58, 0x00, 0xC8, 0x4D, 0x25,
     383     0x5A, 0x06, 0x02, 0x23, 0xB4, 0x37, 0x1E, 0xE0, 0x7E, 0x59, 0xFC, 0x38, 0xCA, 0x13, 0x21, 0x0D,
     384     0x3E, 0x09, 0xDF, 0xB4, 0x45, 0x6C, 0x99, 0x7E, 0x3E, 0xDA, 0xA4, 0xC7, 0xB9, 0x7B, 0xAB, 0x4A,
     385     0xB5, 0xE2, 0x1D, 0xA3, 0xCD, 0x03, 0xAF, 0xDA, 0xBA, 0xEA, 0x3B, 0x85, 0x58, 0x00, 0xC8, 0x4D,
     386     0x25, 0x5A, 0x05, 0xF4, 0xAF, 0x8B, 0x8F, 0x2F, 0x6C, 0xF2, 0x43, 0x8C, 0x86, 0x03, 0xFD, 0x1C,
     387     0xDF, 0x7A, 0xE4, 0xB6, 0x0B, 0xF9, 0x70, 0x72, 0xFC, 0x2A, 0xEC, 0x0F, 0x6D, 0x8D, 0x82, 0xC6,
     388     0x4C, 0x16, 0x81, 0xDC, 0xC9, 0x3C, 0x34, 0x84, 0x35, 0x9A, 0xA7, 0xED, 0xB1, 0x39, 0xBC
     389     }; //UNIQE EMM
     390   */
     391 /*
    407392  uchar emmtest[] = { 0x89, 0x00, 0x68, 0x00, 0x4D, 0x56, 0x85, 0x58, 0x01, 0x00, 0x00, 0x00, 0x00, 0x06, 0x29, 0x58,
    408393    0x89, 0x04, 0x3A, 0xEE, 0x15, 0xB1, 0x38, 0x4A, 0x75, 0x5A, 0x21, 0xEE, 0x4D, 0x37, 0xF3, 0x53,
     
    411396    0xF2, 0xE1, 0xD9, 0x86, 0xEA, 0x19, 0x6A, 0xEF, 0x3B, 0x9D, 0x0C, 0xEA, 0xF3, 0x7B, 0x74, 0xE5,
    412397    0xF7, 0x4F, 0xD6, 0x9C, 0x85, 0x6C, 0x7E, 0x79, 0xDF, 0x18, 0xD1, 0xC3, 0x54, 0xA9, 0x47, 0xCB,
    413     0xAC, 0xB6, 0x18, 0x71, 0xC8, 0x69, 0x6B, 0x10, 0xFF, 0x9D, 0x11 }; //GLOBAL EMM
    414 
    415   memcpy (ep->emm, emmtest, 0x8f);
     398    0xAC, 0xB6, 0x18, 0x71, 0xC8, 0x69, 0x6B, 0x10, 0xFF, 0x9D, 0x11
     399  };                //GLOBAL EMM???
     400
     401  memcpy (ep->emm, emmtest, 0x8f);*/
    416402
    417403  int emm_length = ((ep->emm[1] & 0x0f) << 8) + ep->emm[2];
     
    419405  cs_ddump (ep->emm, emm_length + 3, "EMM:");
    420406  ep->type = ep->emm[0];
    421   cs_debug ("ep->type%x", ep->type);
    422 
    423   if (mode != 41) {
    424     cs_log ("EMM Mode not implemented yet");
    425     return 0;
    426   }
    427 
    428   static uchar emmcmd42[] =
    429     { 0x42, 0x85, 0x58, 0x01, 0xC8, 0x00, 0x00, 0x00, 0x05, 0xB8, 0x0C, 0xBD, 0x7B, 0x07, 0x04, 0xC8,
    430     0x77, 0x31, 0x95, 0xF2, 0x30, 0xB7, 0xE9, 0xEE, 0x0F, 0x81, 0x39, 0x1C, 0x1F, 0xA9, 0x11, 0x3E,
    431     0xE5, 0x0E, 0x8E, 0x50, 0xA4, 0x31, 0xBB, 0x01, 0x00, 0xD6, 0xAF, 0x69, 0x60, 0x04, 0x70, 0x3A,
    432     0x91,
    433     0x56, 0x58, 0x11
    434   };
    435 
    436   switch (ep->type) {
    437   case 0x88:            //shared EMM
    438     {
    439       cs_debug ("HANS: checkpoint 1");
    440       if (memcmp (ep->emm + 9, reader[ridx].sa[0], 1)) {    //in case of SHARED EMM, only first byte has to match?
    441     cs_log ("EMM: Shared update did not match; EMM SA:%02X%02X%02X%02X, Reader SA:%s.", ep->emm[9], ep->emm[10],
    442         ep->emm[11], ep->emm[12], cs_hexdump (0, reader[ridx].sa[0], 4));
    443     return (0);
    444       }
    445       else {
    446     cs_log ("EMM: Shared update matched for EMM SA %02X%02X%02X%02X.", ep->emm[9], ep->emm[19], ep->emm[11],
    447         ep->emm[12]);
    448       }
    449       /*
    450          01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16
    451          88 00 68 C8 4D 56 85 58 01 C8 00 00 00 05 B8 0C
    452 
    453          17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 --
    454          BD 7B 07 04 C8 77 31 95 F2 30 B7 E9 EE 0F 81 39
    455 
    456          33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 --
    457          1C 1F A9 11 3E E5 0E 8E 50 A4 31 BB 01 00 D6 AF
    458 
    459          49 50 51 52 53 54X55 56 57 58 59 60 61 62 63 64 --
    460          69 60 04 70 3A 91 3B 85 58 01 C8 00 00 00 05 B1
    461 
    462          65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 --
    463          3F BF A0 05 6E BD AB 0A 70 77 30 C2 AC EC 06 C2
    464 
    465          81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 --
    466          3D 47 50 8D B1 77 68 62 6B 26 6B CE A9 EF 1B 6A
    467 
    468          97 98 99 00 01 02 03 04 05 06 07 08 09 10 11 12 --
    469          DF 7B 39 52 A4 5A 0E B0 A6 ED 7B DC 82 3C AE A3
    470 
    471          Here we have:
    472 
    473          Bytes ...
    474          01 (88) - EMM filter can be a value 87
    475          03 (68) - length of data EMM
    476          04 (C8) - the number of SA for the filter (C8 - is a map)
    477          06 (56) - index kriptodannyh (56/3B alternate) are likely key number
    478 
    479          07 (85) - choice of algorithm (8x - MSP / 4x - Atmel), in the cards until only 85
    480          08 (01) - the type of EMM (00 - EMM_U, solo / 01 - EMM_S, group)
    481          10 - 13 (C8 00 00 00) - here only for SA EMM_S
    482          14 (05) - additional flags
    483          15 - 54 (V8. .. 91) own body EMM, information about the key.
    484          55 (3B) may be a checksum.
    485 
    486          Bytes 56 - 104 - for the second key.
    487          Appointment of the remaining bytes is unknown.
    488        */
    489     }               // end shared EMM NO BREAK so rest happens in global EMM
    490   case 0x89:            //global EMM ??
    491     {
    492       if (ep->type == 0x89)
    493     cs_log ("EMM: Global update");
    494       /* 89 00 68 00 4D 56 85 58 01 00 00 00 00 06 29 58
    495        * 89 04 3A EE 15 B1 38 4A 75 5A 21 EE 4D 37 F3 53
    496        * F8 AC 1F 8D EA DF 12 73 00 69 BB 67 5D 8A 96 2D
    497        * 1C 08 EB F1 CA 40X3BX85 58 01 00 00 00 00 05 85
    498        * F2 E1 D9 86 EA 19 6A EF 3B 9D 0C EA F3 7B 74 E5
    499        * F7 4F D6 9C 85 6C 7E 79 DF 18 D1 C3 54 A9 47 CB
    500        * AC B6 18 71 C8 69 6B 10 FF 9D 11
    501        */
    502       memcpy (emmcmd42 + 1, ep->emm + 6, 48);
     407  //cs_debug ("ep->type%x", ep->type);
     408
     409  if (mode == 51) {
     410    static uchar emmcmd52[0x3a];
     411    emmcmd52[0] = 0x52;
     412    int i;
     413    for (i = 0; i < 2; i++) {
     414      memcpy (emmcmd52 + 1, ep->emm + 5 + 32 + i * 56, 56);
     415      emmcmd52[0x39] = provider;
     416      if ((dre_cmd (emmcmd52)))
     417    if ((cta_res[cta_lr - 2] != 0x90) || (cta_res[cta_lr - 1] != 0x00))
     418      return (0);       //exit if response is not 90 00
     419    }
     420  }
     421
     422  else {
     423
     424    static uchar emmcmd42[] =
     425      { 0x42, 0x85, 0x58, 0x01, 0xC8, 0x00, 0x00, 0x00, 0x05, 0xB8, 0x0C, 0xBD, 0x7B, 0x07, 0x04, 0xC8,
     426      0x77, 0x31, 0x95, 0xF2, 0x30, 0xB7, 0xE9, 0xEE, 0x0F, 0x81, 0x39, 0x1C, 0x1F, 0xA9, 0x11, 0x3E,
     427      0xE5, 0x0E, 0x8E, 0x50, 0xA4, 0x31, 0xBB, 0x01, 0x00, 0xD6, 0xAF, 0x69, 0x60, 0x04, 0x70, 0x3A,
     428      0x91,
     429      0x56, 0x58, 0x11
     430    };
     431/*
     432    if (memcmp (ep->emm + 9, reader[ridx].sa[0], 1)) {  //in case of SHARED EMM, only first byte has to match?
     433      cs_log ("EMM: Shared update did not match; EMM SA:%02X%02X%02X%02X, Reader SA:%s.", ep->emm[9], ep->emm[10],
     434          ep->emm[11], ep->emm[12], cs_hexdump (0, reader[ridx].sa[0], 4));
     435      return (0);
     436    }
     437    else {
     438      cs_log ("EMM: Shared update matched for EMM SA %02X%02X%02X%02X.", ep->emm[9], ep->emm[19], ep->emm[11],
     439          ep->emm[12]);
     440    } */
     441    /*
     442       01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16
     443       88 00 68 C8 4D 56 85 58 01 C8 00 00 00 05 B8 0C
     444
     445       17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 --
     446       BD 7B 07 04 C8 77 31 95 F2 30 B7 E9 EE 0F 81 39
     447
     448       33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 --
     449       1C 1F A9 11 3E E5 0E 8E 50 A4 31 BB 01 00 D6 AF
     450
     451       49 50 51 52 53 54X55 56 57 58 59 60 61 62 63 64 --
     452       69 60 04 70 3A 91 3B 85 58 01 C8 00 00 00 05 B1
     453
     454       65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 --
     455       3F BF A0 05 6E BD AB 0A 70 77 30 C2 AC EC 06 C2
     456
     457       81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 --
     458       3D 47 50 8D B1 77 68 62 6B 26 6B CE A9 EF 1B 6A
     459
     460       97 98 99 00 01 02 03 04 05 06 07 08 09 10 11 12 --
     461       DF 7B 39 52 A4 5A 0E B0 A6 ED 7B DC 82 3C AE A3
     462
     463       Here we have:
     464
     465       Bytes ...
     466       01 (88) - EMM filter can be a value 87
     467       03 (68) - length of data EMM
     468       04 (C8) - the number of SA for the filter (C8 - is a map)
     469       06 (56) - index kriptodannyh (56/3B alternate) are likely key number
     470
     471       07 (85) - choice of algorithm (8x - MSP / 4x - Atmel), in the cards until only 85
     472       08 (01) - the type of EMM (00 - EMM_U, solo / 01 - EMM_S, group)
     473       10 - 13 (C8 00 00 00) - here only for SA EMM_S
     474       14 (05) - additional flags
     475       15 - 54 (V8. .. 91) own body EMM, information about the key.
     476       55 (3B) may be a checksum.
     477
     478       Bytes 56 - 104 - for the second key.
     479       Appointment of the remaining bytes is unknown.
     480     */
     481    memcpy (emmcmd42 + 1, ep->emm + 6, 48);
     482    emmcmd42[51] = provider;
     483    //emmcmd42[50] = ecmcmd42[2]; //TODO package nr could also be fixed 0x58
     484    emmcmd42[50] = 0x58;
     485    emmcmd42[49] = ep->emm[5];  //keynr
     486    /* response:
     487       59 05 A2 02 05 01 5B
     488       90 00 */
     489    if ((dre_cmd (emmcmd42))) { //first emm request
     490      if ((cta_res[cta_lr - 2] != 0x90) || (cta_res[cta_lr - 1] != 0x00))
     491    return (0);     //exit if response is not 90 00
     492
     493      memcpy (emmcmd42 + 1, ep->emm + 55, 7); //TODO OR next two lines?
     494      /*memcpy (emmcmd42 + 1, ep->emm + 55, 7);  //FIXME either I cant count or my EMM log contains errors
     495         memcpy (emmcmd42 + 8, ep->emm + 67, 41); */
    503496      emmcmd42[51] = provider;
    504497      //emmcmd42[50] = ecmcmd42[2]; //TODO package nr could also be fixed 0x58
    505       emmcmd42[49] = ep->emm[5];    //keynr
    506       /* response:
    507          59 05 A2 02 05 01 5B
    508          90 00 */
    509       cs_debug ("HANS: checkpoint 5");
    510       if ((dre_cmd (emmcmd42))) {   //first emm request
     498      emmcmd42[50] = 0x58;
     499      emmcmd42[49] = ep->emm[54];   //keynr
     500      if ((dre_cmd (emmcmd42))) {   //second emm request
    511501    if ((cta_res[cta_lr - 2] != 0x90) || (cta_res[cta_lr - 1] != 0x00))
    512502      return (0);       //exit if response is not 90 00
    513 
    514     cs_debug ("HANS: checkpoint 6");
    515     memcpy (emmcmd42 + 1, ep->emm + 55, 7);
    516     memcpy (emmcmd42 + 8, ep->emm + 67, 41);
    517     emmcmd42[51] = provider;
    518     //emmcmd42[50] = ecmcmd42[2]; //TODO package nr could also be fixed 0x58
    519     emmcmd42[49] = ep->emm[54]; //keynr
    520     if ((dre_cmd (emmcmd42))) { //second emm request
    521       if ((cta_res[cta_lr - 2] != 0x90) || (cta_res[cta_lr - 1] != 0x00))
    522         return (0);     //exit if response is not 90 00
    523       return 1;     //success
    524     }
     503    return 1;       //success
    525504      }
    526 
    527       break;
    528     }               //end global EMM
    529   case 0x87:            //unique EMM
    530     {
    531       /*
    532          0x87, 0x00, 0x8C, ser1, ser2, ser3, ser4, 0x02, 0xA9, 0xA5, 0x34, 0x31, 0xAB, 0x9C, 0x9B, 0x59,
    533          0x5D, 0x47, 0x95, 0xB3, 0xB1, 0x61, 0x47, 0xE6, 0x85, 0xE0, 0x17, 0xC8, 0x25, 0x70, 0x59, 0x73,
    534          0x12, 0x1F, 0x2B, 0x9B, 0x02, 0x5A, 0x9D, 0x3A, 0x05, 0x56, 0x85, 0x58, 0x00, 0xC8, 0x4D, 0x25,
    535          0x5A, 0x06, 0x02, 0x23, 0xB4, 0x37, 0x1E, 0xE0, 0x7E, 0x59, 0xFC, 0x38, 0xCA, 0x13, 0x21, 0x0D,
    536          0x3E, 0x09, 0xDF, 0xB4, 0x45, 0x6C, 0x99, 0x7E, 0x3E, 0xDA, 0xA4, 0xC7, 0xB9, 0x7B, 0xAB, 0x4A,
    537          0xB5, 0xE2, 0x1D, 0xA3, 0xCD, 0x03, 0xAF, 0xDA, 0xBA, 0xEA, 0x3B, 0x85, 0x58, 0x00, 0xC8, 0x4D,
    538          0x25, 0x5A, 0x05, 0xF4, 0xAF, 0x8B, 0x8F, 0x2F, 0x6C, 0xF2, 0x43, 0x8C, 0x86, 0x03, 0xFD, 0x1C,
    539          0xDF, 0x7A, 0xE4, 0xB6, 0x0B, 0xF9, 0x70, 0x72, 0xFC, 0x2A, 0xEC, 0x0F, 0x6D, 0x8D, 0x82, 0xC6,
    540          0x4C, 0x16, 0x81, 0xDC, 0xC9, 0x3C, 0x34, 0x84, 0x35, 0x9A, 0xA7, 0xED, 0xB1, 0x39, 0xBC
    541        */
    542       cs_debug ("HANS: checkpoint 2");
    543       //first test if UA matches
    544       if (memcmp (reader[ridx].hexserial + 2, ep->emm + 3, 4)) {
    545     cs_log ("EMM: Unique update did not match; EMM Serial:%02X%02X%02X%02X, Reader Serial:%s.", ep->emm[3],
    546         ep->emm[4], ep->emm[5], ep->emm[6], cs_hexdump (0, reader[ridx].hexserial + 2, 4));
    547     return (0);
    548       }
    549       else {
    550     cs_log ("EMM: Unique update matched EMM Serial:%02X%02X%02X%02X.", ep->emm[3], ep->emm[4], ep->emm[5],
    551         ep->emm[6]);
    552     cs_log ("EMM: layout of EMM 0x87 unknown, cannot be processed yet.");
    553       }
    554       break;
    555     }               //end unique EMM
    556   default:
    557     cs_log
    558       ("EMM: Congratulations, you have discovered a new EMM type on DRECRYPT. This has not been decoded yet, so send this output to authors:");
    559     cs_dump (ep->emm, emm_length + 3, "EMM:");
    560     return 0;           //unknown
    561   }             //end of switch
    562 
    563 
    564   cs_debug ("HANS: checkpoint 3");
     505    }
     506  }
     507
     508  /*
     509     0x87, 0x00, 0x8C, ser1, ser2, ser3, ser4, 0x02, 0xA9, 0xA5, 0x34, 0x31, 0xAB, 0x9C, 0x9B, 0x59,
     510     0x5D, 0x47, 0x95, 0xB3, 0xB1, 0x61, 0x47, 0xE6, 0x85, 0xE0, 0x17, 0xC8, 0x25, 0x70, 0x59, 0x73,
     511     0x12, 0x1F, 0x2B, 0x9B, 0x02, 0x5A, 0x9D, 0x3A, 0x05, 0x56, 0x85, 0x58, 0x00, 0xC8, 0x4D, 0x25,
     512     0x5A, 0x06, 0x02, 0x23, 0xB4, 0x37, 0x1E, 0xE0, 0x7E, 0x59, 0xFC, 0x38, 0xCA, 0x13, 0x21, 0x0D,
     513     0x3E, 0x09, 0xDF, 0xB4, 0x45, 0x6C, 0x99, 0x7E, 0x3E, 0xDA, 0xA4, 0xC7, 0xB9, 0x7B, 0xAB, 0x4A,
     514     0xB5, 0xE2, 0x1D, 0xA3, 0xCD, 0x03, 0xAF, 0xDA, 0xBA, 0xEA, 0x3B, 0x85, 0x58, 0x00, 0xC8, 0x4D,
     515     0x25, 0x5A, 0x05, 0xF4, 0xAF, 0x8B, 0x8F, 0x2F, 0x6C, 0xF2, 0x43, 0x8C, 0x86, 0x03, 0xFD, 0x1C,
     516     0xDF, 0x7A, 0xE4, 0xB6, 0x0B, 0xF9, 0x70, 0x72, 0xFC, 0x2A, 0xEC, 0x0F, 0x6D, 0x8D, 0x82, 0xC6,
     517     0x4C, 0x16, 0x81, 0xDC, 0xC9, 0x3C, 0x34, 0x84, 0x35, 0x9A, 0xA7, 0xED, 0xB1, 0x39, 0xBC
     518   */
    565519  return 0;
    566520}
Note: See TracChangeset for help on using the changeset viewer.