I think that the problem seems to be in the order of operations you're performing.
In your comment, you state that a successful operation transforms:
0xC1 0x06 0xA9 0x20 0x9C 0x2F
into
0x81 0x6F 0x4E 0x07 0xB8 0x89
In order to make this transformation, I needed to DECRYPT using the client_keys - whereas your question had given me the impression that the first 6 byes were the original, unmodified data to be transmitted.
It then follows that the opposite of DECRYPT using client_keys would be to ENCRYPT using server_keys, so I tried that. Guess what? The data's gone 'full-circle' and is transformed back into the original sequence,
0xC1 0x06 0xA9 0x20 0x9C 0x2F
I tried all of the 4 combinations with an input of
0xC1 0x06 0xA9 0x20 0x9C 0x2F
Method Output
---------------------------------------------
ENCRYPT client: 0x89 0x68 0x97 0x62 0x29 0x8B
ENCRYPT server: 0x67 0x51 0xB9 0xA5 0x31 0xAC
DECRYPT client: 0x81 0x6F 0x4E 0x07 0xB8 0x89 <--- Here's the expected output.
DECRYPT server: 0x1B 0x98 0x49 0xD1 0xC9 0xAE
The only one that makes the successful transformation that you mention, was DECRYPT client. This lends yet more weight to my belief that you've become confused somehow and applied the wrong transformations at the wrong times.
Anyway, here's a short (as can be!) snippet that changes the data and then changes it back again. Hope it helps. :)
#include <cstdio>
typedef unsigned char BYTE;
BYTE server_keys[2][256] = {
{
0xFC, 0x77, 0xA1, 0x85, 0x1F, 0x30, 0x51, 0x20, 0x93, 0x4A, 0xE3, 0x10, 0x0E, 0x32, 0x58,
0x64, 0x36, 0x8C, 0x19, 0xF0, 0x61, 0xE0, 0xDF, 0x9E, 0x9F, 0x90, 0xD0, 0x05, 0xFA, 0xEB,
0x3D, 0x4B, 0xA5, 0xF1, 0x72, 0x73, 0xD4, 0xB5, 0x70, 0xD7, 0xCD, 0x9A, 0x95, 0x2B, 0xC9,
0x00, 0x8E, 0xAC, 0x35, 0x1B, 0xE7, 0x7B, 0xC3, 0x15, 0x11, 0xF6, 0xAD, 0x5B, 0x87, 0x86,
0xB4, 0x9B, 0x26, 0xDB, 0xDE, 0x1C, 0x66, 0x24, 0xD8, 0x27, 0x6A, 0xBD, 0x5D, 0x8D, 0x7D,
0x0D, 0xAE, 0x8B, 0xA9, 0x62, 0x6B, 0x0B, 0xE2, 0x5C, 0x6C, 0xBE, 0x54, 0x55, 0x6E, 0xBF,
0x3F, 0x88, 0x99, 0xB0, 0x48, 0x16, 0x5A, 0x34, 0xA6, 0xE8, 0xFD, 0xD3, 0xE4, 0x82, 0xD6,
0x8A, 0x3B, 0xFE, 0xA4, 0x94, 0xF8, 0x06, 0x97, 0xCB, 0xF5, 0x33, 0x79, 0xD9, 0x83, 0x4F,
0xB1, 0xAB, 0xA2, 0x69, 0x91, 0xFF, 0xC6, 0x2C, 0x68, 0xC1, 0xAA, 0xC4, 0x1D, 0x18, 0x3A,
0xBC, 0x04, 0x2F, 0xA3, 0xFB, 0x17, 0x89, 0x25, 0x02, 0xCF, 0xDD, 0x2D, 0x6D, 0xC5, 0xC2,
0x46, 0x01, 0xE5, 0xED, 0x2E, 0xDA, 0x31, 0x37, 0x40, 0xC8, 0xB6, 0xE9, 0x7C, 0x45, 0xF3,
0x47, 0x22, 0xF9, 0x63, 0xB9, 0x13, 0x38, 0x78, 0x2A, 0xC0, 0xEC, 0xEF, 0x28, 0x12, 0x6F,
0x75, 0xEA, 0x29, 0x84, 0x9C, 0x44, 0x96, 0x0A, 0x59, 0x76, 0x92, 0x41, 0xF2, 0x67, 0x08,
0xB8, 0x43, 0xCA, 0x1E, 0xE1, 0x52, 0x3C, 0x42, 0xEE, 0xA8, 0x5F, 0x23, 0x1A, 0xD5, 0x7F,
0xC7, 0x5E, 0x50, 0x81, 0xF7, 0x7A, 0x65, 0x09, 0xCC, 0x60, 0x0F, 0x9D, 0x53, 0x80, 0xA0,
0x98, 0xB3, 0xA7, 0x49, 0x57, 0x7E, 0x3E, 0x03, 0xDC, 0x39, 0xBB, 0x8F, 0xCE, 0x4E, 0xF4,
0xE6, 0xB2, 0x74, 0x21, 0x0C, 0x71, 0x07, 0xB7, 0xAF, 0x56, 0x14, 0x4D, 0xD2, 0x4C, 0xD1,
0xBA
},
{
0xEC, 0x48, 0x4E, 0x18, 0x93, 0x4C, 0x98, 0x7F, 0xDA, 0x43, 0x89, 0x6A, 0x1E, 0xAA, 0xF9,
0x65, 0x07, 0x22, 0xD8, 0x52, 0x01, 0xCA, 0x61, 0x7A, 0x85, 0x91, 0x54, 0x08, 0xE6, 0x8D,
0x41, 0xDD, 0xD1, 0xC8, 0x72, 0x31, 0x94, 0xFB, 0xC7, 0x4F, 0xE7, 0x9C, 0x3E, 0x46, 0xD5,
0xE4, 0x76, 0xAE, 0xAB, 0x77, 0xBF, 0x11, 0x09, 0x51, 0xD7, 0x55, 0x39, 0x45, 0xA4, 0xFE,
0xBA, 0x9A, 0x6E, 0xB8, 0x2C, 0x57, 0x32, 0x2A, 0x5F, 0x50, 0xD4, 0x5B, 0xB3, 0x3A, 0xA6,
0x9B, 0x3C, 0x14, 0xDC, 0x1D, 0xFC, 0x27, 0x6C, 0x86, 0x17, 0x5A, 0x5C, 0xDB, 0x78, 0x75,
0x70, 0xF7, 0x3D, 0x8E, 0xE1, 0x05, 0x0D, 0xF3, 0x20, 0x6F, 0x8C, 0x36, 0x7C, 0x69, 0x06,
0xA3, 0x7D, 0xCF, 0xE3, 0x3B, 0x67, 0x40, 0xF8, 0xFA, 0xA2, 0x0C, 0xB6, 0xAD, 0xC6, 0xA0,
0xBE, 0xA1, 0x37, 0xB0, 0xB2, 0x12, 0x9E, 0x23, 0xD9, 0xD0, 0xCD, 0x4B, 0x84, 0x1C, 0xD6,
0xED, 0xE8, 0xC1, 0x3F, 0x2F, 0xB5, 0x38, 0x8A, 0x71, 0xF2, 0x28, 0xC3, 0xD2, 0x6D, 0xB9,
0x30, 0xA9, 0x73, 0xA5, 0x02, 0x5D, 0xC9, 0x10, 0x62, 0xFD, 0x47, 0xAF, 0x81, 0x2B, 0x9D,
0xC0, 0x90, 0x99, 0x74, 0x49, 0x44, 0xB4, 0x8F, 0x92, 0x0E, 0xB1, 0xE0, 0x0B, 0x0A, 0x7E,
0x95, 0x96, 0x34, 0x68, 0x53, 0xCB, 0xEF, 0xCC, 0x2D, 0x56, 0xEE, 0xF0, 0x24, 0x1B, 0xF5,
0x66, 0xD3, 0x03, 0x00, 0x15, 0x4A, 0xE2, 0xA7, 0x58, 0x1A, 0xE5, 0x29, 0x63, 0x25, 0xB7,
0xCE, 0xBB, 0xF4, 0x7B, 0x4D, 0xBD, 0x35, 0x79, 0x0F, 0x80, 0x26, 0xE9, 0xAC, 0xEB, 0x97,
0x16, 0x82, 0xA8, 0xBC, 0x13, 0x21, 0x19, 0x1F, 0x2E, 0xC2, 0x87, 0x88, 0x9F, 0x83, 0xEA,
0x59, 0x42, 0xC5, 0x04, 0x5E, 0x60, 0xF6, 0x33, 0xC4, 0xF1, 0x6B, 0x64, 0xDE, 0x8B, 0xDF,
0xFF
}
};
BYTE client_keys[2][256] = {
{
0xC6, 0x14, 0x9A, 0xC5, 0xF3, 0x5F, 0x68, 0x10, 0x1B, 0x34, 0xB2, 0xB1, 0x73, 0x60, 0xAE,
0xDA, 0x9D, 0x33, 0x7D, 0xE5, 0x4D, 0xC7, 0xE1, 0x54, 0x03, 0xE7, 0xCC, 0xC1, 0x85, 0x4F,
0x0C, 0xE8, 0x62, 0xE6, 0x11, 0x7F, 0xC0, 0xD0, 0xDC, 0x51, 0x91, 0xCE, 0x43, 0xA3, 0x40,
0xBC, 0xE9, 0x8B, 0x96, 0x23, 0x42, 0xF7, 0xB6, 0xD8, 0x65, 0x7A, 0x8D, 0x38, 0x49, 0x6D,
0x4C, 0x5C, 0x2A, 0x8A, 0x6F, 0x1E, 0xF1, 0x09, 0xAA, 0x39, 0x2B, 0xA0, 0x01, 0xA9, 0xC8,
0x83, 0x05, 0xD6, 0x02, 0x27, 0x45, 0x35, 0x13, 0xB8, 0x1A, 0x37, 0xBD, 0x41, 0xCB, 0xF0,
0x55, 0x47, 0x56, 0x9B, 0xF4, 0x44, 0xF5, 0x16, 0x9E, 0xCF, 0xFB, 0x0F, 0xC3, 0x6E, 0xB7,
0x67, 0x0B, 0xFA, 0x52, 0x94, 0x3E, 0x63, 0x5A, 0x8F, 0x22, 0x98, 0xA8, 0x59, 0x2E, 0x31,
0x58, 0xD9, 0x17, 0xD5, 0x66, 0x6A, 0xB3, 0x07, 0xDB, 0xA2, 0xE2, 0xEE, 0x84, 0x18, 0x53,
0xEB, 0xEC, 0x0A, 0x8E, 0xFD, 0x64, 0x1D, 0x5D, 0xAC, 0xA6, 0x19, 0xAD, 0x04, 0x24, 0xB4,
0xB5, 0xE0, 0x06, 0xA7, 0x3D, 0x4B, 0x29, 0xA4, 0x7E, 0xED, 0x77, 0x79, 0x72, 0x69, 0x3A,
0x99, 0x4A, 0xCA, 0xE3, 0x97, 0x0D, 0x30, 0xDE, 0x75, 0x2F, 0xA1, 0x7B, 0xAF, 0x7C, 0x48,
0xAB, 0x8C, 0x74, 0xD1, 0x3F, 0x95, 0x3C, 0xD3, 0xE4, 0xD7, 0x78, 0x32, 0xA5, 0x89, 0xEA,
0x92, 0xF8, 0xF2, 0x76, 0x26, 0x21, 0x9C, 0x15, 0xB9, 0xBB, 0x82, 0xD2, 0x6B, 0x81, 0x20,
0x93, 0xC4, 0x46, 0x2C, 0x86, 0x36, 0x12, 0x80, 0x08, 0x57, 0x4E, 0x1F, 0xFC, 0xFE, 0xB0,
0x5E, 0xC9, 0x6C, 0x2D, 0xCD, 0x1C, 0x28, 0x88, 0xDD, 0xEF, 0xDF, 0x00, 0x87, 0xBE, 0xBA,
0xBF, 0xF9, 0x90, 0x61, 0xD4, 0xC2, 0xF6, 0x5B, 0x70, 0x0E, 0x71, 0x25, 0x50, 0x9F, 0x3B,
0xFF
},
{
0x2D, 0x97, 0x8F, 0xE8, 0x88, 0x1B, 0x6F, 0xF6, 0xC2, 0xD9, 0xBB, 0x51, 0xF4, 0x4B, 0x0C,
0xDC, 0x0B, 0x36, 0xB2, 0xAA, 0xFA, 0x35, 0x5F, 0x8C, 0x85, 0x12, 0xCF, 0x31, 0x41, 0x84,
0xC6, 0x04, 0x07, 0xF3, 0xA6, 0xCE, 0x43, 0x8E, 0x3E, 0x45, 0xB1, 0xB6, 0xAD, 0x2B, 0x7F,
0x92, 0x9A, 0x89, 0x05, 0x9C, 0x0D, 0x73, 0x61, 0x30, 0x10, 0x9D, 0xAB, 0xEA, 0x86, 0x6A,
0xC9, 0x1E, 0xE7, 0x5A, 0x9E, 0xBF, 0xCA, 0xC4, 0xB9, 0xA3, 0x96, 0xA5, 0x5E, 0xE4, 0x09,
0x1F, 0xFD, 0xFB, 0xEE, 0x77, 0xD4, 0x06, 0xC8, 0xDE, 0x56, 0x57, 0xF9, 0xE5, 0x0E, 0xBC,
0x60, 0x39, 0x53, 0x48, 0xD3, 0xCD, 0xDB, 0x14, 0x4F, 0xA8, 0x0F, 0xD8, 0x42, 0xC1, 0x80,
0x7B, 0x46, 0x50, 0x54, 0x93, 0x58, 0xB3, 0x26, 0xF5, 0x22, 0x23, 0xF2, 0xB4, 0xBD, 0x01,
0xAC, 0x74, 0xD7, 0x33, 0xA2, 0x4A, 0xE6, 0xD1, 0xDF, 0xD5, 0x67, 0x76, 0xB7, 0x03, 0x3B,
0x3A, 0x5B, 0x8D, 0x69, 0x4D, 0x11, 0x49, 0x2E, 0xEC, 0x19, 0x7C, 0xBE, 0x08, 0x6D, 0x2A,
0xBA, 0x70, 0xE1, 0x5C, 0x29, 0x3D, 0xB8, 0xDD, 0x17, 0x18, 0xE0, 0x02, 0x7A, 0x8A, 0x6C,
0x20, 0x62, 0xE3, 0xCC, 0x4E, 0x82, 0x79, 0x2F, 0x38, 0x4C, 0xF8, 0x5D, 0x78, 0xF1, 0xE2,
0x3C, 0x25, 0xA0, 0xF7, 0xC3, 0xA9, 0xFF, 0xEB, 0x87, 0x47, 0x55, 0x59, 0xAE, 0x81, 0x95,
0x34, 0x83, 0x94, 0x7E, 0xD2, 0x9F, 0x2C, 0xC5, 0x71, 0xDA, 0x28, 0xED, 0x90, 0x1A, 0xFE,
0xFC, 0x65, 0x24, 0xD0, 0x68, 0x27, 0x44, 0x75, 0x9B, 0x3F, 0xE9, 0x91, 0x40, 0x16, 0x15,
0xC7, 0x52, 0x0A, 0x66, 0x98, 0xF0, 0x32, 0x63, 0xA1, 0xB5, 0x1D, 0xAF, 0x99, 0xCB, 0xB0,
0x13, 0x21, 0xC0, 0xA4, 0xEF, 0x72, 0x37, 0xD6, 0x6E, 0xA7, 0x1C, 0x8B, 0x00, 0x64, 0x6B,
0x7D
}
};
typedef enum PROCESS_TYPE
{
ENCRYPT = 0,
DECRYPT = 1
};
const int KEYS_NUMBER = 256;
inline void process_data(const PROCESS_TYPE type, const BYTE(*keys)[KEYS_NUMBER], BYTE *pInData, BYTE *pOutData, const unsigned int uLen)
{
for (unsigned int i = 0; i < uLen; ++i)
{
pOutData[i] = keys[type][ pInData[i] ];
}
}
void printData(BYTE *data, int len)
{
for (int i=0; i<len; i++)
printf("0x%02X ", data[i]);
printf("\n");
}
int main(int argc, char **argv)
{
const int dataLen = 6;
BYTE inputData[dataLen] = {0xC1, 0x06, 0xA9, 0x20, 0x9C, 0x2F};
BYTE outputData[dataLen] = {};
printf("Orig input data:\n");
printData(inputData, dataLen);
printf("\n");
process_data(DECRYPT, client_keys, inputData, outputData, dataLen);
printf("Data after DECRYPTING using client_keys:\n");
printData(outputData, dataLen);
printf("\n");
printf("----------------------------------------\n");
process_data(ENCRYPT, server_keys, outputData,outputData, dataLen);
printf("Data after ENCRYPTING using server_keys:\n");
printData(outputData, dataLen);
printf("\n");
}
Output
Orig input data:
0xC1 0x06 0xA9 0x20 0x9C 0x2F
Data after DECRYPTING using client_keys:
0x81 0x6F 0x4E 0x07 0xB8 0x89
----------------------------------------
Data after ENCRYPTING using server_keys:
0xC1 0x06 0xA9 0x20 0x9C 0x2F