Greetings
Latest news to you our solidarity NDS has been piracy
By italian hack team
And this topic is the algorithm for lovers of programming
algorithms
#include
#define KEYLEN 4
#define DATLEN 8
#define TABLEN_64 64
#define TABLEN_96 96
#define TABLEN_128 128
typedef unsigned char byte;
typedef unsigned long word;
byte hop0[7] = { 2, 6, 3, 7, 4, 1, 5 };
byte hop1[7] = { 7, 1, 4, 5, 3, 2, 6 }; //adjusted for algo_1
byte hop2[5] = { 2, 7, 4, 1, 3 }; //adjusted for algo_2
//byte hop1[7] = { 1, 7, 6, 2, 3, 5, 4 };
// 2 1
// 9 8 7 6 5 4 3
// ... 11 10
//byte hop2[5] = { 3, 1, 4, 7, 2 };
// 5 4 3 2 1
// ... 6
byte box_id_0[4] = { 0x01,0x02,0x03,0x04 };
byte cw_0[8] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
byte cw_2[8] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
byte box_id_1[4] = { 0x01,0x02,0x03,0x04 };
byte cw_1[8] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
byte cw_3[8] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
byte box_id[4] = { 0x01,0x02,0x03,0x04 };
byte cw[8] = { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef };
byte tab_0[TABLEN_64] =
{
0x39,0x9E,0x97,0x55,0x10,0x66,0xBD,0x04, 0x42,0xBF, 0x3B,0x28,0x71,0x20,0xB3,0x7F,
0x1A,0xD1,0xBE,0xFE,0x9D,0x8F,0x03,0x9E, 0x10,0x0A, 0xC0,0xE6,0x40,0x17,0x15,0xE9,
0xE9,0x87,0xCD,0xA1,0xDF,0xE1,0xD7,0x72, 0xDD,0xDB, 0x52,0x0A,0x36,0xA2,0xC1,0xB1,
0xAD,0x43,0x0F,0x70,0xAC,0xCB,0x26,0x61, 0x7E,0xAC, 0xBD,0x29,0xBE,0x01,0x00,0x01
};
byte tab_1[TABLEN_64] =
{
0xC1,0x7A,0x12,0xD2,0x17,0xE8,0x44,0x4B, 0x63,0x02, 0x72,0x59,0x4A,0x54,0x6F,0x01,
0x65,0x5D,0x9D,0xD5,0xB7,0x7A,0xBD,0x83, 0xA5,0xF9, 0x6E,0xF7,0x84,0x69,0x7B,0x47,
0x9C,0x1A,0xB0,0xDB,0x41,0x4C,0xA4,0xA3, 0x3F,0x92, 0x59,0x30,0xD3,0x64,0x76,0x5F,
0xF8,0x24,0xE6,0x3E,0x0E,0x02,0x2B,0x16, 0xD1,0x1D, 0xF5,0xA9,0x88,0x01,0x00,0x01
};
byte tab_2[TABLEN_64] =
{
0x81,0x57,0xF8,0x61,0x83,0x5A,0xB9,0xE5, 0xDB,0x8B, 0x3E,0x7D,0x21,0x0D,0x90,0x9F,
0x26,0xF0,0x07,0x2E,0xB0,0xB6,0x70,0x00, 0xA1,0x92, 0xA4,0x1E,0x69,0xEF,0xEA,0xA3,
0xAE,0xF3,0xD7,0x40,0xB6,0x73,0x55,0x11, 0xA1,0xD4, 0x06,0xC0,0x96,0x37,0x5D,0x80,
0x47,0x91,0x45,0x20,0x99,0x46,0x66,0x3D, 0x05,0xFA, 0xA4,0xB6,0x3D,0x01,0x00,0x01
};
byte tab_3[TABLEN_64] =
{
0x25,0xE7,0x7E,0x0D,0x2D,0x82,0x1B,0xF6, 0x72,0xEA, 0xC8,0x26,0xBA,0xF5,0x55,0xB8,
0x3B,0xEB,0xA8,0xB4,0x38,0x83,0x36,0x4D, 0xD7,0xB8, 0xF1,0x54,0x0F,0x4D,0x1A,0x37,
0x82,0x8E,0xD2,0xB9,0x9C,0x17,0x6D,0x8C, 0x7E,0xA6, 0x61,0x0A,0x31,0x45,0xA3,0x29,
0x69,0x22,0xB7,0x29,0xF0,0x35,0xC7,0x62, 0x54,0x23, 0xF2,0x3F,0xDD,0x01,0x00,0x01
};
byte tab_4[TABLEN_64] =
{
0xC9,0x79,0xCB,0x88,0xDD,0xEE,0xDE,0x8B, 0x10,0x19, 0x28,0xD4,0xB6,0xA2,0x48,0x9F,
0xF2,0x68,0x5B,0x8A,0xDC,0x02,0x48,0xC4, 0x2B,0xFE, 0xD2,0xC7,0xDC,0x6E,0x30,0x5D,
0x11,0x81,0x55,0xE9,0xE9,0x6D,0x43,0x5D, 0x0F,0x45, 0x70,0x5C,0x72,0x57,0xFE,0xDF,
0x54,0xE6,0xC1,0x76,0x32,0x98,0xF4,0xD5, 0x27,0x6E, 0xBE,0x40,0xA0,0x01,0x00,0x01
};
byte tab_5[TABLEN_64] =
{
0xF9,0x0C,0x1C,0xFB,0xE0,0x3B,0xBF,0xE9, 0x44,0xD1, 0x6B,0x60,0x27,0xF8,0x9F,0xDF,
0xAE,0xEB,0xFB,0xD4,0x1F,0x87,0x1F,0x54, 0xFD,0x40, 0xED,0x11,0x7D,0xEF,0x1C,0x72,
0x7C,0x8D,0xFF,0xCE,0x59,0x04,0x60,0xB4, 0x2E,0x30, 0x42,0x65,0xF0,0x10,0x5F,0x52,
0x7D,0x2B,0x9A,0x42,0xF3,0xAD,0x3C,0xD9, 0xDD,0x49, 0x07,0x41,0x36,0x01,0x00,0x01
};
byte tab_6[TABLEN_64] =
{
0x11,0x89,0x79,0x12,0x7D,0xD8,0xA8,0x89, 0x2F,0x62, 0x54,0x20,0x2F,0xEE,0xDD,0x64,
0xB6,0x61,0x93,0xE7,0xFD,0xF8,0xFD,0xE1, 0x20,0x84, 0x0D,0x91,0x52,0x0E,0xA4,0xFA,
0xD3,0xD3,0x0A,0x0A,0x8B,0x7C,0xDC,0xCB, 0x70,0x1E, 0xE1,0x04,0xE8,0x33,0xC7,0x00,
0x1E,0x38,0xD4,0x2A,0xDD,0x5A,0x00,0x27, 0xCC,0xDE, 0xB9,0xF8,0xCD,0x01,0x00,0x01
};
byte tab_7[TABLEN_64] =
{
0x21,0xD9,0xD6,0xC0,0x0D,0x31,0xBE,0x77, 0xC2,0xCD, 0xBE,0xF8,0xE3,0xB2,0x2B,0xF7,
0x16,0x07,0x83,0x57,0x5F,0x1A,0x68,0xB5, 0xAF,0xE9, 0xEF,0x45,0x6C,0x09,0xFF,0x3A,
0x00,0xD7,0x5C,0xB8,0x04,0x58,0x81,0x24, 0x68,0xFB, 0x1E,0xDD,0x15,0x3B,0x0A,0xBD,
0x0E,0xE7,0x03,0xF8,0x3F,0x0D,0x0C,0x2E, 0xDF,0x7F, 0x8B,0x9B,0x52,0x01,0x00,0x01
};
byte tab_8[TABLEN_96] =
{
0x75,0x46,0xB3,0xD1,0xF3,0x2C,0xA0,0x0C, 0xD8,0x2D, 0x7C,0x40,0xE0,0x99,0x36,0x76,
0x23,0xF9,0x47,0x30,0x3F,0x8D,0x26,0x1B, 0x0F,0x20, 0x43,0x60,0x15,0x67,0xAE,0xB4,
0x6D,0x99,0xAA,0x5D,0x95,0x11,0xCF,0xFE, 0xDB,0x54, 0xD1,0x7C,0x7B,0x51,0x26,0xD3,
0x9F,0xAD,0x2E,0x44,0xC4,0x25,0xEE,0xB3, 0x06,0x12, 0x88,0x7A,0x4E,0x19,0x23,0xA9,
0xF5,0x33,0x2A,0xFE,0xB6,0xD9,0xFA,0xC0, 0xE7,0x76, 0xD1,0xCD,0xC5,0xAF,0x71,0x68,
0x34,0xE9,0xC8,0x3A,0x4E,0x4D,0xF6,0xE7, 0xF3,0x99, 0x60,0xFC,0x80,0x01,0x00,0x01
};
byte tab_9[TABLEN_96] =
{
0x31,0x27,0xEB,0x22,0x37,0xD5,0x38,0xAB, 0x33,0x29, 0xFD,0x5E,0x26,0x22,0xAE,0xF6,
0x8F,0xE5,0xED,0x3E,0xB5,0xFB,0x95,0xDA, 0x49,0x92, 0xD6,0xEB,0xE0,0xD2,0x26,0x43,
0x7C,0x0F,0x62,0x3D,0xD9,0xCF,0xA7,0x47, 0x63,0x2E, 0x03,0xDA,0xE3,0xAD,0x58,0x52,
0xBB,0xDD,0xC4,0x10,0x6E,0x52,0xF0,0x71, 0xC3,0xCE, 0x5D,0x93,0x11,0x03,0x89,0x84,
0x07,0x68,0x32,0x5C,0x2F,0xB3,0x81,0x0F, 0x25,0x29, 0x1A,0x19,0xB1,0xC8,0xA4,0xE8,
0x61,0xF1,0x98,0xEA,0x70,0x4F,0xEB,0xB8, 0xB4,0xF3, 0xB8,0x06,0x7F,0x01,0x00,0x01
};
byte tab_a[TABLEN_96] =
{
0x21,0x14,0x39,0xA6,0x78,0xF5,0x70,0xD1, 0xEC,0xE2, 0x5A,0xBE,0x4A,0x5C,0x4F,0xD7,
0xB4,0x33,0x25,0x93,0x7F,0x23,0x2F,0xD6, 0x7A,0xCC, 0x6F,0xE7,0xE8,0x18,0x02,0x25,
0x16,0x2C,0x07,0x3E,0xD3,0x62,0x61,0xA3, 0x13,0x03, 0x29,0xE4,0x8D,0xBB,0x6F,0x66,
0xF2,0x91,0xDE,0xDD,0xCD,0x59,0x61,0x94, 0x90,0x0A, 0x53,0x67,0x2B,0x44,0x8A,0xD0,
0x2F,0x11,0x1A,0x34,0xB2,0x07,0xDF,0x6B, 0x9F,0xE9, 0x07,0x0B,0x22,0xB5,0x17,0x11,
0x7A,0xCD,0x94,0xE4,0xAE,0x7F,0xEC,0x20, 0xF0,0xCC, 0xFC,0x4F,0x97,0x01,0x00,0x01
};
byte tab_b[TABLEN_96] =
{
0x11,0xBA,0x15,0x2C,0x56,0xB9,0xBD,0x5F, 0xA3,0x2C, 0x75,0x5D,0x2D,0x9A,0x11,0x8A,
0xFA,0x71,0x70,0x64,0x82,0x1E,0x46,0xDB, 0x3C,0xE9, 0x9D,0xFE,0xE6,0x26,0xBC,0xFE,
0xEF,0x1C,0x7A,0x8C,0x9A,0x02,0xEB,0xF4, 0xF6,0xE8, 0x6D,0x27,0xF0,0x8C,0xB2,0x4C,
0x10,0xD5,0xD7,0xC7,0xD9,0x8A,0x35,0x70, 0x97,0x43, 0x7D,0x9B,0xA9,0x2E,0x14,0x64,
0x1C,0x10,0x3D,0xF9,0x19,0x96,0xFF,0xCD, 0xA4,0xEA, 0x33,0xA7,0x8F,0x25,0x3D,0x37,
0x0C,0xFB,0x74,0x1E,0xBF,0x74,0xC2,0x7E, 0x54,0x7B, 0xDB,0xCF,0x43,0x01,0x00,0x01
};
byte tab_c[TABLEN_96] =
{
0x29,0xCC,0x51,0xC2,0xEE,0x5F,0x9F,0xEF, 0x4B,0x0A, 0x92,0xEF,0x44,0x5C,0xC2,0xA7,
0xBF,0xDE,0x0A,0x23,0x58,0x4F,0xBA,0xBC, 0xBB,0x5A, 0x7E,0x5A,0x6F,0xCA,0xAC,0x9E,
0x4B,0x48,0x8B,0x9F,0x8D,0x86,0xEC,0x7F, 0x64,0xB0, 0xE1,0xEC,0x7F,0x80,0xAA,0x03,
0x31,0x48,0x8D,0x2A,0x3C,0x1D,0xF2,0x75, 0x75,0xFF, 0xEC,0x77,0xF1,0xD3,0x7D,0xAC,
0xD0,0x06,0x49,0xD2,0x35,0x7E,0x10,0xB0, 0x7C,0x2E, 0x07,0x0A,0x1A,0xCF,0x70,0x06,
0x23,0x88,0xEC,0xFA,0xCB,0x9C,0x98,0x68, 0x71,0xA0, 0x82,0xEE,0x2B,0x01,0x00,0x01
};
byte tab_d[TABLEN_96] =
{
0x0D,0xF9,0x08,0xEF,0xD4,0xD9,0x05,0x62, 0x7C,0x92, 0x04,0x85,0x40,0x27,0x88,0x7B,
0x60,0xC2,0xBB,0x10,0x61,0x32,0x0A,0x04, 0xA4,0xFE, 0xEC,0x1C,0x2D,0x3C,0x62,0x4A,
0xC2,0xB6,0xDA,0x88,0x90,0x25,0x24,0xD4, 0x0E,0xBA, 0xEC,0x31,0xAA,0x19,0x1F,0x97,
0x45,0xF5,0x6A,0x3C,0x1A,0xA9,0xA7,0xCF, 0xC5,0x7C, 0xD2,0xE5,0x46,0x10,0xF6,0x99,
0x57,0x90,0x54,0x00,0x45,0x87,0x79,0xD3, 0xA1,0x25, 0x8D,0x8A,0xC1,0x17,0xE1,0x70,
0x27,0x28,0x4A,0xE3,0xDA,0x5E,0xA9,0x41, 0xA1,0x8F, 0xFD,0x1D,0x31,0x01,0x00,0x01
};
byte tab_e[TABLEN_96] =
{
0x45,0xEF,0xED,0xAC,0x77,0xA8,0x3D,0xA1, 0x66,0x6C, 0x58,0xBD,0xD1,0x80,0x16,0x29,
0x38,0x7C,0xE7,0x03,0xB0,0xD1,0x5E,0x89, 0xC7,0xE7, 0xA3,0x77,0x50,0x35,0x8F,0xB7,
0xA5,0x0C,0x70,0x79,0xAF,0x63,0xAD,0xF0, 0x39,0xA1, 0xA6,0xEF,0x55,0x17,0x97,0x48,
0x76,0xE1,0xB4,0x74,0xAA,0x6C,0x9A,0x32, 0xDB,0xF1, 0xEC,0x70,0xC6,0x8B,0x96,0x78,
0x69,0x70,0x13,0x0B,0x49,0x20,0xFE,0x69, 0xDD,0x0F, 0x08,0x42,0x8F,0x04,0x45,0xEC,
0x5D,0x48,0xAF,0x42,0x57,0x8C,0x27,0x62, 0xB8,0xB7, 0x7F,0x34,0xC0,0x01,0x00,0x01
};
byte tab_f[TABLEN_96] =
{
0xE5,0xCD,0xA7,0x08,0xF9,0x82,0x2F,0x61, 0x40,0xA0, 0xFA,0xF8,0x94,0x66,0xE5,0xDC,
0xA6,0xFB,0x4F,0x53,0x24,0x20,0x2F,0xD3, 0x43,0x4D, 0x73,0xA0,0x66,0x08,0x6A,0x94,
0xAD,0x8D,0x51,0xFA,0x48,0x9D,0xA7,0xE8, 0xB8,0xC8, 0xCB,0x94,0x6E,0x17,0x0C,0x21,
0x4C,0xB6,0x7F,0xCC,0x59,0x4C,0x9C,0x9E, 0xB5,0x86, 0x94,0xAA,0xDA,0xF3,0x79,0x69,
0x34,0x8D,0xA5,0x55,0xD2,0xDE,0x0D,0x22, 0xB9,0x49, 0x5C,0x88,0x96,0x7C,0x23,0x66,
0xDE,0xA7,0x47,0x27,0xD3,0x42,0xC6,0x9B, 0x58,0x04, 0xC9,0x07,0x35,0x01,0x00,0x01
};
byte tab_10[TABLEN_128] =
{
0x31,0x22,0x5C,0xB4,0x4A,0x6A,0xE2,0x0E, 0x05,0x32, 0xC7,0x48,0x90,0xB3,0xB7,0x70,
0xE1,0xA7,0x5E,0x19,0xB8,0x51,0xE1,0x67, 0xD8,0xA3, 0xE5,0x68,0xCD,0x84,0x08,0x3D,
0x25,0x8A,0xC7,0xA6,0x43,0x73,0x0F,0x53, 0x7C,0xE4, 0xED,0x72,0x52,0x0A,0x8E,0x17,
0x83,0x08,0xE2,0x64,0x4C,0xA6,0xF0,0x00, 0xE3,0x4C, 0xFD,0xAB,0x20,0x88,0x8D,0xD5,
0x39,0x9E,0x97,0x55,0x10,0x66,0xBD,0x04, 0x42,0xBF, 0x3B,0x28,0x71,0x20,0xB3,0x7F,
0x1A,0xD1,0xBE,0xFE,0x9D,0x8F,0x03,0x9E, 0x10,0x0A, 0xC0,0xE6,0x40,0x17,0x15,0xE9,
0xE9,0x87,0xCD,0xA1,0xDF,0xE1,0xD7,0x72, 0xDD,0xDB, 0x52,0x0A,0x36,0xA2,0xC1,0xB1,
0xAD,0x43,0x0F,0x70,0xAC,0xCB,0x26,0x61, 0x7E,0xAC, 0xBD,0x29,0xBE,0x01,0x00,0x01
};
byte tab_11[TABLEN_128] =
{
0xF1,0xC2,0x43,0xDD,0x90,0x2D,0xC7,0x8E, 0xEF,0x03, 0x16,0x7E,0x0E,0x13,0x5B,0x56,
0xE2,0xB9,0x34,0xE8,0xF0,0xC5,0x20,0xA0, 0x14,0x5D, 0x57,0xC2,0xE1,0x98,0xB1,0xBA,
0x5B,0x72,0x80,0xEF,0xB3,0x20,0xFB,0xBA, 0x93,0x49, 0xBA,0x67,0xE5,0x1E,0x2C,0x4A,
0xE7,0xD3,0x6F,0x7F,0x60,0x4C,0x89,0x75, 0x03,0x3E, 0x42,0x82,0x70,0xA9,0xA8,0x82,
0xC1,0x7A,0x12,0xD2,0x17,0xE8,0x44,0x4B, 0x63,0x02, 0x72,0x59,0x4A,0x54,0x6F,0x01,
0x65,0x5D,0x9D,0xD5,0xB7,0x7A,0xBD,0x83, 0xA5,0xF9, 0x6E,0xF7,0x84,0x69,0x7B,0x47,
0x9C,0x1A,0xB0,0xDB,0x41,0x4C,0xA4,0xA3, 0x3F,0x92, 0x59,0x30,0xD3,0x64,0x76,0x5F,
0xF8,0x24,0xE6,0x3E,0x0E,0x02,0x2B,0x16, 0xD1,0x1D, 0xF5,0xA9,0x88,0x01,0x00,0x01
};
byte tab_12[TABLEN_128] =
{
0xE9,0x46,0x96,0x7E,0xA9,0xE9,0x18,0x1B, 0x01,0x0A, 0x26,0x93,0xAE,0xC3,0xE9,0x7E,
0x41,0x39,0xEA,0xE6,0xE5,0xAF,0xBA,0xC2, 0xD7,0x0B, 0xBB,0x22,0xA8,0x28,0x71,0xF0,
0x99,0x4E,0x87,0xF7,0x6C,0xF5,0x43,0x4B, 0x2B,0x2A, 0x5D,0x53,0x85,0xFB,0x3E,0xA3,
0x84,0x77,0xD1,0xF7,0xF8,0xA3,0x6F,0x8A, 0x2F,0xD5, 0x46,0x67,0xE1,0x61,0x94,0xDB,
0x81,0x57,0xF8,0x61,0x83,0x5A,0xB9,0xE5, 0xDB,0x8B, 0x3E,0x7D,0x21,0x0D,0x90,0x9F,
0x26,0xF0,0x07,0x2E,0xB0,0xB6,0x70,0x00, 0xA1,0x92, 0xA4,0x1E,0x69,0xEF,0xEA,0xA3,
0xAE,0xF3,0xD7,0x40,0xB6,0x73,0x55,0x11, 0xA1,0xD4, 0x06,0xC0,0x96,0x37,0x5D,0x80,
0x47,0x91,0x45,0x20,0x99,0x46,0x66,0x3D, 0x05,0xFA, 0xA4,0xB6,0x3D,0x01,0x00,0x01
};
byte tab_13[TABLEN_128] =
{
0x89,0x85,0x20,0x21,0x63,0x33,0x87,0xF1, 0xD4,0x17, 0x2E,0x61,0xEC,0x16,0x5D,0xB2,
0xDE,0x4D,0x8A,0x15,0xFF,0xD4,0x0F,0x18, 0x5C,0x43, 0x9F,0xBC,0x8D,0xAF,0x83,0x22,
0xEC,0x04,0x98,0x10,0x5C,0xE2,0xCE,0xB0, 0xDB,0x7B, 0xD4,0x1B,0x85,0x47,0x16,0x05,
0xC1,0x8A,0x2D,0xD1,0xB7,0x1E,0x5A,0x01, 0x39,0xFF, 0xF8,0xA2,0x0B,0x2B,0xC2,0xDD,
0x25,0xE7,0x7E,0x0D,0x2D,0x82,0x1B,0xF6, 0x72,0xEA, 0xC8,0x26,0xBA,0xF5,0x55,0xB8,
0x3B,0xEB,0xA8,0xB4,0x38,0x83,0x36,0x4D, 0xD7,0xB8, 0xF1,0x54,0x0F,0x4D,0x1A,0x37,
0x82,0x8E,0xD2,0xB9,0x9C,0x17,0x6D,0x8C, 0x7E,0xA6, 0x61,0x0A,0x31,0x45,0xA3,0x29,
0x69,0x22,0xB7,0x29,0xF0,0x35,0xC7,0x62, 0x54,0x23, 0xF2,0x3F,0xDD,0x01,0x00,0x01
};
byte tab_HU_0[TABLEN_64] = //tab_H_0
{
0xB1,0xB5,0x0A,0x49,0x47,0x5A,0x3B,0xA5, 0x6D,0x28, 0xE0,0x04,0xC2,0x3A,0x56,0xF7,
0xE6,0x38,0xCE,0xE7,0x8B,0xE1,0xAD,0x8C, 0x61,0x09, 0x06,0xDB,0xFE,0x11,0x4A,0xE3,
0x6E,0x83,0xEF,0x57,0x49,0x61,0xFF,0x69, 0x8F,0x61, 0xCD,0xD1,0x1E,0x9D,0x9C,0x16,
0x72,0x72,0xE6,0x1D,0xF0,0x84,0x4F,0x4A, 0x77,0x02, 0xD7,0xE8,0x39,0x01,0x00,0x01
};
byte tab_HU_1[TABLEN_64] = //tab_H_1
{
0x2D,0xE7,0x03,0xD1,0x83,0xB4,0xE1,0xC8, 0x77,0xF0, 0x4A,0xF5,0xE4,0x9E,0x13,0xD5,
0xCC,0xFD,0x63,0x19,0x13,0xDE,0xB5,0x1F, 0x8B,0x31, 0xB0,0x4A,0x4A,0x8C,0x25,0x74,
0x09,0x26,0x43,0xE5,0x3C,0xF4,0x45,0xD3, 0xD8,0x28, 0xCE,0x0B,0xF5,0xC5,0x60,0x59,
0x3D,0x97,0x27,0x8A,0x59,0x76,0x2D,0xD0, 0xC2,0xC9, 0xCD,0x68,0xD4,0x01,0x00,0x01
};
byte tab_HU_2[TABLEN_64] =
{
0x11,0x90,0xA6,0x92,0x67,0xDB,0x0D,0xC1, 0xFD,0x4B, 0x57,0xFA,0x31,0x3D,0x6C,0xCB,
0x73,0x0E,0xA5,0xF6,0x81,0x3D,0xFA,0xE1, 0x61,0x16, 0x4F,0x1A,0x9D,0xFD,0xDD,0x5D,
0xC4,0xEF,0x6A,0x12,0x42,0xE9,0x3F,0x8B, 0x31,0x4F, 0xB1,0x8A,0x77,0xF7,0x90,0xAE,
0x04,0x9F,0xED,0xD6,0x12,0x26,0x7F,0xEC, 0xAE,0xFC, 0x45,0x01,0x74,0x01,0x00,0x01
};
byte tab_HU_3[TABLEN_64] =
{
0x39,0xD7,0x88,0xAB,0x7B,0x31,0xF5,0xE2, 0x7D,0x6B, 0x5A,0xCA,0xBB,0x9D,0xAC,0xE8,
0x68,0xAC,0x05,0xEE,0x6A,0x3A,0x21,0x12, 0x0C,0x05, 0x47,0x66,0x83,0x8D,0x5F,0xF0,
0x6E,0x4F,0x9E,0x65,0x45,0x44,0x6E,0xF7, 0x68,0xEE, 0x72,0x89,0x78,0xF4,0xE9,0x7D,
0x41,0x68,0x4A,0x30,0x45,0x5D,0x6B,0x42, 0xD1,0x02, 0x45,0x14,0x94,0x01,0x00,0x01
};
void print(byte *buf, int len);
void cardcrypt(byte *key, byte *dat, byte *tab, byte TABLEN);
void icamcrypt(byte *key, byte *dat, byte *tab, byte TABLEN);
void scardcrypt(int algo, byte *key, byte *dat, byte *tab, byte TABLEN);
void scamcrypt(int algo, byte *key, byte *dat, byte *tab, byte TABLEN);
void print(byte *buf, int len)
{
int i;
for (i = 0; i < len; i++) printf("%02X ", buf[i]); printf(" ");
// printf("\n");
}
void cardcrypt(byte *key, byte *dat, byte *tab, byte TABLEN)
{
int i, j, k;
byte index;
for (i = 0; i < KEYLEN * 8; i++)
{
// print(key, KEYLEN); printf("* ");
// print(dat, DATLEN); printf("\n");
dat[(i+1) % DATLEN] += key[i % KEYLEN];
index = dat[i % DATLEN] - key[(i+1) % KEYLEN];
dat[(i+1) % DATLEN] ^= tab[index % TABLEN];
index = (dat[i % DATLEN] ^ key[(i+1) % KEYLEN]) >> 2;
dat[(i+1) % DATLEN] += (tab[index % TABLEN] << 1);
//MSB of IRD[3] came into LSB of IRD[0]
// rotate key[] 1 bit to left
// +------------------+
// +-- 39,38,37,36 <--+
j = key[KEYLEN - 1];
for (k = KEYLEN - 1; k >= 1; k--) key[k] = (key[k] << 1) + (key[k-1] >> 7);
key[0] = (key[0] << 1) + (j >> 7);
}
}
void icamcrypt(byte *key, byte *dat, byte *tab, byte TABLEN)
{
int i, j, k;
byte index;
for (i = (KEYLEN * 8) - 1; i >= 0; i--)
{
// rotate key[] 1 bit to right
// +------------------+
// +--> 39,38,37,36 --+
j = key[0];
for (k = 0; k < KEYLEN - 1; k++) key[k] = (key[k] >> 1) + (key[k+1] << 7);
key[KEYLEN - 1] = (key[KEYLEN - 1] >> 1) + (j << 7);
index = (dat[i % DATLEN] ^ key[(i+1) % KEYLEN]) >> 2;
dat[(i+1) % DATLEN] -= (tab[index % TABLEN] << 1);
index = dat[i % DATLEN] - key[(i+1) % KEYLEN];
dat[(i+1) % DATLEN] ^= tab[index % TABLEN];
dat[(i+1) % DATLEN] -= key[i % KEYLEN];
// print(key, KEYLEN); printf("* ");
// print(dat, DATLEN); printf("\n");
}
}
======================================== ========== ======================================== ========== ====
algorithms
void scardcrypt(int algo, byte *key, byte *dat, byte *tab, byte TABLEN)
{
int h = 62;
int i, j, k, L, m, n, nn, hh;
byte index, x, y, z;
for (j = 0; j < KEYLEN; j++)
{
for (i = 0; i < DATLEN; i++)
{
if (algo == 0) nn = 2;
if (algo == 1) nn = 3;
if (algo == 2) nn = 1;
n = (i + j + nn) % DATLEN;
m = (i + j + 1) % KEYLEN;
index = dat[i] + key[m];
if (algo == 0) index = index >> 1;
x = tab[index % TABLEN];
index = dat[i] ^ x;
y = tab[index % TABLEN];
if (algo == 0) hh = hop0[h % 7];
if (algo == 1) hh = hop1[h % 7];
if (algo == 2) hh = hop2[h % 5];
h++;
z = ((y << hh) | (x >> (8 - hh))) & 0xFF;
if (algo == 0) hh = hop0[h % 7];
if (algo == 1) hh = hop1[h % 7];
if (algo == 2) hh = hop2[h % 5];
h++;
x = ((x << hh) | (y >> (8 - hh))) & 0xFF;
h -= 4;
if (algo == 2) dat[n] ^= (x - z + i) & 0xFF;
else dat[n] ^= (x - z) & 0xFF;
L = key[KEYLEN - 1];
for (k = KEYLEN - 1; k >= 1; k--) key[k] = (key[k] << 3) + (key[k-1] >> 5);
key[0] = (key[0] << 3) + (L >> 5);
}
}//j
}
void scamcrypt(int algo, byte *key, byte *dat, byte *tab, byte TABLEN)
{
int h = 0; //algo_0/1/2, adjusted for algo_1/2
int i, j, k, L, m, n, nn, hh;
byte index, x, y, z;
for (j = 3; j >= 0; j--)
{
for (i = 7; i >= 0; i--)
{
L = key[0];
for (k = 0; k < KEYLEN - 1; k++) key[k] = (key[k] >> 3) + (key[k+1] << 5);
key[KEYLEN - 1] = (key[KEYLEN - 1] >> 3) + (L << 5);
if (algo == 0) nn = 2;
if (algo == 1) nn = 3;
if (algo == 2) nn = 1;
n = (i + j + nn) % DATLEN;
m = (i + j + 1) % KEYLEN;
index = dat[i] + key[m];
if (algo == 0) index = index >> 1;
x = tab[index % TABLEN];
index = dat[i] ^ x;
y = tab[index % TABLEN];
if (algo == 0) hh = hop0[h % 7];
if (algo == 1) hh = hop1[h % 7];
if (algo == 2) hh = hop2[h % 5];
h++;
z = ((y << hh) | (x >> (8 - hh))) & 0xFF;
if (algo == 0) hh = hop0[h % 7];
if (algo == 1) hh = hop1[h % 7];
if (algo == 2) hh = hop2[h % 5];
h++;
x = ((x << hh) | (y >> (8 - hh))) & 0xFF;
if (algo == 2) dat[n] ^= (x - z + i) & 0xFF;
else dat[n] ^= (x - z) & 0xFF;
}
}
}
void main()
{
// int i;
// byte b = tab_HU_2[62];
// for (i = 0; i < 0x40; i++) printf("%02X ", tab_HU_2[i] ^ b);
// return;
// cardcrypt(box_id, cw, tab_HU_0, TABLEN_64);
// printf("\n****************************** ********** ****\n");
// print(box_id, KEYLEN); printf("* ");
// print(cw, DATLEN); printf("\n");
// printf("******************************** ********** **\n\n");
// icamcrypt(box_id, cw, tab_HU_0, TABLEN_64);
int algo = 2; //using algo_0/1/2
scamcrypt(algo, box_id_0, cw_0, tab_0, TABLEN_64);
scamcrypt(algo, box_id_1, cw_1, tab_0, TABLEN_64);
scamcrypt(algo, box_id_0, cw_2, tab_0, TABLEN_64);
scamcrypt(algo, box_id_1, cw_3, tab_0, TABLEN_64);
printf("\n****************************** ********** ****\n");
print(box_id_0, KEYLEN); printf("*0* ");
print(cw_0, DATLEN); printf("\n");
print(box_id_0, KEYLEN); printf("*0* ");
print(cw_2, DATLEN); printf("\n");
print(box_id_1, KEYLEN); printf("*1* ");
print(cw_1, DATLEN); printf("\n");
print(box_id_1, KEYLEN); printf("*1* ");
print(cw_3, DATLEN); printf("\n");
printf("******************************** ********** **\n");
scardcrypt(algo, box_id_0, cw_0, tab_0, TABLEN_64);
scardcrypt(algo, box_id_1, cw_1, tab_0, TABLEN_64);
scardcrypt(algo, box_id_0, cw_2, tab_0, TABLEN_64);
scardcrypt(algo, box_id_1, cw_3, tab_0, TABLEN_64);
printf("\n****************************** ********** ****\n");
print(box_id_0, KEYLEN); printf("*0* ");
print(cw_0, DATLEN); printf("\n");
print(box_id_0, KEYLEN); printf("*0* ");
print(cw_2, DATLEN); printf("\n");
print(box_id_1, KEYLEN); printf("*1* ");
print(cw_1, DATLEN); printf("\n");
print(box_id_1, KEYLEN); printf("*1* ");
print(cw_3, DATLEN); printf("\n");
printf("******************************** ********** **\n");
scamcrypt(algo, box_id_0, cw_0, tab_0, TABLEN_64);
scamcrypt(algo, box_id_1, cw_1, tab_0, TABLEN_64);
scamcrypt(algo, box_id_0, cw_2, tab_0, TABLEN_64);
scamcrypt(algo, box_id_1, cw_3, tab_0, TABLEN_64);
printf("\n****************************** ********** ****\n");
print(box_id_0, KEYLEN); printf("*0* ");
print(cw_0, DATLEN); printf("\n");
print(box_id_0, KEYLEN); printf("*0* ");
print(cw_2, DATLEN); printf("\n");
print(box_id_1, KEYLEN); printf("*1* ");
print(cw_1, DATLEN); printf("\n");
print(box_id_1, KEYLEN); printf("*1* ");
print(cw_3, DATLEN); printf("\n");
printf("******************************** ********** **\n");
scardcrypt(algo, box_id, cw, tab_0, TABLEN_64);
printf("\n****************************** ********** ****\n");
print(box_id, KEYLEN); printf("*0* ");
print(cw, DATLEN); printf("\n");
printf("******************************** ********** **\n");
scamcrypt(algo, box_id, cw, tab_0, TABLEN_64);
printf("\n****************************** ********** ****\n");
print(box_id, KEYLEN); printf("*0* ");
print(cw, DATLEN); printf("\n");
printf("******************************** ********** **\n");
// printf("\n****************************** ********** ****\n");
// print(box_id_0, KEYLEN); printf("*0* ");
// print(cw_0, DATLEN); printf("\n");
// print(box_id_1, KEYLEN); printf("*1* ");
// print(cw_1, DATLEN); printf("\n");
// printf("******************************** ********** **\n");
}
/*
;Wptr is -#9 by routine and -#4 by call
;+++++++++++++++++++++++++++++++++++++++ ++++++
;#0 : x: init with 1, then (-= 3 => -2; +7 => 5); 1 5 2 6 3 0 7 4
;#1 : i: 7..0
;#2 : m = (i+j+1) & 3, then value TAB[x]
;#3 : (CW[i] ^ TAB[x]) & $3F, then TAB[y]
;#4 : IRD_ID copied here
;#5 : TAB[y]
;#6 : n = (i+j+2) & 7
;#7 : j: 3..0
;#8 : PTR to table_?
;#9 : old Iptr
;#A : A = RAM base ?
;#B : B = ??? (encrypted CW)
;#C : C = PTR to IRD_ID
;#D - #0 : RAM start = 13C0
;#E - #1 : table_ID copied here
;#F - #2 : PTR to buffer (encrypted CW copied here)
;+++++++++++++++++++++++++++++++++++++++ ++++++
000E18DD 60B7 sub_000E18DD: ajw -#9
000E18DF 7D ldl #D
000E18E0 53 ldnlp #3 ;13CC
000E18E1 2CFA ls ;B = load sixteen = max LEN = $14
000E18E3 7E ldl #E ;A = table_ID
000E18E4 F9 gt ;A = TRUE if B > A
000E18E5 21AF cj loc_E1906 ;jump if false (only 20 tables)
000E18E7 7E ldl #E ;table_ID
000E18E8 4C ldc #C ;size of each block in dwords
000E18E9 F8 prod ;B: table_ID * 12
000E18EA 7D ldl #D ;RAM start
000E18EB 32 ldnl #2 ;A: PTR to 1000
000E18EC FA wsub ;A=A+B*4
000E18ED 35 ldnl #5 ;PTR to table_?
000E18EE D8 stl #8
000E18EF 7B ldl #B ;copy encrypted CW
000E18F0 7F ldl #F ;to PTR in #F
000E18F1 48 ldc #8
000E18F2 24FA move
000E18F4 7C ldl #C ;copy IRD_ID
000E18F5 14 ldlp #4 ;to #4
000E18F6 44 ldc #4
000E18F7 24FA move
000E18F9 43 ldc #3
000E18FA D7 stl #7 ;j = 3
000E18FB 41 ldc #1
000E18FC D0 stl #0
000E1909 47 loc_E1909: ldc #7
000E190A D1 stl #1 ;i = 7
000E1911 43 loc_E1911: ldc #3 ;C: 3
000E1912 14 ldlp #4 ;B: IRD_ID
000E1913 7A ldl #A ;A: RAM base
000E1914 6C9E call sub_E1854 ;rotate IRD_ID
000E1916 71 ldl #1 ;i
000E1917 77 ldl #7 ;j
000E1918 F2 bsub ;A=A+B
000E1919 82 adc #2
000E191A 47 ldc #7
000E191B 24F6 and
000E191D 2FF8 xsword ;sign extend 16 to 32
000E191F D6 stl #6 ;n = (i+j+2) & 7
000E1920 71 ldl #1 ;i
000E1921 77 ldl #7 ;j
000E1922 F2 bsub ;A=A+B
000E1923 81 adc #1
000E1924 43 ldc #3
000E1925 24F6 and
000E1927 2FF8 xsword
000E1929 25FA dup
000E192B D2 stl #2 ;m = (i+j+1) & 3
000E192C 14 ldlp #4 ;IRD_ID
000E192D F2 bsub
000E192E F1 lb ;IRD[m]
000E192F 71 ldl #1 ;i
000E1930 7F ldl #F ;PTR to CW
000E1931 F2 bsub
000E1932 F1 lb ;CW[i]
000E1933 F2 bsub ;A=A+B IRD[m] + CW[i]
000E1934 42 ldc #2
000E1935 24F6 and ;false if bit 1 is zero
000E1937 21AE cj loc_E1957 ;jump if false
000E1939 72 ldl #2 ;m
000E193A 14 ldlp #4
000E193B F2 bsub
000E193C F1 lb ;IRD[m]
000E193D 71 ldl #1
000E193E 7F ldl #F
000E193F F2 bsub
000E1940 F1 lb ;CW[i]
000E1941 F2 bsub ;A=A+B IRD[m] + CW[i]
000E1942 41 ldc #1
000E1943 24F0 shr ;>> 1
000E1945 234F ldc #3F
000E1947 24F6 and ;& $3F
000E1949 41 ldc #1
000E194A 24F0 shr ;>> 1 (this is nothing)
000E194C 78 ldl #8 ;PTR to table_?
000E194D 2CF1 ssub ;16 subscript
000E194F 2CFA ls ;load 16
000E1951 48 ldc #8
000E1952 24F0 shr ;>>8
000E1954 D2 stl #2 ;MSB
000E1955 2109 j loc_E1970
000E1957 72 loc_E1957: ldl #2 ;m
000E1958 14 ldlp #4
000E1959 F2 bsub
000E195A F1 lb ;IRD[m]
000E195B 71 ldl #1
000E195C 7F ldl #F
000E195D F2 bsub
000E195E F1 lb ;CW[i]
000E195F F2 bsub ;A=A+B IRD[m] + CW[i]
000E1960 41 ldc #1
000E1961 24F0 shr ;>> 1
000E1963 234F ldc #3F
000E1965 24F6 and ;& $3F
000E1967 41 ldc #1
000E1968 24F0 shr ;>> 1 (this is nothing)
000E196A 78 ldl #8 ;PTR to table_?
000E196B 2CF1 ssub ;16 subscript
000E196D 2CFA ls ;load 16
000E196F D2 stl #2 ;LSB
000E1970 72 loc_E1970: ldl #2 ;TAB[x]
000E1971 2F4F ldc #FF
000E1973 24F6 and
000E1975 D2 stl #2
000E1976 71 ldl #1 ;i
000E1977 7F ldl #F ;PTR to CW
000E1978 F2 bsub
000E1979 F1 lb ;CW[i]
000E197A 72 ldl #2
000E197B 23F3 xor ;^ TAB[x]
000E197D 234F ldc #3F
000E197F 24F6 and ;& $3F
000E1981 25FA dup
000E1983 D3 stl #3 ;(CW[i] ^ TAB[x]) & $3F
000E1984 41 ldc #1 ;bit 0
000E1985 24F6 and
000E1987 AF cj loc_E1997 ;jump if bit 0 is zero
000E1988 73 ldl #3 ;(CW[i] ^ TAB[x]) & $3F
000E1989 41 ldc #1 ;(this is nothing)
000E198A 24F0 shr
000E198C 78 ldl #8 ;PTR to table_?
000E198D 2CF1 ssub
000E198F 2CFA ls
000E1991 48 ldc #8
000E1992 24F0 shr
000E1994 D3 stl #3 ;MSB
000E1995 0B j loc_E19A1
000E1997 73 loc_E1997: ldl #3
000E1998 41 ldc #1
000E1999 24F0 shr ;(this is nothing)
000E199B 78 ldl #8 ;PTR to table_?
000E199C 2CF1 ssub
000E199E 2CFA ls
000E19A0 D3 stl #3 ;LSB
000E19A1 73 loc_E19A1: ldl #3 ;TAB[y]
000E19A2 2F4F ldc #FF
000E19A4 24F6 and
000E19A6 25FA dup
000E19A8 D5 stl #5 ;store here
000E19A9 70 ldl #0 ;was init with 1
000E19AA 81 adc #1 ;+1
000E19AB 24F1 shl ;TAB[y] << 2
000E19AD 47 ldc #7
000E19AE 70 ldl #0 ;still 1
000E19AF F4 diff ;A=7-A => 6
000E19B0 72 ldl #2 ;TAB[x]
000E19B1 F0 rev ;swap A <-> B
000E19B2 24F0 shr ;TAB[x] >> 6
000E19B4 24FB or ;+
000E19B6 2F4F ldc #FF
000E19B8 24F6 and ;& $FF
000E19BA D3 stl #3 ;store back modified TAB[y]
000E19BB 70 ldl #0 ;x still 1
000E19BC 608D adc -#3 ;adjust x
000E19BE 2FF8 xsword
000E19C0 D0 stl #0 ;store back
000E19C1 40 ldc #0
000E19C2 70 ldl #0
000E19C3 F9 gt ;A = TRUE if 0 > -2
000E19C4 A6 cj loc_E19CB ;jump if false
000E19C6 70 ldl #0
000E19C7 87 adc #7 ;-2 + 7 = 5
000E19C8 2FF8 xsword
000E19CA D0 stl #0 ;must be +
000E19CB 72 loc_E19CB: ldl #2 ;TAB[x]
000E19CC 70 ldl #0 ;x = 1 5 2 6 3 0 7 4
000E19CD 81 adc #1
000E19CE 24F1 shl ;TAB[x] << x+1
000E19D0 47 ldc #7
000E19D1 70 ldl #0
000E19D2 F4 diff ;A=7-A => 0..7
000E19D3 75 ldl #5 ;TAB[y]
000E19D4 F0 rev
000E19D5 24F0 shr ;TAB[y] >> 7-x
000E19D7 24FB or ;+1
000E19D9 2F4F ldc #FF
000E19DB 24F6 and ;& $FF
000E19DD D2 stl #2 ;store back modified TAB[x]
000E19DE 70 ldl #0
000E19DF 608D adc -#3 ;adjust x again
000E19E1 2FF8 xsword
000E19E3 D0 stl #0
000E19E4 40 ldc #0
000E19E5 70 ldl #0
000E19E6 F9 gt
000E19E7 A6 cj loc_E19EE
000E19E9 70 ldl #0
000E19EA 87 adc #7
000E19EB 2FF8 xsword
000E19ED D0 stl #0
000E19EE 72 loc_E19EE: ldl #2 ;modified TAB[x]
000E19EF 73 ldl #3 ;modified TAB[y]
000E19F0 F4 diff ;A=B-A
000E19F1 76 ldl #6 ;n
000E19F2 7F ldl #F ;PTR to CW
000E19F3 F2 bsub
000E19F4 F1 lb ;CW[n]
000E19F5 23F3 xor ;(TAB[x]-TAB[y]) ^ CW[n]
000E19F7 76 ldl #6
000E19F8 7F ldl #F
000E19F9 F2 bsub
000E19FA 23FB sb ;store back CW[n]
000E19FC 71 ldl #1
000E19FD 608F adc -#1 ;i--
000E19FF 25FA dup
000E1A01 D1 stl #1
000E1A02 604F ldc -#1
000E1A04 F9 gt
000E1A05 A3 cj loc_E1A09
000E1A07 6F08 j loc_E1911 ;inner loop
000E1A09 77 loc_E1A09: ldl #7
000E1A0A 608F adc -#1 ;j--
000E1A0C 25FA dup
000E1A0E D7 stl #7
000E1A0F 604F ldc -#1
000E1A11 F9 gt
000E1A12 A4 cj loc_E1A17
000E1A14 612F02 j loc_E1909 ;outer loop
000E1A17 B9 loc_E1A17: ajw #9
000E1A18 22F0 ret
*/
/*
v4 = 0x0001;
v6 = 1; //len offset 1 or 2
vv1 = 0x0000;
TAB95[0] = 0;
k = 0; //#5 //LSB or MSB ?
while (k != v6) // do 1 or 2 times
{
temp = 0; //#0 //previous MSB
v3 = OFSVAL[k]
j = 0;
i = k;
temp = (TAB95[j] * v3 + temp + TAB101[i]) & 0xFFFF;
TAB101[i] = (temp & 0xFF); //LSB
temp = (temp >> 8) & 0xFF; //MSB
j++;
i++;
while (temp != 0)
{
temp = (TAB101[i] + temp);
TAB101[i] = (temp & 0xFF); //LSB
temp = (temp >> 8) & 0xFF; //MSB
i++;
}
k++;
}
store i to val##1;
//questions left over:
//- why is j not used
//- TAB95[0] is 1, so why mul ?
//this routine adds offs val depending on 96 bits if set
*/
/*
byte mm = 0x17;
IRD[0] = box_id_1[0];
IRD[1] = box_id_1[1];
IRD[2] = box_id_1[2];
IRD[3] = box_id_1[3];
//80 00 00 07 03 06 11 09
//80 00 01 07 03 06 50 09
kk[0] = IRD[3] & 0x01;
kk[0] |= IRD[0] & 0x80;
if ((IRD[1] && 0x20) != 0) kk[0] |= 0x80;
if ((IRD[1] && 0x80) != 0) kk[0] |= 0x80;
if ((IRD[1] && 0x02) != 0) kk[0] |= 0x80;
if ((IRD[1] && 0x04) != 0) kk[0] |= 0x80;
kk[1] = 0;
kk[3] = 0; //wasn't init
if (IRD[3] && 0x10 != 0) kk[3] |= 0x07; else kk[3] |= 0x01;
kk[2] = (IRD[3] & 0x02) >> 1;
kk[4] = 3;
kk[5] = 0;
if ((IRD[2] && 0x40) != 0) kk[5] |= 0x02;
if ((IRD[2] && 0x20) != 0) kk[5] |= 0x04;
kk[6] = 0;
kk[6] |= IRD[1] & 0x01;
if ((IRD[1] && 0x08) != 0) kk[6] |= 0x10;
kk[6] |= IRD[1] & 0x40;
kk[7] = 0;
if ((IRD[1] && 0x10) != 0) kk[7] |= 0x01;
if ((IRD[2] && 0x80) != 0)
{
if (mm == 0x17) kk[7] |= 0x08; else kk[7] |= 0x20;
}
print(kk, DATLEN); printf("\n");
return;
*/
Urgent: NDS system was piracy and Here's your version Khurzmih
Reply With Quote
Originally Posted by zoltar25
I have an expired card!
Re: Urgent: NDS system was piracy and Here's your version Khurzmih
