Verify RSA signature in c++ using openssl - c++

I have a public key and a signature of some message, in the form of a byte array.
I'm trying to verify the signature using the public key.
That's what I tried:
int test2()
{
const unsigned char *MESSAGE = (unsigned char *) "My message";
const int MESSAGE_LEN = 10;
unsigned char pubKey[] = {0x2D, 0x7E, 0xDC, 0xFE, 0x5B, 0x17, 0xE4, 0x30, 0x64, 0x09, 0x75,
0xCA, 0xBB, 0x6C, 0x8D, 0xAE, 0x93, 0xB3, 0x0F, 0xA0, 0x0F, 0x59,
0xE2, 0xA5, 0x2F, 0x66, 0x45, 0x3D, 0x89, 0x6D, 0x66, 0x60, 0x60,
0x5B, 0x83, 0xC2, 0xA7, 0xC8, 0x01, 0x52, 0x2D, 0xA9, 0x62, 0xC2,
0x1C, 0xED, 0x85, 0x98, 0xD1, 0xC2, 0x84, 0x01, 0xF4, 0x45, 0xFA,
0x2C, 0x78, 0x05, 0x99, 0x1F, 0xCF, 0x96, 0xDA, 0xC5, 0xC0, 0x46,
0x26, 0xF8, 0x0D, 0x31, 0x01, 0x42, 0x77, 0x46, 0x9C, 0x5B, 0xC5,
0x9D, 0x0D, 0x68, 0xBA, 0x1F, 0x11, 0x89, 0xCC, 0xC3, 0x75, 0xC6,
0x17, 0x4B, 0xFD, 0x1E, 0x1A, 0x19, 0x32, 0x23, 0x2F, 0x9D, 0xAB,
0x51, 0xFB, 0x5A, 0xD3, 0xC7, 0xCE, 0xB0, 0xDE, 0x07, 0x01, 0xB1,
0xB7, 0x90, 0x28, 0x36, 0x9F, 0x15, 0xEB, 0x07, 0x6E, 0x6F, 0x5A,
0x1B, 0x9E, 0x22, 0xC4, 0x02, 0x8F, 0x90, 0x47, 0xEE, 0x78, 0xF4,
0xE8, 0x1D, 0x63, 0xD7, 0x56, 0x2C, 0x13, 0x71, 0xCD, 0xCD, 0x84,
0x50, 0x1D, 0x1C, 0x36, 0x56, 0xD5, 0xDE, 0x20, 0x3A, 0xB5, 0xE8,
0x1B, 0x9A, 0x89, 0xDE, 0x51, 0xAB, 0x1A, 0x0C, 0x51, 0x08, 0xD2,
0x22, 0xB0, 0x74, 0x6D, 0xA3, 0x84, 0x11, 0xF5, 0x91, 0x27, 0xAB,
0x05, 0xB4, 0x01, 0x14, 0xBF, 0xB4, 0x03, 0xD2, 0x38, 0x89, 0xDA,
0xA6, 0x16, 0xBF, 0xB4, 0x0B, 0xD2, 0x7A, 0xFF, 0xB0, 0x0F, 0x42,
0x8A, 0x0A, 0x32, 0xD4, 0x28, 0x77, 0x54, 0xA0, 0xA0, 0xFB, 0x96,
0xB1, 0x69, 0x08, 0x43, 0xB0, 0x25, 0x47, 0x01, 0x58, 0xA0, 0xBE,
0xB3, 0xDF, 0xC4, 0x51, 0xE2, 0x62, 0x2D, 0x95, 0xB3, 0x8D, 0x80,
0x5C, 0x4E, 0x24, 0xC3, 0x2F, 0x9F, 0x6D, 0x7A, 0x02, 0xB7, 0xD9,
0x7F, 0xEE, 0xF1, 0x1C, 0xAF, 0x51, 0xBE, 0x45, 0x5E, 0x85, 0x2E,
0x05, 0x74, 0xB9};
unsigned char exp[] = {0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned char signature[] = {0x1A, 0x84, 0x32, 0x9F, 0x73, 0x3F, 0x46, 0xDF, 0x63, 0x41, 0xB4,
0xDC, 0xC5, 0x7B, 0x5B, 0x9E, 0xA8, 0x98, 0xFD, 0xE5, 0x65, 0x96,
0xD5, 0xF4, 0xEC, 0xFB, 0x19, 0x76, 0x0F, 0x7E, 0x23, 0xAA, 0xB8,
0x54, 0x87, 0x08, 0x94, 0xAB, 0x8E, 0x00, 0x76, 0x99, 0xB9, 0x17,
0xFE, 0x35, 0x39, 0xD4, 0x10, 0x95, 0x82, 0xB4, 0x7E, 0x7C, 0xC3,
0x17, 0xCD, 0x51, 0x89, 0x2D, 0xCC, 0x71, 0xEC, 0xA2, 0x0E, 0x33,
0xFA, 0xB9, 0x77, 0x3D, 0xD5, 0xD5, 0xE7, 0x6C, 0x6C, 0x64, 0xDE,
0xEA, 0x10, 0x6A, 0xC9, 0x5E, 0x82, 0x4D, 0x00, 0xF6, 0x55, 0x45,
0x37, 0xEC, 0xF1, 0x61, 0xD4, 0x68, 0x65, 0x42, 0xAE, 0xF3, 0xC6,
0x51, 0xBC, 0xF3, 0x27, 0x1F, 0x02, 0x45, 0x05, 0x20, 0xD5, 0x0B,
0x2B, 0x82, 0x39, 0x49, 0x29, 0x1E, 0x7E, 0xC0, 0xB5, 0xE3, 0xB2,
0x46, 0xCF, 0x20, 0xAE, 0x9C, 0xE9, 0x51, 0x29, 0xAA, 0x4F, 0xB0,
0xAD, 0xBF, 0x8C, 0x45, 0x70, 0xB1, 0x66, 0xA5, 0xAE, 0x56, 0x9E,
0xA6, 0x9E, 0x57, 0x21, 0x92, 0xEE, 0xFB, 0x59, 0xA3, 0x6D, 0x61,
0x3A, 0xC8, 0xCA, 0xFD, 0x53, 0xA8, 0xFB, 0x54, 0x12, 0x5F, 0x28,
0x3E, 0x6D, 0x01, 0x3F, 0x19, 0xD9, 0x2B, 0x1E, 0xC2, 0x30, 0xF2,
0x0E, 0xA5, 0x87, 0xEC, 0x12, 0x5A, 0x7E, 0x96, 0xDF, 0x75, 0xA9,
0x92, 0xDF, 0x65, 0x96, 0x45, 0xFA, 0xDF, 0xDF, 0x8C, 0x53, 0xF4,
0x08, 0xAB, 0x5C, 0x01, 0xA0, 0xB1, 0x4C, 0x10, 0xEB, 0xA9, 0x4C,
0x91, 0x52, 0x3A, 0x4B, 0x84, 0x8A, 0x55, 0x5E, 0x85, 0x1A, 0x8E,
0x70, 0x77, 0x3B, 0x25, 0x2D, 0x63, 0x4E, 0xE4, 0x19, 0xCF, 0x76,
0x07, 0xDE, 0xC4, 0x7B, 0x77, 0x41, 0x3F, 0x46, 0x5E, 0x4F, 0xC9,
0xEE, 0x57, 0xB6, 0x65, 0xFD, 0xFF, 0xD4, 0xC7, 0x0A, 0x10, 0x26,
0xA7, 0x3F, 0xF0};
RSA *rsa = RSA_new();
rsa->n = BN_bin2bn(pubKey, 256, NULL);
rsa->e = BN_bin2bn(exp, 8, NULL);
int errCode = RSA_verify(RSA_PKCS1_PADDING, MESSAGE, MESSAGE_LEN, signature, 256, rsa);
if (errCode == 1)
{
std::cout << "Message signature was verified successfully" << std::endl;
}
else
{
std::cout << "Message signature is incorrect" << std::endl;
}
return 0;
}
That is the right signature for the message, but I keep getting a wrong signature result. What am I doing wrong?


Thanks to jww's comment about the exponent being 72058693549555712, I realized I provided the numbers in little-endian form, where the BN_bin2bn function expect a buffer in big-endian form. I managed to find here a function called BN_bin2lbn that should be perfect for that case, as it expects a buffer in little-endian form. Unfortunately this function doesn't seem to exist in the bn.h file on my computer (which is where BN_bin2bn is declared).
Eventually I managed to overcome this by turning my numbers into big-endian form, using:
std::reverse(pubKey, pubKey + 256);
std::reverse(exp, exp + 8);
Now everything works fine.

Related

CryptDecrypt fails with ERROR_INVALID_PARAMETER when called for openssl encrypted data

I'm trying to use encryption/decryption functions available in Windows.
I generated RSA key pair in PuTTYgen, extracted private and public keys to separate pem files. Then I use OpenSSL to test those keys by encrypting and then decrypting some message.
openssl.exe rsautl -in input.txt -out encrypted.bin -inkey public_key_4096_puttygen.pem -encrypt -oaep -pubin
openssl.exe rsautl -in encrypted.bin -out decrypted.txt -inkey private_key_4096_puttygen.pem -decrypt -oaep
At this step everything is fine.
Then I take the private key data into sample C++ program written in Visual Studio C++. I call the following functions: CryptAcquireContext, CryptImportKey, CryptEncrypt and CryptDecrypt to test encryption/decryption chain. And also there is everything allright.
Finally I wand to encrypt some data by openssl command and try to decrypt it in C++ program with above functions. And CryptDecrypt returns FALSE (GetLastError returns ERROR_INVALID_PARAMETER).
Here is the program code:
#include "windows.h"
#include "stdio.h"
#define KEY_BUFFER_LENGTH (8 * 1024)
void main()
{
LPCSTR encryptedBase64 = "EyKgay5XppNIX0vVEUuOJ11TYTn5vMHBu1gQJObjWzc7kVCi6dgvmI/r10NeRwQWDDp8m2NluC77ndbZT2CeCMnc9GXG7OwXVLasz8AC1pwC6ZVSsKshp1927mpOn0ZyJK3Ry4hV/jWvBOspDAT1f0ovRqB0Zl2dvN1jwrPjJK4xgREWq9JR8ElEptVd3kRZWkUOrpw0QpCVFmK8mJOlP7ayR2gRhDbQNdbgo12QN0Hsurqjyu8zEb4rEPrw8Ywj3apKytNOFSiQSlXmtCQC+T7vVSQVaVddgLWvXCQFA8tFGyWq+8f4dEl6qfn0/E4RKbJlSs7G2pqTgSnlZVf7NcctJrQP5AUz0bihxEb0+H4TYojYenb98fdu6/QEjHiQH2VzD07VwIyOIGZiL9NhtDc1EOyvtXuGF5t4Zw6wLgeuYvT9HWLYO6dh8zIu2032vKJ+EIkKd4wTotdZlqIWfDRjyKJUIYVwOl4dHXPO2cdCburmzsVooat0LttJjBjJmhxk1D25RjdOgJl6dhq3N/zmcSO0eoCnXZGbGUOAcsVJATo6u7Oo0KCHPsbEkk2iw/WjAT1H1fFJ2XZcLGxfKHYNEtRg25dtbnKPzscxY02AhwEv4v0o/9dEoasxrdJEIh5mpKRJK4xY7E4iAyLIKJ17c6wJ3zu3wfSeJlM1auY=";
HCRYPTPROV provider;
BYTE privKey[] = {0x30, 0x82, 0x09, 0x26, 0x02, 0x01, 0x00, 0x02, 0x82, 0x02, 0x01, 0x00, 0xAE, 0xFF, 0x2C, 0x1E, 0xBD, 0x7A, 0xF3, 0xC0, 0x71, 0x56, 0x6D, 0x4C, 0x54, 0x59, 0x77, 0xCE, 0x88, 0xFB, 0x59, 0xB9, 0xB7, 0xDA, 0xB8, 0xCA, 0xBB, 0x67, 0x05, 0xF0, 0x50, 0xB6, 0x6C, 0x41, 0xE3, 0xB9, 0x7E, 0x36, 0xA3, 0x49, 0x13, 0x42, 0xA9, 0xBB, 0x51, 0x02, 0x97, 0xB2, 0xBF, 0x76, 0xB6, 0xFA, 0x1E, 0xCE, 0x00, 0xE7, 0xA7, 0xF8, 0xE2, 0x00, 0x08, 0x96, 0xE0, 0x9F, 0x21, 0x71, 0xAB, 0x48, 0xCB, 0xC6, 0x83, 0x63, 0xBE, 0xB9, 0x0F, 0x89, 0x66, 0x70, 0x58, 0x40, 0xC1, 0x8E, 0xAC, 0xC8, 0xE1, 0x97, 0xCF, 0x40, 0xE9, 0xE5, 0xE5, 0x35, 0x71, 0xB2, 0x28, 0xA6, 0x00, 0x2A, 0xC6, 0x39, 0x59, 0x6F, 0x81, 0xFB, 0xFC, 0x7A, 0xAC, 0x24, 0xAF, 0xB2, 0x9D, 0xFD, 0xAD, 0x91, 0xCE, 0xC8, 0xD2, 0x9E, 0x4A, 0xE2, 0x33, 0xA4, 0xB3, 0x37, 0x25, 0x41, 0x21, 0x4C, 0x8D, 0xB3, 0x9A, 0xB7, 0x96, 0x35, 0xF2, 0x95, 0x7B, 0x8A, 0x0F, 0x8E, 0x37, 0xA2, 0x15, 0xFE, 0x6B, 0xC1, 0x7D, 0x51, 0xA3, 0xE3, 0xC4, 0x13, 0xE8, 0x8B, 0x95, 0xE6, 0x10, 0x44, 0x40, 0x11, 0x6D, 0xA5, 0x4B, 0x33, 0x69, 0x2C, 0x21, 0xF7, 0x09, 0x5E, 0x09, 0x8B, 0x9C, 0x3C, 0xB3, 0xD8, 0xF9, 0xA8, 0xAF, 0x69, 0x3B, 0xBF, 0x52, 0xB6, 0xB2, 0x08, 0x2A, 0x1E, 0x5D, 0x3A, 0xCB, 0x8B, 0xC4, 0xBF, 0xA3, 0xE8, 0x20, 0x62, 0x43, 0xBB, 0x12, 0x74, 0x04, 0xE7, 0xEE, 0x3A, 0x60, 0xF4, 0x9F, 0x92, 0xA9, 0x57, 0x54, 0xA6, 0xD6, 0x16, 0x84, 0x3E, 0x60, 0x90, 0xD6, 0x1E, 0xD2, 0x9B, 0xCA, 0x1B, 0x78, 0x6E, 0xE5, 0x98, 0x68, 0x2A, 0x6D, 0x52, 0x0F, 0x54, 0x3E, 0x19, 0x8A, 0xFC, 0xC2, 0x7B, 0x67, 0x00, 0x68, 0x2B, 0x67, 0x0F, 0x2D, 0x56, 0xB2, 0xE5, 0x6F, 0x6C, 0x05, 0x7B, 0x6B, 0xA4, 0x32, 0x31, 0x97, 0x52, 0x5E, 0x38, 0x0F, 0x3F, 0x24, 0x6B, 0xF9, 0x35, 0xE0, 0x88, 0xA4, 0x26, 0x49, 0x12, 0xF1, 0x00, 0xEC, 0x2D, 0x80, 0x0B, 0x15, 0xA7, 0x32, 0x0C, 0xDD, 0xA2, 0x0C, 0xA7, 0xB8, 0x3C, 0xA0, 0x41, 0xFB, 0x3D, 0xB5, 0x4D, 0xBE, 0xFC, 0x72, 0x43, 0xDD, 0x96, 0x59, 0x1E, 0x76, 0xA2, 0xE1, 0x8A, 0x0F, 0x52, 0xF1, 0x86, 0x9B, 0x6D, 0x5E, 0x81, 0x14, 0xDE, 0x39, 0xF6, 0xB7, 0xFB, 0xEF, 0xB8, 0x74, 0xAB, 0xDA, 0x93, 0xC5, 0xB0, 0x86, 0xEF, 0x11, 0xD3, 0xC2, 0x95, 0x09, 0x06, 0x05, 0x00, 0x2E, 0x58, 0xE6, 0xFA, 0xEE, 0xE1, 0xC3, 0xA7, 0xF5, 0x4E, 0xE2, 0x93, 0xF9, 0xD9, 0x0F, 0xBE, 0xB5, 0x9A, 0x71, 0xEF, 0xE2, 0x7A, 0xEA, 0xF7, 0x17, 0x30, 0xA2, 0x51, 0xD0, 0x15, 0x4A, 0x76, 0xBD, 0x09, 0x95, 0x78, 0x4F, 0x5E, 0xC3, 0xF0, 0x22, 0xD5, 0x33, 0x87, 0x25, 0x9C, 0xF9, 0x1A, 0xA2, 0xA3, 0x7C, 0x6C, 0xF8, 0xD0, 0x9E, 0x4A, 0xA8, 0xD7, 0x25, 0x22, 0x47, 0xC9, 0x43, 0x39, 0x68, 0x11, 0x8B, 0x73, 0x6C, 0xF6, 0x84, 0x86, 0x02, 0xA0, 0xF7, 0xC8, 0x8D, 0xB4, 0x28, 0x8A, 0x96, 0x44, 0x76, 0x07, 0x57, 0x4A, 0x51, 0x27, 0xFF, 0xD5, 0x9D, 0xBF, 0x07, 0x2F, 0x00, 0x9E, 0xE5, 0xA8, 0xF8, 0xD6, 0x03, 0xA3, 0xDA, 0x17, 0xAA, 0xC8, 0x73, 0xCB, 0x6B, 0xDD, 0x1C, 0x49, 0x55, 0x87, 0x96, 0x57, 0x8C, 0xF1, 0x2B, 0xC9, 0x49, 0xD7, 0xDE, 0xD2, 0x5A, 0xC5, 0x8E, 0x83, 0x05, 0x93, 0x0C, 0xB1, 0x6F, 0xA8, 0xE8, 0x1F, 0x79, 0x19, 0xB8, 0xDA, 0xE5, 0xCC, 0xEA, 0x73, 0x0B, 0xA8, 0xC7, 0xF2, 0xD7, 0xDA, 0x5D, 0x11, 0xD0, 0x63, 0x70, 0x29, 0x60, 0x41, 0x79, 0x8E, 0xEE, 0x69, 0x15, 0xAB, 0xE8, 0x6B, 0x02, 0xEC, 0x61, 0x3D, 0xAC, 0x5D, 0x02, 0x01, 0x25, 0x02, 0x82, 0x02, 0x00, 0x1C, 0x60, 0xBB, 0x0B, 0xE7, 0x60, 0x0B, 0xDA, 0x04, 0x8A, 0x8E, 0x43, 0xBA, 0xA6, 0xB9, 0x7B, 0x70, 0x28, 0xC2, 0x71, 0x24, 0xBB, 0xAF, 0x43, 0x78, 0x55, 0xE5, 0x49, 0x90, 0x8C, 0x48, 0xE8, 0x17, 0x17, 0x29, 0x39, 0x4A, 0xE9, 0x41, 0x64, 0xC1, 0x93, 0xFF, 0x4C, 0x87, 0x4D, 0x6B, 0x28, 0x01, 0xFF, 0x0B, 0xEA, 0x0D, 0xFC, 0x0D, 0x66, 0xA1, 0x30, 0x70, 0x18, 0x77, 0x73, 0xC0, 0x3B, 0xF2, 0x43, 0x27, 0xF6, 0xAD, 0x85, 0xCB, 0xE6, 0xA8, 0x92, 0xD2, 0x57, 0x68, 0x41, 0xDA, 0x32, 0xCF, 0xE9, 0x39, 0x56, 0xE3, 0x56, 0xA2, 0x78, 0x4E, 0xAE, 0xB8, 0x7D, 0xC1, 0x67, 0x06, 0xF2, 0x2D, 0xFB, 0x76, 0x49, 0x6F, 0x06, 0x44, 0x9E, 0x45, 0x6D, 0xBB, 0xA0, 0x6C, 0xA5, 0xAD, 0x71, 0x97, 0x27, 0x7C, 0x19, 0xAB, 0x47, 0x46, 0xA5, 0x16, 0x24, 0x9E, 0x41, 0xE9, 0xB9, 0x63, 0x16, 0x34, 0xC3, 0xD3, 0x2B, 0x57, 0xC5, 0x36, 0xA0, 0xC4, 0x40, 0x93, 0x66, 0x64, 0x6E, 0x72, 0x56, 0xBA, 0x60, 0x44, 0x17, 0x18, 0xE0, 0xA2, 0x40, 0x26, 0x25, 0x4E, 0xBE, 0xF5, 0xA1, 0xF6, 0x1A, 0xCD, 0xEC, 0xA9, 0x45, 0x6D, 0x4A, 0xA7, 0x92, 0xB5, 0x70, 0x95, 0xE0, 0x54, 0x84, 0x0C, 0xCF, 0x3F, 0x0A, 0x25, 0x5D, 0x4B, 0xAE, 0xEC, 0x70, 0x06, 0xD4, 0x7D, 0xD2, 0x2E, 0xD8, 0x65, 0x18, 0x28, 0x6A, 0xD4, 0xD1, 0xAA, 0x1E, 0x56, 0x04, 0xF9, 0xE0, 0x6B, 0xD2, 0x1D, 0x8F, 0x73, 0xD2, 0x98, 0x00, 0x52, 0xEA, 0x9F, 0x41, 0xEB, 0xEE, 0x70, 0x86, 0x30, 0x8F, 0x60, 0x6C, 0x4A, 0x49, 0xA4, 0xD3, 0xB6, 0x87, 0x6A, 0xD6, 0x72, 0x97, 0xAF, 0x75, 0x71, 0xDA, 0xA0, 0xEA, 0xB7, 0xC0, 0xFB, 0xF2, 0x3A, 0x67, 0xE7, 0x32, 0xE4, 0xC1, 0xF3, 0x7F, 0x26, 0xD3, 0x3F, 0x28, 0xC5, 0x58, 0xA0, 0xE3, 0x78, 0x5F, 0x29, 0x0E, 0x9C, 0xD1, 0x4E, 0xA5, 0x54, 0x2B, 0xBA, 0xF1, 0xF3, 0xA8, 0x2B, 0xD7, 0xDD, 0xBB, 0x84, 0x7E, 0x5C, 0xF9, 0x47, 0x49, 0xA0, 0xC6, 0x01, 0xAE, 0x3C, 0xD4, 0x0C, 0xFA, 0x5C, 0x54, 0x3A, 0x85, 0xD6, 0x27, 0x05, 0xD8, 0xEF, 0x5F, 0x4D, 0x5D, 0xB9, 0xC4, 0x28, 0xE3, 0xBE, 0xEC, 0x2D, 0x34, 0x00, 0x68, 0x71, 0x20, 0x04, 0x98, 0xF3, 0x0F, 0x16, 0x56, 0x9D, 0xD2, 0xF3, 0xC9, 0xB5, 0x30, 0x44, 0xEC, 0x7E, 0x50, 0x0D, 0xD7, 0xBB, 0xB1, 0x24, 0xA1, 0xD5, 0x1F, 0x07, 0xFE, 0x33, 0x2A, 0x76, 0x55, 0xFC, 0xC7, 0xB4, 0x4B, 0x56, 0xAB, 0x9E, 0x1C, 0x1C, 0x30, 0x4A, 0x1F, 0xFB, 0x04, 0xD0, 0xE2, 0xCB, 0x04, 0x22, 0x54, 0x96, 0xE9, 0xD2, 0x47, 0x6B, 0x85, 0x5A, 0xD1, 0x43, 0x66, 0x1F, 0xFF, 0xDE, 0x44, 0x27, 0xA8, 0x7C, 0xDD, 0x24, 0xCD, 0x53, 0x6B, 0x25, 0x2B, 0x59, 0x60, 0x88, 0xD9, 0x1B, 0x8C, 0x95, 0xA4, 0xD9, 0xB7, 0xB7, 0x3C, 0x19, 0x31, 0xB4, 0x20, 0xA9, 0x14, 0x08, 0x8B, 0xE1, 0xAF, 0x04, 0x3D, 0xE2, 0x72, 0x94, 0x75, 0x80, 0x66, 0x9F, 0xDF, 0x55, 0x4B, 0x8F, 0xE5, 0x1B, 0xED, 0xFB, 0x3A, 0x93, 0x16, 0xC8, 0xF6, 0xDC, 0x23, 0x76, 0xDC, 0xC6, 0x70, 0x55, 0x50, 0x7D, 0x05, 0x58, 0xDA, 0x92, 0x90, 0x64, 0xFD, 0x04, 0xD0, 0xAD, 0xE2, 0x5A, 0x88, 0x6F, 0x19, 0xE1, 0xEC, 0xC0, 0x74, 0x2B, 0xE1, 0xC3, 0xEB, 0xEF, 0x7B, 0xD2, 0xBC, 0x13, 0x05, 0xDD, 0x27, 0xC9, 0x8E, 0xB0, 0x47, 0x3D, 0x18, 0x1C, 0xD6, 0x40, 0xF6, 0xA9, 0x6E, 0x7C, 0x7A, 0x36, 0xF3, 0xA9, 0x54, 0x3B, 0x91, 0xAE, 0xF7, 0xF7, 0xCD, 0xDC, 0xCC, 0x3B, 0xB6, 0x8D, 0x18, 0x9F, 0x95, 0xF5, 0x7A, 0xD7, 0x52, 0x37, 0xE5, 0x61, 0x75, 0x02, 0x82, 0x01, 0x01, 0x00, 0xD7, 0x63, 0xD4, 0xFD, 0xB3, 0xE3, 0xE1, 0xCF, 0x53, 0x86, 0xC2, 0x4F, 0x0D, 0x22, 0x77, 0xC5, 0xAD, 0x93, 0x71, 0x16, 0x6D, 0xBB, 0x6C, 0xB5, 0xC6, 0xCC, 0x7B, 0x4C, 0x9F, 0x44, 0x27, 0x2B, 0x0A, 0x70, 0x51, 0x25, 0x67, 0xC6, 0xE7, 0xCF, 0xE9, 0xD7, 0xEA, 0x5A, 0x3B, 0xD3, 0xA5, 0xD2, 0xF2, 0x55, 0x6A, 0xF0, 0xFB, 0xE6, 0x0F, 0xA5, 0x30, 0x4F, 0xDE, 0x7C, 0x32, 0x9B, 0x57, 0xD3, 0x58, 0x42, 0xCB, 0x63, 0x43, 0xCD, 0xAB, 0xEE, 0x09, 0x85, 0x8B, 0x75, 0xDE, 0xD6, 0x28, 0x46, 0x2A, 0xD5, 0x8A, 0xE7, 0x61, 0xB0, 0x72, 0x57, 0x44, 0x50, 0x50, 0xA0, 0x5B, 0x1E, 0x59, 0x9D, 0x72, 0x19, 0x8A, 0xC8, 0xA3, 0xA4, 0xA3, 0x24, 0x43, 0xE7, 0x86, 0xF4, 0x28, 0xCB, 0xE7, 0x5E, 0x86, 0xA2, 0xD9, 0xCC, 0x47, 0x75, 0x0F, 0x1E, 0x59, 0xA7, 0x61, 0xF4, 0x0C, 0x4A, 0x39, 0xA8, 0xFC, 0x3D, 0xA4, 0x44, 0xBF, 0x2F, 0xF2, 0x05, 0x65, 0x59, 0x94, 0x91, 0x10, 0xDF, 0x90, 0x70, 0xA4, 0x03, 0xEA, 0x25, 0x9C, 0xEF, 0x3A, 0xBE, 0x35, 0xDE, 0xC3, 0x67, 0xC1, 0xBF, 0x48, 0x14, 0x94, 0xC4, 0xFA, 0xD8, 0x77, 0xDE, 0x81, 0x62, 0x00, 0x3C, 0xC2, 0x62, 0x35, 0x04, 0x6E, 0x40, 0x19, 0xC5, 0x96, 0xFD, 0x15, 0xA1, 0x3D, 0x83, 0x18, 0x55, 0x86, 0x1A, 0x94, 0x0C, 0x20, 0x86, 0x2C, 0xA7, 0x3A, 0xE7, 0xA8, 0xF8, 0xB8, 0xA2, 0x72, 0xB4, 0x92, 0x20, 0x13, 0xA9, 0x99, 0xF7, 0x8C, 0x1C, 0x20, 0x96, 0x98, 0x05, 0x98, 0x08, 0xE7, 0xC8, 0x11, 0x18, 0x88, 0x5E, 0xE8, 0x25, 0x81, 0xA3, 0x34, 0x8F, 0x6A, 0x74, 0x77, 0x5F, 0x42, 0x18, 0x34, 0xCC, 0x1F, 0x6E, 0xD3, 0xE0, 0x2B, 0x82, 0xA1, 0xCD, 0x85, 0x49, 0xF6, 0xCB, 0xF5, 0x6F, 0x34, 0xC0, 0x6F, 0xF3, 0x69, 0xAF, 0x02, 0x82, 0x01, 0x01, 0x00, 0xCF, 0xFD, 0xB1, 0x5F, 0x2D, 0x24, 0xBB, 0xBA, 0x6B, 0xE9, 0xAF, 0xD9, 0x27, 0xE7, 0x78, 0x7E, 0x37, 0xCC, 0x53, 0x3B, 0x78, 0x11, 0x80, 0xA9, 0x6C, 0x94, 0xAC, 0xA5, 0xDE, 0xAB, 0x6E, 0x61, 0x08, 0x6F, 0x15, 0xBF, 0xD5, 0x3D, 0x7A, 0x37, 0xDB, 0xC0, 0x19, 0x1D, 0xEF, 0x56, 0x0F, 0x11, 0xDD, 0x7B, 0xB2, 0x93, 0x52, 0x01, 0x8A, 0x08, 0x06, 0xD8, 0x0E, 0x55, 0xB2, 0x10, 0x83, 0x0D, 0x3D, 0x24, 0x44, 0xF9, 0x53, 0x89, 0xDA, 0xF3, 0x5B, 0xE7, 0xFB, 0x71, 0x82, 0xE3, 0xE3, 0x13, 0x91, 0x46, 0x73, 0x79, 0x3B, 0xCD, 0x45, 0x91, 0x69, 0x17, 0x45, 0xE1, 0xAE, 0x63, 0x8F, 0x49, 0x2F, 0x40, 0x66, 0x86, 0x30, 0xAD, 0x71, 0x55, 0x0F, 0xF9, 0xE5, 0xA3, 0xF6, 0x6D, 0x7F, 0x90, 0x32, 0x66, 0xC0, 0xA0, 0x00, 0x9E, 0xC1, 0x05, 0x70, 0x68, 0x6D, 0x6D, 0x14, 0x8C, 0x96, 0xEB, 0xFC, 0x4A, 0x9A, 0x4A, 0x91, 0xA0, 0x3E, 0x82, 0x14, 0x3E, 0xC4, 0x41, 0x04, 0x0A, 0xAA, 0xBF, 0x08, 0x68, 0x2C, 0xF5, 0x0D, 0xD1, 0x71, 0x56, 0x9C, 0xB5, 0xD1, 0xA0, 0xA1, 0xC9, 0xC6, 0xDF, 0x61, 0x20, 0xFE, 0x7B, 0x90, 0x69, 0x52, 0xA0, 0x80, 0x27, 0x56, 0xDC, 0x95, 0x1A, 0x02, 0xE1, 0xF5, 0x39, 0x61, 0xFB, 0x08, 0x53, 0x02, 0x8D, 0x3D, 0xAD, 0x5A, 0xB9, 0x39, 0x97, 0x39, 0xD7, 0xA1, 0x84, 0x5B, 0xC3, 0x28, 0xF0, 0x30, 0x95, 0x7E, 0x5D, 0xF6, 0xDC, 0xD2, 0x3E, 0x0C, 0xAB, 0xDF, 0x2D, 0xDA, 0x64, 0xA2, 0xE9, 0x4B, 0x88, 0x82, 0x46, 0x42, 0xA4, 0xF7, 0xFB, 0x74, 0x36, 0xD3, 0x8D, 0xF6, 0x64, 0xF6, 0xED, 0x53, 0x0A, 0x56, 0xE5, 0x63, 0x98, 0xA4, 0xA6, 0x24, 0x29, 0x0D, 0xD3, 0x67, 0x86, 0x58, 0x5C, 0x9C, 0x18, 0x89, 0x30, 0xF3, 0xB0, 0xED, 0xEE, 0x69, 0xB3, 0x02, 0x82, 0x01, 0x00, 0x57, 0x51, 0xFC, 0x66, 0xDA, 0x39, 0xCA, 0x3F, 0x4B, 0x60, 0x25, 0x42, 0xA4, 0x75, 0xC1, 0xDA, 0x84, 0xA3, 0x8E, 0xB6, 0x10, 0xCF, 0x71, 0x42, 0xC6, 0x37, 0x38, 0xE7, 0xB6, 0x30, 0x62, 0xE7, 0xEF, 0x79, 0xA4, 0x5B, 0x45, 0xBF, 0x57, 0x0F, 0x19, 0x9C, 0xB8, 0xF4, 0x26, 0x17, 0x88, 0x6A, 0x46, 0x91, 0x54, 0xDE, 0x3C, 0x9B, 0x89, 0xCD, 0x58, 0xC6, 0x6E, 0xF4, 0x14, 0x84, 0x2A, 0x86, 0x1C, 0xDC, 0xCE, 0xFE, 0xBA, 0x9F, 0x7D, 0x0D, 0x79, 0x7B, 0x54, 0x36, 0xB4, 0x48, 0xFB, 0x92, 0x11, 0x5D, 0x7D, 0x80, 0x65, 0xDF, 0xBF, 0xA6, 0xD6, 0x81, 0x6C, 0xCB, 0x63, 0x35, 0xD1, 0x4D, 0xAA, 0xCC, 0x15, 0xAB, 0x49, 0x42, 0xBE, 0xAD, 0xD6, 0x56, 0xF1, 0x85, 0x93, 0xFF, 0xA2, 0xFC, 0xCE, 0xCC, 0x66, 0x22, 0x62, 0x28, 0x89, 0x96, 0xAE, 0xB9, 0x7A, 0xBC, 0xE2, 0x63, 0x47, 0xCE, 0xE2, 0xCC, 0xE1, 0xBB, 0x01, 0x66, 0x76, 0xDF, 0x97, 0xCA, 0x5E, 0xD3, 0x06, 0xD7, 0x2C, 0xB8, 0x0B, 0x24, 0x2E, 0x7D, 0xF3, 0x83, 0x94, 0x5A, 0xF3, 0x3E, 0xA2, 0x3E, 0xD2, 0x01, 0x70, 0x3F, 0xB1, 0xEE, 0xFD, 0xE9, 0x0E, 0x00, 0x42, 0x4A, 0x53, 0x1F, 0x8D, 0x13, 0x0E, 0x93, 0x17, 0xF0, 0x79, 0x26, 0x97, 0x28, 0x54, 0xE0, 0x80, 0xB8, 0x9B, 0x29, 0x97, 0x3B, 0x35, 0x19, 0xAC, 0x52, 0x12, 0x1A, 0x48, 0x50, 0x14, 0x11, 0xCE, 0x4F, 0xB1, 0xF6, 0x2D, 0x66, 0xF3, 0x36, 0xEB, 0x64, 0x5B, 0x65, 0x59, 0x51, 0xCE, 0xED, 0x82, 0xD3, 0x2D, 0x88, 0x75, 0xA2, 0x29, 0x72, 0x95, 0x76, 0xFD, 0x34, 0x53, 0x94, 0x16, 0x66, 0x91, 0x42, 0x4B, 0x3A, 0x3E, 0xEA, 0xF7, 0xFC, 0x7F, 0x68, 0xB7, 0xB1, 0x7F, 0xDD, 0xB2, 0x93, 0x9B, 0x67, 0x71, 0x56, 0x98, 0xD8, 0x64, 0xBC, 0xA0, 0x77, 0x02, 0x82, 0x01, 0x00, 0x27, 0x59, 0x82, 0x6B, 0xF3, 0xC8, 0xAD, 0xE4, 0xFF, 0xA8, 0xC0, 0x67, 0x5A, 0x93, 0x93, 0x56, 0x26, 0x3B, 0x69, 0xB1, 0x4E, 0x11, 0x26, 0x2D, 0xE4, 0x1C, 0x20, 0xA9, 0xC2, 0x57, 0xC8, 0xC6, 0x3F, 0xDD, 0xAA, 0x2B, 0x36, 0x2E, 0x39, 0xB7, 0x8A, 0x70, 0x73, 0x74, 0x5D, 0xB6, 0x55, 0xE0, 0xC9, 0x09, 0x90, 0x7C, 0xBC, 0x7C, 0xD4, 0xEC, 0xC3, 0x06, 0x47, 0xE6, 0xB2, 0xFC, 0x34, 0x78, 0x20, 0x52, 0xF8, 0x4A, 0xD8, 0x74, 0x06, 0xD4, 0x18, 0x4E, 0x7B, 0xAD, 0xB0, 0xFA, 0xAE, 0x6B, 0x7C, 0x59, 0x6F, 0xCA, 0xD3, 0xF6, 0x67, 0x1B, 0x82, 0x95, 0xB3, 0x46, 0x5F, 0x43, 0x44, 0x9F, 0x24, 0x9D, 0x7B, 0x2E, 0x24, 0xE2, 0x8B, 0x10, 0x17, 0xC7, 0x7E, 0x78, 0xF7, 0x45, 0x25, 0xF8, 0xAF, 0x96, 0xE6, 0x2C, 0x1B, 0xCB, 0x01, 0xEC, 0x45, 0xB2, 0xE4, 0x45, 0x11, 0xB9, 0xBB, 0xB0, 0x1A, 0xF9, 0x5B, 0x75, 0xE4, 0x33, 0x12, 0xBE, 0xA9, 0xE2, 0x5C, 0x7B, 0x00, 0xC3, 0xBF, 0x70, 0x3F, 0xDC, 0x5B, 0x88, 0x4E, 0xB8, 0xEB, 0xED, 0xCA, 0x9E, 0xF0, 0x4E, 0xD2, 0x80, 0x1E, 0xB4, 0xA3, 0xAC, 0x4B, 0xD2, 0x30, 0x13, 0xED, 0x09, 0x9B, 0xB4, 0x6A, 0x61, 0x15, 0x4A, 0x1C, 0x38, 0x96, 0x2D, 0x73, 0x66, 0xD8, 0x0F, 0xB4, 0x5F, 0xE9, 0x12, 0xF5, 0x7C, 0xFD, 0x0E, 0xC5, 0xC1, 0x02, 0xE1, 0xB0, 0x7E, 0xDE, 0x3B, 0x47, 0x76, 0x3A, 0x80, 0x7A, 0xCF, 0xD4, 0xBF, 0xA1, 0x88, 0x4C, 0xD1, 0x52, 0xD4, 0xC4, 0xE0, 0x07, 0x5F, 0x03, 0xE3, 0xC7, 0x6B, 0x51, 0x82, 0x99, 0x72, 0x28, 0x06, 0x19, 0xDB, 0xC0, 0x03, 0x62, 0xBC, 0xC4, 0x54, 0xE9, 0x54, 0x3A, 0xD3, 0x52, 0xF3, 0x02, 0x9D, 0x9D, 0xF6, 0xD2, 0x72, 0x62, 0xB8, 0x88, 0xA8, 0x65, 0x74, 0x80, 0x0A, 0x82, 0xB3, 0x02, 0x82, 0x01, 0x01, 0x00, 0xCB, 0x7C, 0xEC, 0xAA, 0x10, 0x97, 0xB1, 0xA8, 0x60, 0x0A, 0xE3, 0x61, 0xF9, 0x26, 0x2F, 0xAD, 0x88, 0xFA, 0x7C, 0x40, 0x05, 0xE0, 0xD5, 0xBB, 0x2A, 0xCE, 0x68, 0x90, 0xF2, 0xAC, 0x8B, 0x63, 0x29, 0x7F, 0xA0, 0x61, 0xC6, 0xDB, 0xBC, 0xB1, 0x20, 0x53, 0xC5, 0xEC, 0xAC, 0x04, 0xEC, 0x29, 0xBD, 0xDE, 0x4F, 0xBA, 0x55, 0x66, 0x0D, 0x25, 0xB7, 0x3E, 0xED, 0x0F, 0xCE, 0x7C, 0x43, 0x30, 0xC1, 0xDD, 0xAA, 0x50, 0x8D, 0xA9, 0x6B, 0x1C, 0x85, 0xCB, 0x24, 0xD4, 0xCA, 0xA2, 0x8F, 0x3F, 0x68, 0x0F, 0xEF, 0x86, 0x24, 0x3F, 0xA8, 0x9B, 0x65, 0x8D, 0xF4, 0x5E, 0x84, 0x57, 0x1D, 0x85, 0xBC, 0xC1, 0x49, 0x3F, 0xD5, 0x94, 0x9D, 0xA7, 0x63, 0x70, 0xA9, 0x0F, 0x29, 0x4D, 0x60, 0x80, 0x4A, 0xC0, 0x22, 0xCD, 0x1D, 0x5E, 0x0D, 0x65, 0xC2, 0xF2, 0x37, 0xA3, 0x81, 0x63, 0x2B, 0xD5, 0x38, 0x40, 0x63, 0xC2, 0x52, 0xC8, 0xA5, 0xA7, 0x06, 0xBD, 0xF9, 0xC3, 0xF8, 0x43, 0x84, 0xC0, 0x6E, 0x86, 0x03, 0x5E, 0xBE, 0xF8, 0x79, 0x7E, 0x1C, 0x2C, 0x93, 0x07, 0x35, 0xEB, 0xBA, 0x84, 0xF7, 0xAE, 0xC5, 0x9C, 0xB7, 0xAD, 0x31, 0x7D, 0xBB, 0x9C, 0x20, 0xAC, 0x8F, 0xD6, 0xB9, 0x63, 0xAE, 0xDC, 0xE3, 0x75, 0xF1, 0x41, 0x18, 0x5F, 0xCA, 0x35, 0x52, 0xFD, 0xD0, 0x8C, 0x75, 0xA6, 0x6C, 0xE1, 0x31, 0x2D, 0x11, 0x9A, 0x0D, 0x7B, 0x83, 0x04, 0xB3, 0xA1, 0x88, 0x3C, 0x2E, 0xF9, 0xD8, 0x5E, 0x10, 0x29, 0xE0, 0x3C, 0xBF, 0x4E, 0xFD, 0x7A, 0xC3, 0xF5, 0x19, 0x37, 0x41, 0x42, 0x88, 0x67, 0x4D, 0xB2, 0x99, 0x25, 0xAA, 0xC5, 0x5F, 0xE6, 0x9D, 0x47, 0x95, 0xE7, 0x86, 0x04, 0xF4, 0xA5, 0xE2, 0xC1, 0x61, 0x6F, 0x81, 0x0E, 0x4B, 0x21, 0x69, 0x45, 0x73, 0xA7, 0x0D, 0x6B};
DWORD keyBufferLength = sizeof(privKey);
CHAR encrypted[KEY_BUFFER_LENGTH];
DWORD encryptedLength = KEY_BUFFER_LENGTH;
CryptStringToBinaryA(encryptedBase64, strlen(encryptedBase64), CRYPT_STRING_BASE64, (LPBYTE)encrypted, &encryptedLength, NULL, NULL);
if (CryptAcquireContextA(&provider, NULL, MS_ENHANCED_PROV_A, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT) == TRUE)
{
DWORD derSize = 0;
BYTE *privateKeyInfo;
if (CryptDecodeObjectEx(X509_ASN_ENCODING, PKCS_RSA_PRIVATE_KEY, privKey, keyBufferLength, CRYPT_DECODE_ALLOC_FLAG, NULL, &privateKeyInfo, &derSize) != FALSE)
{
HCRYPTKEY key = 0;
if (CryptImportKey(provider, privateKeyInfo, derSize, 0, CRYPT_EXPORTABLE | CRYPT_OAEP, &key) != FALSE)
{
if (CryptDecrypt(key, NULL, TRUE, CRYPT_OAEP, (LPBYTE) encrypted, &encryptedLength) != FALSE)
{
encrypted[encryptedLength] = '\0';
printf("%s\n", encrypted);
}
else
{
DWORD error = GetLastError();
printf("%d\n", error);
}
CryptDestroyKey(key);
}
LocalFree(privateKeyInfo);
}
CryptReleaseContext(provider, 0);
}
}
Could you please tell, what is wrong with this code?

Reading raw SSL/TLS Certificate from memory using OpenSSL

I'm having trouble using OpenSSL to parse certificates from bytes acquired from a pcap file. The data is coming directly from ssl.handshake.certificate field in Wireshark (when observing the pcap).
The raw data is from a pcap file i found from Wireshark. This is just the 10th packet and is a certificate with a commonName 'Ubuntu'. I believe my problem is that i'm giving the OpenSSL function data that is incorrectly formatted but i wouldve thought that it could handle network order bytes (as i have directly from a pcap).
const unsigned int raw[] = {
0x30, 0x82, 0x02, 0xb2, 0x30, 0x82, 0x01, 0x9a,
0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x09, 0x00,
0xcd, 0xdb, 0x2b, 0xb3, 0xe2, 0xa7, 0x1b, 0x88,
0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30,
0x11, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x06, 0x75, 0x62, 0x75, 0x6e,
0x74, 0x75, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x35,
0x30, 0x31, 0x32, 0x37, 0x31, 0x36, 0x35, 0x35,
0x30, 0x31, 0x5a, 0x17, 0x0d, 0x32, 0x35, 0x30,
0x31, 0x32, 0x34, 0x31, 0x36, 0x35, 0x35, 0x30,
0x31, 0x5a, 0x30, 0x11, 0x31, 0x0f, 0x30, 0x0d,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x06, 0x75,
0x62, 0x75, 0x6e, 0x74, 0x75, 0x30, 0x82, 0x01,
0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48,
0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00,
0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01,
0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xf1, 0x85,
0x02, 0x0b, 0x26, 0x3d, 0x2d, 0xcd, 0xcc, 0x75,
0xc2, 0x1d, 0x51, 0x19, 0x7c, 0x1d, 0xbc, 0x1e,
0x14, 0xe5, 0x71, 0x6f, 0xfb, 0xaa, 0x2a, 0x8b,
0x2f, 0x69, 0xe3, 0xe7, 0xc7, 0xa4, 0xc4, 0x79,
0xef, 0x17, 0x0e, 0x4b, 0x37, 0xd8, 0x68, 0x00,
0x81, 0x6a, 0x62, 0x55, 0x79, 0x1d, 0x1d, 0x73,
0x6d, 0xbb, 0x20, 0x43, 0x4e, 0x21, 0x8b, 0xe8,
0x67, 0xb6, 0x0e, 0xfd, 0xde, 0x15, 0x18, 0xff,
0x9f, 0x0d, 0x2b, 0xf6, 0x61, 0xd5, 0x51, 0x1c,
0xfe, 0x5e, 0xca, 0x7f, 0xdc, 0x16, 0xc8, 0x4f,
0x36, 0x3d, 0x17, 0x4b, 0x85, 0x53, 0x2e, 0x85,
0x04, 0x7c, 0xa3, 0x02, 0xdd, 0xf2, 0x9b, 0x86,
0xcd, 0x98, 0x64, 0xd4, 0xcd, 0x10, 0x25, 0x79,
0xd6, 0x81, 0x36, 0x40, 0x72, 0xd3, 0xfd, 0x06,
0xff, 0x55, 0x79, 0x0b, 0xc3, 0x07, 0x7a, 0x04,
0xd3, 0x9a, 0x80, 0x92, 0xd2, 0x33, 0x82, 0x63,
0x87, 0x1f, 0xae, 0x9f, 0xb3, 0x9e, 0x01, 0x41,
0x07, 0x42, 0x02, 0x25, 0x9d, 0x29, 0xb8, 0x67,
0xa0, 0x02, 0xf5, 0x57, 0x63, 0xd6, 0xc1, 0x41,
0x5c, 0x5d, 0x74, 0x5d, 0x75, 0x17, 0x3a, 0xce,
0xd8, 0xb2, 0x9f, 0x4a, 0x66, 0x6b, 0x4c, 0x4e,
0x28, 0xf1, 0x2f, 0x74, 0x86, 0xdf, 0xe3, 0x9a,
0x3d, 0x8e, 0xbd, 0x7e, 0x03, 0xf9, 0x8d, 0x42,
0xa1, 0xe9, 0xa3, 0x58, 0xca, 0x26, 0xdb, 0xae,
0xbb, 0x47, 0x4a, 0x81, 0x98, 0x80, 0xee, 0x54,
0x04, 0x93, 0x22, 0xa8, 0x6a, 0xb1, 0xb8, 0x13,
0x14, 0xa4, 0x90, 0x99, 0x51, 0x3d, 0x30, 0xd3,
0x9a, 0xd1, 0x46, 0xc4, 0x79, 0x74, 0xe5, 0x6d,
0x4f, 0xde, 0xb8, 0xa6, 0x90, 0xb1, 0x75, 0x67,
0x16, 0xf0, 0x0e, 0x4b, 0x15, 0xfa, 0x9f, 0xbf,
0x65, 0x48, 0x2d, 0x27, 0x00, 0x3a, 0x86, 0x73,
0x49, 0xa5, 0xd9, 0x01, 0x56, 0x5f, 0x02, 0x03,
0x01, 0x00, 0x01, 0xa3, 0x0d, 0x30, 0x0b, 0x30,
0x09, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x04, 0x02,
0x30, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86,
0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05,
0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x1d, 0x14,
0x29, 0xa8, 0x5f, 0x81, 0x2b, 0xae, 0x61, 0x36,
0x7b, 0x44, 0xbb, 0xc1, 0xa2, 0x11, 0x23, 0x21,
0x43, 0x98, 0xee, 0x42, 0xfa, 0x90, 0x01, 0x5a,
0xde, 0xd6, 0x80, 0x1f, 0xa4, 0x49, 0x4b, 0xaf,
0xf8, 0x9d, 0xb8, 0xa3, 0xc8, 0xf2, 0x0f, 0xdb,
0x33, 0x6d, 0xd7, 0x29, 0x6f, 0xda, 0xe3, 0x06,
0x51, 0xab, 0xbf, 0xd2, 0xb1, 0xee, 0x89, 0x24,
0x2c, 0x00, 0x5f, 0x71, 0x0a, 0xc9, 0xba, 0xde,
0x61, 0xa0, 0x82, 0x7e, 0x40, 0xb8, 0xbf, 0xd3,
0x75, 0x9a, 0xab, 0x96, 0x77, 0xb1, 0x8e, 0x1c,
0xad, 0xf7, 0x36, 0xbb, 0xfc, 0xc3, 0x30, 0x58,
0x38, 0x19, 0x19, 0x3a, 0xdd, 0xdb, 0x03, 0xed,
0x5a, 0x31, 0xb9, 0x74, 0x06, 0x63, 0x95, 0x41,
0x48, 0x66, 0x41, 0x63, 0xf5, 0x0b, 0x5d, 0x82,
0xe4, 0xaf, 0xfc, 0x47, 0x17, 0xed, 0x4e, 0xe3,
0x8d, 0x62, 0xf9, 0x6a, 0xec, 0xcb, 0xbb, 0x2c,
0xe7, 0x8c, 0x30, 0x49, 0xfa, 0x5f, 0xda, 0xdc,
0x18, 0x14, 0x9a, 0x9a, 0x7a, 0x0f, 0xbf, 0x47,
0x22, 0x46, 0x00, 0x7b, 0xf9, 0xed, 0xd8, 0x52,
0x48, 0x32, 0x84, 0x93, 0x41, 0x50, 0x2f, 0x31,
0xf6, 0x1d, 0xfc, 0x69, 0x0d, 0x30, 0xd0, 0xda,
0x44, 0x65, 0x85, 0xde, 0x0c, 0x2c, 0x92, 0x9c,
0x42, 0xd7, 0x40, 0xe2, 0xbc, 0x7d, 0xd3, 0x93,
0xad, 0x63, 0x42, 0xe3, 0x95, 0xc4, 0xaf, 0xa2,
0x3d, 0xd6, 0x02, 0x1c, 0xf9, 0x28, 0xd2, 0xe8,
0x18, 0xa0, 0x6f, 0xb0, 0x42, 0x4c, 0x9a, 0x75,
0xca, 0x49, 0xb6, 0xa2, 0x66, 0x3d, 0xa2, 0x21,
0x76, 0xfa, 0xbd, 0xe6, 0x66, 0x73, 0x04, 0x35,
0xde, 0x6b, 0x1a, 0xb9, 0x3f, 0xa0, 0x06, 0xd5,
0x39, 0x0e, 0xc3, 0xfa, 0xe2, 0x6f, 0x7f, 0xb3,
0x4d, 0xee, 0x54, 0x38, 0x78, 0x3b, 0x1b, 0x2e,
0x71, 0xc2, 0xc5, 0x2d, 0xca, 0xf1
};
const unsigned char* data = reinterpret_cast<const unsigned char*>(raw);
size_t len = sizeof(raw)/sizeof(raw[0]);
X509 *cert = d2i_X509(NULL, &data, len);
This will always return cert as NULL and i'm stuck because this seemed like a simple procedure.

Your raw array is the wrong type. That is supposed to be a sequence of simple octets (unsigned char, uint8_t, pick your poison).
Changed as described above, the certificate is extracted successfully:
Code
#include <stdio.h>
#include <openssl/evp.h>
#include <openssl/x509.h>
const unsigned char raw[] = // <<======= HERE
{
0x30, 0x82, 0x02, 0xb2, 0x30, 0x82, 0x01, 0x9a,
0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x09, 0x00,
0xcd, 0xdb, 0x2b, 0xb3, 0xe2, 0xa7, 0x1b, 0x88,
0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30,
0x11, 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x06, 0x75, 0x62, 0x75, 0x6e,
0x74, 0x75, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x35,
0x30, 0x31, 0x32, 0x37, 0x31, 0x36, 0x35, 0x35,
0x30, 0x31, 0x5a, 0x17, 0x0d, 0x32, 0x35, 0x30,
0x31, 0x32, 0x34, 0x31, 0x36, 0x35, 0x35, 0x30,
0x31, 0x5a, 0x30, 0x11, 0x31, 0x0f, 0x30, 0x0d,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x06, 0x75,
0x62, 0x75, 0x6e, 0x74, 0x75, 0x30, 0x82, 0x01,
0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48,
0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00,
0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01,
0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xf1, 0x85,
0x02, 0x0b, 0x26, 0x3d, 0x2d, 0xcd, 0xcc, 0x75,
0xc2, 0x1d, 0x51, 0x19, 0x7c, 0x1d, 0xbc, 0x1e,
0x14, 0xe5, 0x71, 0x6f, 0xfb, 0xaa, 0x2a, 0x8b,
0x2f, 0x69, 0xe3, 0xe7, 0xc7, 0xa4, 0xc4, 0x79,
0xef, 0x17, 0x0e, 0x4b, 0x37, 0xd8, 0x68, 0x00,
0x81, 0x6a, 0x62, 0x55, 0x79, 0x1d, 0x1d, 0x73,
0x6d, 0xbb, 0x20, 0x43, 0x4e, 0x21, 0x8b, 0xe8,
0x67, 0xb6, 0x0e, 0xfd, 0xde, 0x15, 0x18, 0xff,
0x9f, 0x0d, 0x2b, 0xf6, 0x61, 0xd5, 0x51, 0x1c,
0xfe, 0x5e, 0xca, 0x7f, 0xdc, 0x16, 0xc8, 0x4f,
0x36, 0x3d, 0x17, 0x4b, 0x85, 0x53, 0x2e, 0x85,
0x04, 0x7c, 0xa3, 0x02, 0xdd, 0xf2, 0x9b, 0x86,
0xcd, 0x98, 0x64, 0xd4, 0xcd, 0x10, 0x25, 0x79,
0xd6, 0x81, 0x36, 0x40, 0x72, 0xd3, 0xfd, 0x06,
0xff, 0x55, 0x79, 0x0b, 0xc3, 0x07, 0x7a, 0x04,
0xd3, 0x9a, 0x80, 0x92, 0xd2, 0x33, 0x82, 0x63,
0x87, 0x1f, 0xae, 0x9f, 0xb3, 0x9e, 0x01, 0x41,
0x07, 0x42, 0x02, 0x25, 0x9d, 0x29, 0xb8, 0x67,
0xa0, 0x02, 0xf5, 0x57, 0x63, 0xd6, 0xc1, 0x41,
0x5c, 0x5d, 0x74, 0x5d, 0x75, 0x17, 0x3a, 0xce,
0xd8, 0xb2, 0x9f, 0x4a, 0x66, 0x6b, 0x4c, 0x4e,
0x28, 0xf1, 0x2f, 0x74, 0x86, 0xdf, 0xe3, 0x9a,
0x3d, 0x8e, 0xbd, 0x7e, 0x03, 0xf9, 0x8d, 0x42,
0xa1, 0xe9, 0xa3, 0x58, 0xca, 0x26, 0xdb, 0xae,
0xbb, 0x47, 0x4a, 0x81, 0x98, 0x80, 0xee, 0x54,
0x04, 0x93, 0x22, 0xa8, 0x6a, 0xb1, 0xb8, 0x13,
0x14, 0xa4, 0x90, 0x99, 0x51, 0x3d, 0x30, 0xd3,
0x9a, 0xd1, 0x46, 0xc4, 0x79, 0x74, 0xe5, 0x6d,
0x4f, 0xde, 0xb8, 0xa6, 0x90, 0xb1, 0x75, 0x67,
0x16, 0xf0, 0x0e, 0x4b, 0x15, 0xfa, 0x9f, 0xbf,
0x65, 0x48, 0x2d, 0x27, 0x00, 0x3a, 0x86, 0x73,
0x49, 0xa5, 0xd9, 0x01, 0x56, 0x5f, 0x02, 0x03,
0x01, 0x00, 0x01, 0xa3, 0x0d, 0x30, 0x0b, 0x30,
0x09, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x04, 0x02,
0x30, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86,
0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05,
0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x1d, 0x14,
0x29, 0xa8, 0x5f, 0x81, 0x2b, 0xae, 0x61, 0x36,
0x7b, 0x44, 0xbb, 0xc1, 0xa2, 0x11, 0x23, 0x21,
0x43, 0x98, 0xee, 0x42, 0xfa, 0x90, 0x01, 0x5a,
0xde, 0xd6, 0x80, 0x1f, 0xa4, 0x49, 0x4b, 0xaf,
0xf8, 0x9d, 0xb8, 0xa3, 0xc8, 0xf2, 0x0f, 0xdb,
0x33, 0x6d, 0xd7, 0x29, 0x6f, 0xda, 0xe3, 0x06,
0x51, 0xab, 0xbf, 0xd2, 0xb1, 0xee, 0x89, 0x24,
0x2c, 0x00, 0x5f, 0x71, 0x0a, 0xc9, 0xba, 0xde,
0x61, 0xa0, 0x82, 0x7e, 0x40, 0xb8, 0xbf, 0xd3,
0x75, 0x9a, 0xab, 0x96, 0x77, 0xb1, 0x8e, 0x1c,
0xad, 0xf7, 0x36, 0xbb, 0xfc, 0xc3, 0x30, 0x58,
0x38, 0x19, 0x19, 0x3a, 0xdd, 0xdb, 0x03, 0xed,
0x5a, 0x31, 0xb9, 0x74, 0x06, 0x63, 0x95, 0x41,
0x48, 0x66, 0x41, 0x63, 0xf5, 0x0b, 0x5d, 0x82,
0xe4, 0xaf, 0xfc, 0x47, 0x17, 0xed, 0x4e, 0xe3,
0x8d, 0x62, 0xf9, 0x6a, 0xec, 0xcb, 0xbb, 0x2c,
0xe7, 0x8c, 0x30, 0x49, 0xfa, 0x5f, 0xda, 0xdc,
0x18, 0x14, 0x9a, 0x9a, 0x7a, 0x0f, 0xbf, 0x47,
0x22, 0x46, 0x00, 0x7b, 0xf9, 0xed, 0xd8, 0x52,
0x48, 0x32, 0x84, 0x93, 0x41, 0x50, 0x2f, 0x31,
0xf6, 0x1d, 0xfc, 0x69, 0x0d, 0x30, 0xd0, 0xda,
0x44, 0x65, 0x85, 0xde, 0x0c, 0x2c, 0x92, 0x9c,
0x42, 0xd7, 0x40, 0xe2, 0xbc, 0x7d, 0xd3, 0x93,
0xad, 0x63, 0x42, 0xe3, 0x95, 0xc4, 0xaf, 0xa2,
0x3d, 0xd6, 0x02, 0x1c, 0xf9, 0x28, 0xd2, 0xe8,
0x18, 0xa0, 0x6f, 0xb0, 0x42, 0x4c, 0x9a, 0x75,
0xca, 0x49, 0xb6, 0xa2, 0x66, 0x3d, 0xa2, 0x21,
0x76, 0xfa, 0xbd, 0xe6, 0x66, 0x73, 0x04, 0x35,
0xde, 0x6b, 0x1a, 0xb9, 0x3f, 0xa0, 0x06, 0xd5,
0x39, 0x0e, 0xc3, 0xfa, 0xe2, 0x6f, 0x7f, 0xb3,
0x4d, 0xee, 0x54, 0x38, 0x78, 0x3b, 0x1b, 0x2e,
0x71, 0xc2, 0xc5, 0x2d, 0xca, 0xf1
};
int main()
{
OpenSSL_add_all_ciphers();
OpenSSL_add_all_digests();
OpenSSL_add_all_algorithms();
const unsigned char *data = raw;
size_t len = sizeof(raw) / sizeof(raw[0]);
X509 *cert = d2i_X509(NULL, &data, (long)len);
printf("%p\n", cert);
if (cert)
{
X509_NAME *name = X509_get_issuer_name(cert);
if (name)
printf("Issuer: %s\n", X509_NAME_oneline(name, NULL, 0));
X509_free(cert);
}
return 0;
}
Output (pointer value varies)
0000018ACA51BEB0
Issuer: /CN=ubuntu

Loading byte array (from memory) to LibPNG c++

Instead of using 'png_init_io' I'm trying to use 'png_set_read_fn' to provide a custom function to load a byte array from memory instead of from file.
Why would this be happening.. It seems to be failing at:
if (setjmp(png_jmpbuf(png_ctx)) != 0)
{
png_destroy_read_struct(&png_ctx, &info_ctx, NULL);
free(img_data); free(row_data);
return (1); /* libpng feedback (?) */
}
This is my code so far, the PNG data is at the end of the file
#ifndef __EMBEDDEDPNG_H__
#define __EMBEDDEDPNG_H__
#include <png.h>
typedef struct {
const png_byte* data;
const png_size_t size;
} DataHandle;
typedef struct {
const DataHandle data;
png_size_t offset;
} ReadDataHandle;
#include <GL/gl.h>
#include <algorithm>
#define PNG_SIG_BYTES (8) /* bytes in the PNG file signature. */
using byte = unsigned char;
#define PNG_RGBA_PIXEL_LIMIT (0x1000000)
static int
png_rgba_pixel_limit(png_uint_32 w, png_uint_32 h)
{
double da;
/* assert(w != 0 && h != 0); */
if (w > PNG_RGBA_PIXEL_LIMIT || h > PNG_RGBA_PIXEL_LIMIT)
return (1); /* since both (w) and (h) are non-zero. */
/* since an IEEE-754 double has a 53 bit mantissa, it can
* represent the maximum area: (w * h == 2^48) exactly. */
da = ((double)w) * ((double)h);
if (da > ((double)PNG_RGBA_PIXEL_LIMIT))
return (1);
return (0); /* the PNG image is within the pixel limit. */
}
class EmbeddedPNG
{
public:
byte *Data;
public:
size_t Read(byte* dest, const size_t byteCount);
unsigned int Load(int &width, int &height);
};
void ReadDataFromInputStream(
png_structp png_ptr, png_byte* raw_data, png_size_t read_length) {
ReadDataHandle* handle = (ReadDataHandle*)png_get_io_ptr(png_ptr);
const png_byte* png_src = handle->data.data + handle->offset;
memcpy(raw_data, png_src, read_length);
handle->offset += read_length;
}
size_t EmbeddedPNG::Read(byte* dest, const size_t byteCount)
{
std::copy(Data + 0, Data + byteCount, dest);
return byteCount;
}
unsigned int EmbeddedPNG::Load(int &width, int &height)
{
png_byte magic[PNG_SIG_BYTES]; /* (signature byte buffer) */
png_structp png_ctx;
png_infop info_ctx;
png_uint_32 img_width, img_height, row;
png_byte img_depth, img_color_type;
/* 'volatile' qualifier forces reload in setjmp cleanup: */
png_byte *volatile img_data = NULL;
png_bytep *volatile row_data = NULL;
;//*buf = NULL;
/* it is assumed that 'longjmp' can be invoked within this
* code to efficiently unwind resources for *all* errors. */
/* PNG structures and resource unwinding: */
if ((png_ctx = png_create_read_struct(
PNG_LIBPNG_VER_STRING, NULL, NULL, NULL)) == NULL)
return (1); /* ENOMEM (?) */
if ((info_ctx = png_create_info_struct(png_ctx)) == NULL)
{
png_destroy_read_struct(&png_ctx, NULL, NULL);
return (1); /* ENOMEM (?) */
}
if (setjmp(png_jmpbuf(png_ctx)) != 0)
{
png_destroy_read_struct(&png_ctx, &info_ctx, NULL);
free(img_data); free(row_data);
return (1); /* libpng feedback (?) */
}
/* check PNG file signature: */
//if (fread(magic, (1), PNG_SIG_BYTES, fp) != PNG_SIG_BYTES)
// png_error(png_ctx, "invalid PNG file");
Read(magic, PNG_SIG_BYTES);
if (png_sig_cmp(magic, 0, PNG_SIG_BYTES))
png_error(png_ctx, "invalid PNG file");
/* set the input file stream and get the PNG image info: */
//png_init_io(png_ctx, fp);
ReadDataHandle a = ReadDataHandle{ { Data, 898 }, 0 };
png_set_read_fn(png_ctx, &a, ReadDataFromInputStream);
//png_set_read_fn(png_ptr, NULL, ReadDataFromInputStream);
png_set_sig_bytes(png_ctx, PNG_SIG_BYTES);
//////////////// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
png_read_info(png_ctx, info_ctx);
img_width = png_get_image_width(png_ctx, info_ctx);
img_height = png_get_image_height(png_ctx, info_ctx);
#if (1) /* PNG doesn't support zero area image? */
if (img_width == 0 || img_height == 0)
png_error(png_ctx, "zero area PNG image");
#endif
if (png_rgba_pixel_limit(img_width, img_height))
png_error(png_ctx, "PNG image exceeds pixel limits");
img_depth = png_get_bit_depth(png_ctx, info_ctx);
img_color_type = png_get_color_type(png_ctx, info_ctx);
/* ignored image interlacing, compression and filtering. */
/* force 8-bit color channels: */
if (img_depth == 16)
png_set_strip_16(png_ctx);
else if (img_depth < 8)
png_set_packing(png_ctx);
/* force formats to RGB: */
if (img_color_type != PNG_COLOR_TYPE_RGBA)
png_set_expand(png_ctx);
if (img_color_type == PNG_COLOR_TYPE_PALETTE)
png_set_palette_to_rgb(png_ctx);
if (img_color_type == PNG_COLOR_TYPE_GRAY)
png_set_gray_to_rgb(png_ctx);
if (img_color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
png_set_gray_to_rgb(png_ctx);
/* add full opacity alpha channel if required: */
if (img_color_type != PNG_COLOR_TYPE_RGBA)
png_set_filler(png_ctx, 0xff, PNG_FILLER_AFTER);
/* apply the output transforms before reading image data: */
png_read_update_info(png_ctx, info_ctx);
/* allocate RGBA image data: */
img_data = (png_byte *)
malloc((size_t)(img_width * img_height * (4)));
if (img_data == NULL)
png_error(png_ctx, "error allocating image buffer");
/* allocate row pointers: */
row_data = (png_bytep *)
malloc((size_t)(img_height * sizeof(png_bytep)));
if (row_data == NULL)
png_error(png_ctx, "error allocating row pointers");
/* set the row pointers and read the RGBA image data: */
for (row = 0; row < img_height; row++)
row_data[row] = img_data +
(img_height - (row + 1)) * (img_width * (4));
png_read_image(png_ctx, row_data);
/* libpng and dynamic resource unwinding: */
png_read_end(png_ctx, NULL);
png_destroy_read_struct(&png_ctx, &info_ctx, NULL);
free(row_data);
//*w = (unsigned) img_width, *h = (unsigned) img_height;
width = img_width;
height = img_height;
//*buf = img_data; /* (asserts png_byte is an unsigned char) */
//Now generate the OpenGL texture object
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // Important!
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)img_data);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
return texture;
}
class EmbeddedPNG_Icon_HandShake
: public EmbeddedPNG
{
public:
EmbeddedPNG_Icon_HandShake()
{
Data = new byte[898]{ 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x08, 0x04, 0x00, 0x00, 0x00, 0xD9, 0x73, 0xB2, 0x7F, 0x00, 0x00, 0x00, 0x04, 0x67, 0x41, 0x4D, 0x41, 0x00, 0x00, 0xB1, 0x8F, 0x0B, 0xFC, 0x61, 0x05, 0x00, 0x00, 0x00, 0x20, 0x63, 0x48, 0x52, 0x4D, 0x00, 0x00, 0x7A, 0x26, 0x00, 0x00, 0x80, 0x84, 0x00, 0x00, 0xFA, 0x00, 0x00, 0x00, 0x80, 0xE8, 0x00, 0x00, 0x75, 0x30, 0x00, 0x00, 0xEA, 0x60, 0x00, 0x00, 0x3A, 0x98, 0x00, 0x00, 0x17, 0x70, 0x9C, 0xBA, 0x51, 0x3C, 0x00, 0x00, 0x00, 0x02, 0x62, 0x4B, 0x47, 0x44, 0x00, 0x00, 0xAA, 0x8D, 0x23, 0x32, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0D, 0xD7, 0x00, 0x00, 0x0D, 0xD7, 0x01, 0x42, 0x28, 0x9B, 0x78, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4D, 0x45, 0x07, 0xE1, 0x05, 0x1D, 0x15, 0x3A, 0x07, 0xDA, 0x7F, 0x48, 0xF4, 0x00, 0x00, 0x02, 0x50, 0x49, 0x44, 0x41, 0x54, 0x48, 0xC7, 0xD5, 0xD3, 0x4B, 0x68, 0x94, 0x57, 0x18, 0x06, 0xE0, 0x6F, 0x4C, 0x0C, 0x9A, 0xE2, 0x2D, 0x1A, 0xD1, 0x8A, 0x44, 0x57, 0x5A, 0xCD, 0xA2, 0xA8, 0xB1, 0x20, 0x8A, 0x97, 0x95, 0x08, 0x8A, 0x5D, 0xB4, 0x44, 0xC4, 0x8D, 0x08, 0xB6, 0x12, 0x21, 0x04, 0x84, 0xA2, 0x20, 0x48, 0xBB, 0xE8, 0xA2, 0x8B, 0x6E, 0x5A, 0x6C, 0xAD, 0x45, 0xB0, 0x14, 0x06, 0xB4, 0xA8, 0x64, 0x61, 0x16, 0x82, 0x08, 0x46, 0x4A, 0xB5, 0x68, 0x5C, 0x18, 0x35, 0xE8, 0xAC, 0x92, 0x8A, 0xA0, 0x62, 0xEE, 0x66, 0xC8, 0xD3, 0x45, 0x7E, 0xC7, 0xC9, 0xDC, 0x12, 0xBA, 0x28, 0xF8, 0xAD, 0x0E, 0x67, 0xCE, 0xFB, 0xF0, 0xFE, 0xE7, 0xFF, 0x27, 0xE2, 0x3D, 0x1A, 0xCB, 0x7C, 0xE7, 0x86, 0x83, 0x52, 0x53, 0x1D, 0x4C, 0x59, 0xA5, 0xD1, 0x5A, 0xB3, 0x26, 0xED, 0xAE, 0x90, 0xF1, 0xDC, 0x15, 0xFC, 0x58, 0x81, 0x50, 0xAD, 0x4D, 0x8F, 0x89, 0xC9, 0x7A, 0x20, 0xED, 0x84, 0xDD, 0x1A, 0x7C, 0xA0, 0x47, 0x9F, 0xD5, 0x11, 0xBE, 0xAA, 0x40, 0x98, 0xE9, 0x0F, 0x59, 0x69, 0xBB, 0x6D, 0xB5, 0xCB, 0x31, 0xE7, 0xDD, 0x35, 0x0A, 0x46, 0xB1, 0x31, 0x39, 0x55, 0x9E, 0xF0, 0x83, 0x37, 0x3E, 0x2D, 0xEA, 0xB4, 0x56, 0xB3, 0x8B, 0x68, 0xCD, 0xED, 0x95, 0x26, 0x2C, 0x34, 0xE4, 0x54, 0x99, 0x47, 0x9B, 0xE1, 0x37, 0xE3, 0xBE, 0xAC, 0x48, 0x68, 0x95, 0xF5, 0x61, 0xB2, 0xAE, 0x29, 0x22, 0xAA, 0xA6, 0x24, 0xA4, 0xDD, 0x4B, 0x56, 0x4D, 0x06, 0x0C, 0xCB, 0xF8, 0x53, 0x5A, 0x43, 0x45, 0xA2, 0x35, 0x1F, 0xB8, 0xE5, 0x62, 0xB2, 0xFA, 0xC6, 0x80, 0xAF, 0xFD, 0xEC, 0x92, 0xE7, 0x9E, 0x96, 0x26, 0x1C, 0x50, 0xED, 0xAC, 0xC7, 0x61, 0xA9, 0xDA, 0xE4, 0xE7, 0xAB, 0x1E, 0x4A, 0x45, 0x98, 0xED, 0x91, 0x6B, 0xC9, 0xDE, 0x6A, 0x7D, 0x32, 0x56, 0x14, 0x12, 0x6A, 0x9C, 0xD6, 0xE0, 0xB6, 0x8E, 0xD0, 0xE9, 0x6F, 0x75, 0x11, 0x11, 0xF6, 0xE2, 0xBA, 0x16, 0x1D, 0xD8, 0x93, 0x8B, 0x94, 0x23, 0xE6, 0xEA, 0x34, 0x62, 0x4B, 0xD8, 0xAC, 0x3F, 0x47, 0x1C, 0xD1, 0x87, 0x7F, 0x1C, 0x9E, 0x74, 0x7D, 0xA5, 0x89, 0x1E, 0x23, 0x76, 0x4E, 0x6C, 0xE4, 0x13, 0x55, 0xE6, 0xAB, 0x2A, 0x7A, 0x03, 0x85, 0xC4, 0x02, 0x2F, 0x73, 0xF1, 0x42, 0xA2, 0xCC, 0x77, 0x90, 0x47, 0x98, 0xE3, 0xD6, 0xA4, 0x78, 0x42, 0x0C, 0x4F, 0x8F, 0x30, 0xC7, 0xCD, 0xA2, 0x78, 0x84, 0x56, 0x28, 0x47, 0xA8, 0xB5, 0x47, 0x4D, 0x42, 0x74, 0x96, 0x8A, 0x7F, 0x84, 0x5F, 0xED, 0x93, 0x2D, 0x4D, 0x58, 0x22, 0xEB, 0x72, 0x42, 0x70, 0xA8, 0xF8, 0xC0, 0x51, 0x2C, 0xF6, 0x89, 0xFE, 0xE2, 0x16, 0x6A, 0xAD, 0x8C, 0xB0, 0x2F, 0x8F, 0xC8, 0xA8, 0x2F, 0x04, 0x96, 0x19, 0xD5, 0x6B, 0x50, 0x97, 0x96, 0xC2, 0x16, 0x36, 0x1B, 0x77, 0x24, 0x42, 0x73, 0x8E, 0x18, 0x72, 0xB2, 0xB8, 0x43, 0x93, 0x6B, 0xD8, 0x62, 0x9E, 0xEE, 0x77, 0x2D, 0x54, 0x99, 0x29, 0xE5, 0x34, 0x5A, 0x22, 0x7C, 0x6E, 0xCC, 0x15, 0xDB, 0xBC, 0x70, 0xBE, 0xD4, 0x45, 0xD5, 0x19, 0x70, 0x5F, 0xB7, 0x01, 0xDF, 0xBE, 0x6D, 0xE1, 0x0B, 0xAF, 0x6C, 0x94, 0xF2, 0x13, 0x8E, 0x46, 0xF8, 0x0C, 0x8C, 0xD8, 0x54, 0xFA, 0x45, 0x6D, 0xF7, 0x17, 0xF6, 0x47, 0xE8, 0x98, 0x68, 0xA1, 0x5E, 0x97, 0x57, 0x36, 0x48, 0x39, 0x83, 0x36, 0x4B, 0x3C, 0x73, 0xA9, 0xE8, 0x06, 0x26, 0x5D, 0xD8, 0x33, 0x37, 0x5C, 0x40, 0x7A, 0xA2, 0x85, 0x7A, 0x5D, 0x5E, 0x5A, 0x2F, 0xE5, 0x2C, 0x18, 0xB7, 0x26, 0x2A, 0x8D, 0x1D, 0xBA, 0xF1, 0x4B, 0x84, 0xEF, 0xF3, 0x5A, 0xBC, 0xB0, 0xCE, 0xC7, 0x68, 0xB7, 0x2A, 0xA6, 0x1A, 0xD5, 0x9E, 0xE8, 0x74, 0xDC, 0xA8, 0x9B, 0xFA, 0xDD, 0xB1, 0x40, 0xBD, 0x2E, 0x83, 0xBA, 0x8D, 0x59, 0x3E, 0x65, 0x3C, 0x22, 0xC2, 0x4E, 0x19, 0x63, 0x7E, 0x37, 0xFB, 0xED, 0x7F, 0x44, 0x33, 0xDA, 0x35, 0x4D, 0x2B, 0x1E, 0x11, 0x61, 0x86, 0x45, 0xB9, 0xAF, 0xA0, 0x5F, 0xAF, 0x8C, 0xD7, 0xE6, 0x4E, 0x3B, 0x5E, 0x80, 0x35, 0x3A, 0xA7, 0xDD, 0x8E, 0xFF, 0x18, 0xFF, 0x1F, 0xE6, 0x5F, 0x1F, 0xA9, 0x98, 0xCC, 0x0D, 0x77, 0xF1, 0x32, 0x00, 0x00, 0x00, 0x25, 0x74, 0x45, 0x58, 0x74, 0x64, 0x61, 0x74, 0x65, 0x3A, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x00, 0x32, 0x30, 0x31, 0x37, 0x2D, 0x30, 0x35, 0x2D, 0x32, 0x39, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x38, 0x3A, 0x30, 0x37, 0x2B, 0x30, 0x32, 0x3A, 0x30, 0x30, 0x19, 0xBB, 0x75, 0xB7, 0x00, 0x00, 0x00, 0x25, 0x74, 0x45, 0x58, 0x74, 0x64, 0x61, 0x74, 0x65, 0x3A, 0x6D, 0x6F, 0x64, 0x69, 0x66, 0x79, 0x00, 0x32, 0x30, 0x31, 0x37, 0x2D, 0x30, 0x35, 0x2D, 0x32, 0x39, 0x54, 0x32, 0x31, 0x3A, 0x35, 0x38, 0x3A, 0x30, 0x37, 0x2B, 0x30, 0x32, 0x3A, 0x30, 0x30, 0x68, 0xE6, 0xCD, 0x0B, 0x00, 0x00, 0x00, 0x19, 0x74, 0x45, 0x58, 0x74, 0x53, 0x6F, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x00, 0x77, 0x77, 0x77, 0x2E, 0x69, 0x6E, 0x6B, 0x73, 0x63, 0x61, 0x70, 0x65, 0x2E, 0x6F, 0x72, 0x67, 0x9B, 0xEE, 0x3C, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82 };
}
};
#endif

Don't call
png_set_sig_bytes(png_ctx, PNG_SIG_BYTES);
This signals libpng to skip reading the signature bytes causing your offset to be wrong when you start reading the png data. Offset points to zero and libpng assumes that it's already 8 (or more accurately that there is no signature in the stream).
Source: I ran this through a debugger.

Getting wxImage in a panel

I've a problem to get a wxImage into a wxPanel.
I want to create a .exe with some pics in the exe, but I want to avoid to give the PNG-Pics with the exe.
So far, I get the PNGs into the exe with this:
wxStaticBitmap *image = new wxStaticBitmap(p_img, wxID_ANY,
wxBitmap("Bild.png", wxBITMAP_TYPE_PNG),
wxPoint(0,0),
wxSize(width, height);
where p_img ist the panel and Bild.png the picture.
Now, I have followed http://wiki.wxwidgets.org/WxImage And have now a wxImage... But I don't know how I can get the wxImage in the panel.
wxMemoryInputStream istream1(Bild_png, sizeof Bild_png);
wxImage Bild_png(istream1, wxBITMAP_TYPE_PNG);
I hope somebody has a idea.
-Casisto
My System:
OS: Win 8.1; wxW 2.9.4; IDE: CodeLite5.1

You can pass wxImage into wxBitmap constructor (wxBitmap Class Reference):
wxBitmap(const wxImage &img, int depth=wxBITMAP_SCREEN_DEPTH)
And then you can create wxStaticBitmap. So the code would be something like that:
wxImage Bild_png(istream1, wxBITMAP_TYPE_PNG);
wxStaticBitmap *staticBitmap = new wxStaticBitmap(p_img, wxID_ANY, wxBitmap(Bild_png));

As I understand you want to use the images and do not want to ship with exe as a physical files on the file system.
For Windows platform resource only Dll can be used. If you want cross platform you can use following technique:
Convert your PNG file to C++ style array.
And use this C++ array to create wxImage object.
You can download the application to get C++ array from:
http://sourceforge.net/projects/png2cscc/
you will get C++ array like below and put this array in some source file of your project.
static const unsigned int the_sizeof_swdXW_bytes = 2304 ;
static const unsigned char the_swdXW_bytes[ the_sizeof_swdXW_bytes ] =
{
0xED, 0xF8, 0xFC, 0xFF, 0xEB, 0xF4, 0xF9, 0xFF, 0xEF, 0xF3, 0xFC, 0xFF, 0xF4, 0xF7, 0xFF, 0xFF,
0xF7, 0xF7, 0xFF, 0xFF, 0xEE, 0xF1, 0xFA, 0xFF, 0xEB, 0xF0, 0xF6, 0xFF, 0xF1, 0xF9, 0xFC, 0xFF,
0xEE, 0xF8, 0xFA, 0xFF, 0xED, 0xF6, 0xF5, 0xFF, 0xEC, 0xF2, 0xF2, 0xFF, 0xE6, 0xEA, 0xE9, 0xFF,
0xE1, 0xE3, 0xE2, 0xFF, 0xDC, 0xE0, 0xDF, 0xFF, 0xDC, 0xE0, 0xE1, 0xFF, 0xD8, 0xDD, 0xD9, 0xFF,
0xD0, 0xD1, 0xC9, 0xFF, 0xE2, 0xE2, 0xD6, 0xFF, 0xB4, 0xB1, 0xA8, 0xFF, 0x81, 0x7E, 0x75, 0xFF,
0xBA, 0xB5, 0xAF, 0xFF, 0xC2, 0xBD, 0xB7, 0xFF, 0xD0, 0xC9, 0xC3, 0xFF, 0xC6, 0xBF, 0xB9, 0xFF,
0xEA, 0xF3, 0xF8, 0xFF, 0xEB, 0xF4, 0xF9, 0xFF, 0xF1, 0xF6, 0xFC, 0xFF, 0xF3, 0xF6, 0xFF, 0xFF,
0xF4, 0xF4, 0xFE, 0xFF, 0xEC, 0xEF, 0xF6, 0xFF, 0xE9, 0xEE, 0xF4, 0xFF, 0xF0, 0xF8, 0xFB, 0xFF,
0xEE, 0xF6, 0xF8, 0xFF, 0xEC, 0xF2, 0xF2, 0xFF, 0xF7, 0xFB, 0xFA, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF,
0xFB, 0xFB, 0xFB, 0xFF, 0xF5, 0xF7, 0xF6, 0xFF, 0xD9, 0xDD, 0xDE, 0xFF, 0xD2, 0xD7, 0xD3, 0xFF,
0xD2, 0xD3, 0xCB, 0xFF, 0xDD, 0xDD, 0xD3, 0xFF, 0xB5, 0xB2, 0xA9, 0xFF, 0x83, 0x80, 0x79, 0xFF,
0xBD, 0xB8, 0xB2, 0xFF, 0xC3, 0xBE, 0xB8, 0xFF, 0xD2, 0xCB, 0xC5, 0xFF, 0xC5, 0xBE, 0xB8, 0xFF,
0xE6, 0xEE, 0xF1, 0xFF, 0xE9, 0xF1, 0xF4, 0xFF, 0xEF, 0xF2, 0xF7, 0xFF, 0xF1, 0xF1, 0xF9, 0xFF,
0xEF, 0xF2, 0xF9, 0xFF, 0xE9, 0xEC, 0xF3, 0xFF, 0xE2, 0xE7, 0xEB, 0xFF, 0xE9, 0xF1, 0xF3, 0xFF,
0xE9, 0xEF, 0xEF, 0xFF, 0xF6, 0xFA, 0xF9, 0xFF, 0xE1, 0xE1, 0xE1, 0xFF, 0xA4, 0xA3, 0xA1, 0xFF,
0xB5, 0xB3, 0xB4, 0xFF, 0xAC, 0xAA, 0xAB, 0xFF, 0xE9, 0xEA, 0xEC, 0xFF, 0xDB, 0xDD, 0xDC, 0xFF,
0xD2, 0xD1, 0xCC, 0xFF, 0xD8, 0xD5, 0xCE, 0xFF, 0xBB, 0xB6, 0xB0, 0xFF, 0x85, 0x80, 0x7C, 0xFF,
0xBE, 0xB6, 0xB3, 0xFF, 0xC5, 0xBD, 0xBA, 0xFF, 0xD7, 0xCF, 0xCC, 0xFF, 0xC4, 0xBC, 0xB9, 0xFF,
0xE3, 0xE8, 0xEB, 0xFF, 0xE5, 0xEA, 0xED, 0xFF, 0xE6, 0xEA, 0xED, 0xFF, 0xEA, 0xEB, 0xF0, 0xFF,
0xEB, 0xEE, 0xF3, 0xFF, 0xE5, 0xE8, 0xED, 0xFF, 0xD9, 0xDE, 0xE1, 0xFF, 0xE6, 0xEC, 0xEC, 0xFF,
0xFE, 0xFF, 0xFF, 0xFF, 0xC8, 0xC7, 0xC5, 0xFF, 0x04, 0x00, 0x00, 0xFF, 0x06, 0x00, 0x00, 0xFF,
0x07, 0x00, 0x00, 0xFF, 0x04, 0x00, 0x00, 0xFF, 0x58, 0x56, 0x57, 0xFF, 0xF5, 0xF5, 0xF3, 0xFF,
0xD5, 0xD1, 0xCE, 0xFF, 0xD4, 0xD1, 0xCC, 0xFF, 0xC2, 0xBD, 0xB9, 0xFF, 0x82, 0x7D, 0x79, 0xFF,
0xB8, 0xB0, 0xAD, 0xFF, 0xC3, 0xBB, 0xB8, 0xFF, 0xDC, 0xD4, 0xD1, 0xFF, 0xC4, 0xBC, 0xB9, 0xFF,
0xE0, 0xE4, 0xE5, 0xFF, 0xE0, 0xE4, 0xE5, 0xFF, 0xE1, 0xE2, 0xE4, 0xFF, 0xE5, 0xE6, 0xEA, 0xFF,
0xE5, 0xE9, 0xEC, 0xFF, 0xDF, 0xE3, 0xE4, 0xFF, 0xD5, 0xD9, 0xDA, 0xFF, 0xEF, 0xF1, 0xF0, 0xFF,
0xE2, 0xE1, 0xDF, 0xFF, 0x08, 0x00, 0x00, 0xFF, 0x0A, 0x00, 0x00, 0xFF, 0x22, 0x12, 0x13, 0xFF,
0x23, 0x15, 0x15, 0xFF, 0x15, 0x09, 0x09, 0xFF, 0x04, 0x00, 0x00, 0xFF, 0xBD, 0xB9, 0xB6, 0xFF,
0xE3, 0xDF, 0xDC, 0xFF, 0xD3, 0xCF, 0xCC, 0xFF, 0xC4, 0xBF, 0xBC, 0xFF, 0x80, 0x7B, 0x78, 0xFF,
0xB4, 0xAC, 0xA9, 0xFF, 0xC2, 0xBA, 0xB7, 0xFF, 0xDF, 0xD7, 0xD4, 0xFF, 0xC8, 0xC0, 0xBD, 0xFF,
0xDD, 0xDF, 0xDE, 0xFF, 0xDF, 0xE1, 0xE0, 0xFF, 0xDE, 0xE0, 0xDF, 0xFF, 0xE0, 0xE2, 0xE1, 0xFF,
0xDE, 0xE2, 0xE3, 0xFF, 0xD8, 0xDC, 0xDB, 0xFF, 0xD3, 0xD7, 0xD6, 0xFF, 0xFA, 0xFA, 0xF8, 0xFF,
0x6C, 0x64, 0x62, 0xFF, 0x0A, 0x00, 0x00, 0xFF, 0x67, 0x53, 0x52, 0xFF, 0x8A, 0x72, 0x72, 0xFF,
0x87, 0x72, 0x71, 0xFF, 0x75, 0x63, 0x61, 0xFF, 0x09, 0x00, 0x00, 0xFF, 0x5F, 0x57, 0x54, 0xFF,
0xF3, 0xEE, 0xEA, 0xFF, 0xD2, 0xCF, 0xCA, 0xFF, 0xC3, 0xBE, 0xBB, 0xFF, 0x7F, 0x7A, 0x76, 0xFF,
0xB4, 0xAC, 0xA9, 0xFF, 0xC1, 0xB9, 0xB6, 0xFF, 0xDE, 0xD6, 0xD3, 0xFF, 0xCC, 0xC4, 0xC1, 0xFF,
0xD7, 0xD7, 0xD5, 0xFF, 0xDC, 0xDC, 0xDA, 0xFF, 0xD9, 0xDB, 0xD8, 0xFF, 0xD9, 0xDB, 0xD8, 0xFF,
0xD7, 0xDB, 0xDA, 0xFF, 0xD3, 0xD8, 0xD4, 0xFF, 0xCE, 0xD0, 0xCB, 0xFF, 0xFA, 0xF7, 0xF2, 0xFF,
0x46, 0x3B, 0x37, 0xFF, 0x62, 0x4F, 0x4B, 0xFF, 0xB9, 0x9D, 0x9A, 0xFF, 0xCC, 0xAD, 0xAA, 0xFF,
0x92, 0x75, 0x71, 0xFF, 0x94, 0x7B, 0x76, 0xFF, 0x3B, 0x28, 0x21, 0xFF, 0x48, 0x3B, 0x33, 0xFF,
0xF0, 0xE9, 0xE3, 0xFF, 0xCF, 0xCC, 0xC5, 0xFF, 0xC6, 0xC1, 0xBD, 0xFF, 0x80, 0x7B, 0x75, 0xFF,
0xB1, 0xAA, 0xA4, 0xFF, 0xC1, 0xBA, 0xB4, 0xFF, 0xDB, 0xD4, 0xCE, 0xFF, 0xC9, 0xC2, 0xBC, 0xFF,
0xD3, 0xD4, 0xCF, 0xFF, 0xD8, 0xD9, 0xD4, 0xFF, 0xD2, 0xD4, 0xD1, 0xFF, 0xD2, 0xD4, 0xD1, 0xFF,
0xD3, 0xD8, 0xD4, 0xFF, 0xD3, 0xD5, 0xD0, 0xFF, 0xC8, 0xC9, 0xC3, 0xFF, 0xF0, 0xEB, 0xE5, 0xFF,
0x8D, 0x80, 0x78, 0xFF, 0x3F, 0x28, 0x22, 0xFF, 0x4C, 0x2B, 0x26, 0xFF, 0x95, 0x70, 0x6A, 0xFF,
0x58, 0x35, 0x2F, 0xFF, 0x69, 0x4B, 0x43, 0xFF, 0x75, 0x5D, 0x53, 0xFF, 0x80, 0x6F, 0x65, 0xFF,
0xDF, 0xD8, 0xCE, 0xFF, 0xCC, 0xC9, 0xC0, 0xFF, 0xCB, 0xC6, 0xC0, 0xFF, 0x80, 0x7C, 0x73, 0xFF,
0xAC, 0xA5, 0x9F, 0xFF, 0xC0, 0xB9, 0xB1, 0xFF, 0xD8, 0xD1, 0xCB, 0xFF, 0xC4, 0xBD, 0xB5, 0xFF,
0xD0, 0xD2, 0xCD, 0xFF, 0xD5, 0xD7, 0xD2, 0xFF, 0xCA, 0xCC, 0xC7, 0xFF, 0xD2, 0xD4, 0xCF, 0xFF,
0xCD, 0xD2, 0xCC, 0xFF, 0xCB, 0xCE, 0xC7, 0xFF, 0xCB, 0xCB, 0xC3, 0xFF, 0xD9, 0xD2, 0xCA, 0xFF,
0xA9, 0x98, 0x90, 0xFF, 0x63, 0x48, 0x41, 0xFF, 0x8D, 0x68, 0x60, 0xFF, 0x92, 0x69, 0x63, 0xFF,
0xA5, 0x7F, 0x76, 0xFF, 0xBE, 0x9C, 0x92, 0xFF, 0x82, 0x66, 0x5B, 0xFF, 0x7E, 0x6A, 0x5F, 0xFF,
0xE2, 0xDC, 0xD0, 0xFF, 0xC6, 0xC4, 0xB8, 0xFF, 0xCF, 0xCB, 0xC2, 0xFF, 0x83, 0x7F, 0x74, 0xFF,
0xA8, 0xA1, 0x99, 0xFF, 0xC0, 0xB9, 0xAF, 0xFF, 0xD2, 0xCB, 0xC3, 0xFF, 0xBE, 0xB7, 0xAD, 0xFF,
0xCD, 0xCF, 0xCA, 0xFF, 0xC8, 0xCA, 0xC5, 0xFF, 0xD0, 0xD2, 0xCD, 0xFF, 0xCC, 0xCE, 0xC9, 0xFF,
0xC9, 0xCC, 0xC5, 0xFF, 0xC4, 0xC7, 0xBE, 0xFF, 0xC2, 0xC2, 0xBA, 0xFF, 0xC1, 0xBA, 0xB0, 0xFF,
0xAE, 0x9D, 0x95, 0xFF, 0x74, 0x59, 0x50, 0xFF, 0xA1, 0x7F, 0x76, 0xFF, 0x7C, 0x54, 0x4C, 0xFF,
0x7F, 0x59, 0x50, 0xFF, 0x85, 0x60, 0x57, 0xFF, 0x6A, 0x4C, 0x41, 0xFF, 0xC1, 0xAD, 0xA2, 0xFF,
0xD5, 0xCF, 0xC3, 0xFF, 0xC5, 0xC5, 0xB9, 0xFF, 0xD1, 0xCF, 0xC3, 0xFF, 0x83, 0x7F, 0x74, 0xFF,
0xA5, 0xA1, 0x96, 0xFF, 0xC0, 0xB9, 0xAF, 0xFF, 0xC7, 0xC0, 0xB6, 0xFF, 0xBF, 0xB8, 0xAE, 0xFF,
0xC8, 0xCB, 0xC4, 0xFF, 0xCE, 0xD1, 0xCA, 0xFF, 0xC5, 0xC6, 0xC1, 0xFF, 0xC9, 0xCA, 0xC5, 0xFF,
0xC6, 0xC7, 0xC1, 0xFF, 0xBD, 0xBE, 0xB6, 0xFF, 0xB6, 0xB6, 0xAE, 0xFF, 0xB8, 0xB1, 0xA7, 0xFF,
0xC9, 0xBB, 0xB2, 0xFF, 0x79, 0x63, 0x58, 0xFF, 0x4D, 0x2F, 0x25, 0xFF, 0x6E, 0x4C, 0x43, 0xFF,
0x7B, 0x56, 0x4E, 0xFF, 0x73, 0x52, 0x49, 0xFF, 0x47, 0x2B, 0x20, 0xFF, 0xDE, 0xCC, 0xC0, 0xFF,
0xF4, 0xED, 0xE3, 0xFF, 0xCB, 0xCB, 0xC1, 0xFF, 0xCF, 0xCF, 0xC5, 0xFF, 0x84, 0x81, 0x78, 0xFF,
0x9F, 0x9B, 0x90, 0xFF, 0xBE, 0xBA, 0xAF, 0xFF, 0xC9, 0xC2, 0xB8, 0xFF, 0xB8, 0xB1, 0xA7, 0xFF,
0xC8, 0xCB, 0xC4, 0xFF, 0xC7, 0xCA, 0xC3, 0xFF, 0xC8, 0xC9, 0xC4, 0xFF, 0xC7, 0xC8, 0xC3, 0xFF,
0xC4, 0xC5, 0xBF, 0xFF, 0xBD, 0xBC, 0xB7, 0xFF, 0xB7, 0xB7, 0xAF, 0xFF, 0xB1, 0xAD, 0xA4, 0xFF,
0xB4, 0xA7, 0x9F, 0xFF, 0xC0, 0xAD, 0xA6, 0xFF, 0x5D, 0x44, 0x3D, 0xFF, 0x6A, 0x4D, 0x47, 0xFF,
0x81, 0x64, 0x5E, 0xFF, 0x45, 0x2A, 0x23, 0xFF, 0x62, 0x4B, 0x43, 0xFF, 0x4C, 0x3E, 0x35, 0xFF,
0x6C, 0x69, 0x62, 0xFF, 0xB0, 0xB1, 0xAB, 0xFF, 0xE8, 0xE9, 0xE3, 0xFF, 0x9B, 0x9B, 0x93, 0xFF,
0xA1, 0x9E, 0x95, 0xFF, 0xBA, 0xB6, 0xAD, 0xFF, 0xC7, 0xC0, 0xB8, 0xFF, 0xBE, 0xB7, 0xAD, 0xFF,
0xC8, 0xCB, 0xC2, 0xFF, 0xC5, 0xC8, 0xBF, 0xFF, 0xC8, 0xC9, 0xC3, 0xFF, 0xC7, 0xC6, 0xC1, 0xFF,
0xBD, 0xBC, 0xB8, 0xFF, 0xBB, 0xBA, 0xB6, 0xFF, 0xB3, 0xB2, 0xAD, 0xFF, 0xAF, 0xAC, 0xA7, 0xFF,
0xC9, 0xC2, 0xBC, 0xFF, 0x8D, 0x82, 0x7C, 0xFF, 0x51, 0x3F, 0x3B, 0xFF, 0x34, 0x21, 0x1D, 0xFF,
0x27, 0x14, 0x10, 0xFF, 0x72, 0x5F, 0x5B, 0xFF, 0x90, 0x81, 0x7E, 0xFF, 0x10, 0x06, 0x04, 0xFF,
0x01, 0x00, 0x00, 0xFF, 0x00, 0x01, 0x00, 0xFF, 0x28, 0x28, 0x26, 0xFF, 0x57, 0x56, 0x52, 0xFF,
0x9B, 0x98, 0x93, 0xFF, 0xC7, 0xC4, 0xBF, 0xFF, 0xC1, 0xBC, 0xB6, 0xFF, 0xB9, 0xB5, 0xAC, 0xFF,
0xCA, 0xCD, 0xC4, 0xFF, 0xC7, 0xC8, 0xC0, 0xFF, 0xC8, 0xC7, 0xC2, 0xFF, 0xC2, 0xBF, 0xBA, 0xFF,
0xC4, 0xC0, 0xBD, 0xFF, 0xBE, 0xBA, 0xB7, 0xFF, 0xC4, 0xC3, 0xBF, 0xFF, 0xC4, 0xC3, 0xBF, 0xFF,
0x5C, 0x5B, 0x56, 0xFF, 0x04, 0x00, 0x00, 0xFF, 0x39, 0x2F, 0x2D, 0xFF, 0x86, 0x7A, 0x7A, 0xFF,
0x88, 0x7C, 0x7C, 0xFF, 0x77, 0x6D, 0x6E, 0xFF, 0x1D, 0x14, 0x15, 0xFF, 0x13, 0x0F, 0x10, 0xFF,
0x1B, 0x1C, 0x20, 0xFF, 0x11, 0x15, 0x18, 0xFF, 0x08, 0x09, 0x0B, 0xFF, 0x01, 0x01, 0x01, 0xFF,
0x0A, 0x09, 0x07, 0xFF, 0xC4, 0xC0, 0xBD, 0xFF, 0xBD, 0xB8, 0xB4, 0xFF, 0xB3, 0xAE, 0xA8, 0xFF,
0xC6, 0xC9, 0xBE, 0xFF, 0xC4, 0xC5, 0xBD, 0xFF, 0xC5, 0xC2, 0xBD, 0xFF, 0xC7, 0xC2, 0xBE, 0xFF,
0xC6, 0xC1, 0xBE, 0xFF, 0xC6, 0xC2, 0xC1, 0xFF, 0xB4, 0xB4, 0xB2, 0xFF, 0x24, 0x26, 0x23, 0xFF,
0x00, 0x02, 0x00, 0xFF, 0x19, 0x19, 0x17, 0xFF, 0x15, 0x13, 0x14, 0xFF, 0x2E, 0x2A, 0x2B, 0xFF,
0x2F, 0x29, 0x2D, 0xFF, 0x04, 0x00, 0x05, 0xFF, 0x12, 0x10, 0x15, 0xFF, 0x16, 0x17, 0x1C, 0xFF,
0x11, 0x14, 0x1B, 0xFF, 0x12, 0x15, 0x1C, 0xFF, 0x1A, 0x1B, 0x20, 0xFF, 0x16, 0x15, 0x1A, 0xFF,
0x07, 0x05, 0x08, 0xFF, 0x64, 0x60, 0x61, 0xFF, 0xD7, 0xD2, 0xCF, 0xFF, 0xAC, 0xA7, 0xA3, 0xFF,
0xC3, 0xC6, 0xBB, 0xFF, 0xC8, 0xC9, 0xC1, 0xFF, 0xC7, 0xC4, 0xBF, 0xFF, 0xC3, 0xC0, 0xBB, 0xFF,
0xC8, 0xC2, 0xC2, 0xFF, 0xC6, 0xC2, 0xC1, 0xFF, 0x0F, 0x0F, 0x0F, 0xFF, 0x01, 0x03, 0x02, 0xFF,
0x16, 0x1A, 0x1B, 0xFF, 0x14, 0x18, 0x1B, 0xFF, 0x14, 0x15, 0x19, 0xFF, 0x0E, 0x0F, 0x14, 0xFF,
0x0C, 0x0B, 0x11, 0xFF, 0x19, 0x18, 0x20, 0xFF, 0x17, 0x17, 0x1F, 0xFF, 0x14, 0x17, 0x20, 0xFF,
0x13, 0x16, 0x1F, 0xFF, 0x11, 0x14, 0x1D, 0xFF, 0x11, 0x14, 0x1D, 0xFF, 0x18, 0x18, 0x20, 0xFF,
0x17, 0x14, 0x1B, 0xFF, 0x07, 0x05, 0x08, 0xFF, 0xB9, 0xB5, 0xB6, 0xFF, 0xAF, 0xAB, 0xAA, 0xFF,
0xBF, 0xC0, 0xB8, 0xFF, 0xC3, 0xC4, 0xBC, 0xFF, 0xC4, 0xC3, 0xBE, 0xFF, 0xC0, 0xBF, 0xBA, 0xFF,
0xDA, 0xD6, 0xD5, 0xFF, 0x84, 0x82, 0x83, 0xFF, 0x01, 0x01, 0x03, 0xFF, 0x1A, 0x1B, 0x1F, 0xFF,
0x14, 0x17, 0x1E, 0xFF, 0x17, 0x1A, 0x23, 0xFF, 0x11, 0x14, 0x1D, 0xFF, 0x12, 0x15, 0x1E, 0xFF,
0x17, 0x17, 0x21, 0xFF, 0x14, 0x14, 0x1E, 0xFF, 0x17, 0x17, 0x21, 0xFF, 0x14, 0x17, 0x20, 0xFF,
0x15, 0x18, 0x21, 0xFF, 0x0F, 0x12, 0x1B, 0xFF, 0x16, 0x18, 0x24, 0xFF, 0x17, 0x17, 0x23, 0xFF,
0x19, 0x19, 0x23, 0xFF, 0x00, 0x00, 0x07, 0xFF, 0x73, 0x72, 0x77, 0xFF, 0xBA, 0xBA, 0xBC, 0xFF,
0xC1, 0xC2, 0xBA, 0xFF, 0xBE, 0xBF, 0xB7, 0xFF, 0xC7, 0xC6, 0xC1, 0xFF, 0xBE, 0xBD, 0xB8, 0xFF,
0xD9, 0xD8, 0xD6, 0xFF, 0x6F, 0x6D, 0x6E, 0xFF, 0x03, 0x03, 0x05, 0xFF, 0x15, 0x16, 0x1B, 0xFF,
0x14, 0x14, 0x1E, 0xFF, 0x11, 0x13, 0x1F, 0xFF, 0x13, 0x17, 0x23, 0xFF, 0x15, 0x19, 0x25, 0xFF,
0x14, 0x16, 0x22, 0xFF, 0x12, 0x14, 0x20, 0xFF, 0x15, 0x15, 0x1F, 0xFF, 0x15, 0x18, 0x21, 0xFF,
0x13, 0x16, 0x1D, 0xFF, 0x19, 0x1C, 0x23, 0xFF, 0x0C, 0x0E, 0x1A, 0xFF, 0x11, 0x13, 0x1F, 0xFF,
0x1A, 0x1A, 0x24, 0xFF, 0x07, 0x06, 0x0E, 0xFF, 0x31, 0x32, 0x37, 0xFF, 0xC4, 0xC5, 0xC9, 0xFF,
0xC1, 0xC2, 0xBA, 0xFF, 0xB9, 0xBA, 0xB2, 0xFF, 0xC5, 0xC4, 0xBF, 0xFF, 0xBB, 0xBA, 0xB5, 0xFF,
0xCD, 0xCC, 0xCA, 0xFF, 0x63, 0x61, 0x62, 0xFF, 0x00, 0x00, 0x02, 0xFF, 0x17, 0x18, 0x1D, 0xFF,
0x1A, 0x1A, 0x22, 0xFF, 0x15, 0x17, 0x23, 0xFF, 0x15, 0x19, 0x25, 0xFF, 0x12, 0x16, 0x22, 0xFF,
0x11, 0x13, 0x1F, 0xFF, 0x16, 0x18, 0x24, 0xFF, 0x17, 0x1A, 0x23, 0xFF, 0x12, 0x15, 0x1E, 0xFF,
0x14, 0x17, 0x1E, 0xFF, 0x13, 0x18, 0x1E, 0xFF, 0x0F, 0x12, 0x1B, 0xFF, 0x0D, 0x0D, 0x17, 0xFF,
0x16, 0x15, 0x1D, 0xFF, 0x17, 0x14, 0x1B, 0xFF, 0x0A, 0x09, 0x0E, 0xFF, 0xB9, 0xBA, 0xBE, 0xFF,
0xBD, 0xBE, 0xB6, 0xFF, 0xBE, 0xBF, 0xB7, 0xFF, 0xC1, 0xC0, 0xBB, 0xFF, 0xB8, 0xB7, 0xB2, 0xFF,
0xCC, 0xCB, 0xC7, 0xFF, 0x54, 0x52, 0x53, 0xFF, 0x04, 0x04, 0x06, 0xFF, 0x10, 0x11, 0x16, 0xFF,
0x10, 0x10, 0x18, 0xFF, 0x14, 0x17, 0x20, 0xFF, 0x16, 0x1A, 0x25, 0xFF, 0x14, 0x18, 0x24, 0xFF,
0x12, 0x14, 0x20, 0xFF, 0x12, 0x14, 0x20, 0xFF, 0x15, 0x18, 0x21, 0xFF, 0x13, 0x16, 0x1D, 0xFF,
0x14, 0x19, 0x1F, 0xFF, 0x12, 0x17, 0x1B, 0xFF, 0x0C, 0x0F, 0x16, 0xFF, 0x13, 0x14, 0x19, 0xFF,
0x1E, 0x19, 0x1D, 0xFF, 0x1D, 0x18, 0x1C, 0xFF, 0x00, 0x00, 0x04, 0xFF, 0x71, 0x72, 0x76, 0xFF,
0xC0, 0xC1, 0xB9, 0xFF, 0xBF, 0xC0, 0xB8, 0xFF, 0xBD, 0xBC, 0xB7, 0xFF, 0xB5, 0xB4, 0xAF, 0xFF,
0xC7, 0xC6, 0xC2, 0xFF, 0x56, 0x55, 0x53, 0xFF, 0x00, 0x00, 0x02, 0xFF, 0x15, 0x16, 0x1B, 0xFF,
0x14, 0x14, 0x1C, 0xFF, 0x18, 0x1B, 0x24, 0xFF, 0x10, 0x14, 0x1F, 0xFF, 0x14, 0x18, 0x23, 0xFF,
0x17, 0x19, 0x25, 0xFF, 0x10, 0x12, 0x1E, 0xFF, 0x14, 0x17, 0x20, 0xFF, 0x14, 0x17, 0x1E, 0xFF,
0x10, 0x15, 0x1B, 0xFF, 0x10, 0x15, 0x19, 0xFF, 0x0C, 0x0F, 0x14, 0xFF, 0x0A, 0x0A, 0x0C, 0xFF,
0x0C, 0x03, 0x04, 0xFF, 0x14, 0x0B, 0x0C, 0xFF, 0x0C, 0x0A, 0x0D, 0xFF, 0x79, 0x78, 0x7D, 0xFF,
0xBB, 0xBC, 0xB4, 0xFF, 0xBC, 0xBD, 0xB5, 0xFF, 0xBC, 0xBB, 0xB6, 0xFF, 0xB6, 0xB5, 0xB0, 0xFF,
0xCC, 0xCB, 0xC7, 0xFF, 0x52, 0x51, 0x4F, 0xFF, 0x04, 0x02, 0x05, 0xFF, 0x16, 0x15, 0x1A, 0xFF,
0x11, 0x11, 0x19, 0xFF, 0x17, 0x1A, 0x23, 0xFF, 0x12, 0x14, 0x20, 0xFF, 0x11, 0x15, 0x20, 0xFF,
0x15, 0x17, 0x23, 0xFF, 0x14, 0x16, 0x22, 0xFF, 0x16, 0x19, 0x22, 0xFF, 0x12, 0x15, 0x1E, 0xFF,
0x10, 0x15, 0x1B, 0xFF, 0x15, 0x18, 0x1D, 0xFF, 0x19, 0x1A, 0x1E, 0xFF, 0x28, 0x24, 0x25, 0xFF,
0x73, 0x65, 0x62, 0xFF, 0x8A, 0x7C, 0x79, 0xFF, 0x55, 0x4F, 0x51, 0xFF, 0x4E, 0x4C, 0x51, 0xFF,
0xB9, 0xBA, 0xB4, 0xFF, 0xC2, 0xC3, 0xBD, 0xFF, 0xBC, 0xBB, 0xB6, 0xFF, 0xAE, 0xAD, 0xA8, 0xFF,
0xC2, 0xBE, 0xBB, 0xFF, 0x3E, 0x3D, 0x3B, 0xFF, 0x07, 0x05, 0x06, 0xFF, 0x07, 0x06, 0x0B, 0xFF,
0x0D, 0x0D, 0x15, 0xFF, 0x0C, 0x0F, 0x18, 0xFF, 0x18, 0x1A, 0x26, 0xFF, 0x16, 0x18, 0x24, 0xFF,
0x10, 0x12, 0x1E, 0xFF, 0x14, 0x16, 0x22, 0xFF, 0x15, 0x18, 0x21, 0xFF, 0x14, 0x17, 0x20, 0xFF,
0x11, 0x16, 0x1C, 0xFF, 0x11, 0x14, 0x19, 0xFF, 0x0B, 0x0B, 0x0D, 0xFF, 0x3F, 0x37, 0x35, 0xFF,
0xA4, 0x91, 0x8B, 0xFF, 0x91, 0x7E, 0x78, 0xFF, 0x69, 0x5F, 0x60, 0xFF, 0x5E, 0x59, 0x5D, 0xFF,
0xBA, 0xBB, 0xB5, 0xFF, 0xB9, 0xBA, 0xB4, 0xFF, 0xBA, 0xB9, 0xB4, 0xFF, 0xB2, 0xB1, 0xAC, 0xFF,
0xAB, 0xA7, 0xA4, 0xFF, 0x8D, 0x89, 0x88, 0xFF, 0x3E, 0x3C, 0x3D, 0xFF, 0x6E, 0x6D, 0x72, 0xFF,
0x41, 0x40, 0x46, 0xFF, 0x14, 0x14, 0x1C, 0xFF, 0x13, 0x15, 0x21, 0xFF, 0x16, 0x18, 0x24, 0xFF,
0x11, 0x13, 0x1F, 0xFF, 0x16, 0x18, 0x24, 0xFF, 0x11, 0x14, 0x1D, 0xFF, 0x16, 0x19, 0x22, 0xFF,
0x15, 0x1A, 0x20, 0xFF, 0x11, 0x14, 0x19, 0xFF, 0x10, 0x10, 0x12, 0xFF, 0x2B, 0x23, 0x20, 0xFF,
0x7E, 0x67, 0x61, 0xFF, 0x85, 0x6E, 0x68, 0xFF, 0x6B, 0x5F, 0x5F, 0xFF, 0xCB, 0xC5, 0xC9, 0xFF
};

c++ Decrypting msg from game client

i made a socket that accepting connection from a game , in the game u should type in username and password , i can recive it bt , it's like ummmm encrypted letteers and numbers(”VeDbç)
3¥ثuo_‰°"“Fِمض)
my question is where to look at so i can understand how to deal with this prob , is there a tut. or hint or somthing that i can work on so i can reach what am looking for!?
thanks.
unsigned char* Key3;
unsigned char* Key4;
unsigned char Low;
unsigned char High;
const unsigned char Key1[] =
{
0x9D, 0x90, 0x83, 0x8A, 0xD1, 0x8C, 0xE7, 0xF6, 0x25, 0x28, 0xEB, 0x82, 0x99, 0x64, 0x8F, 0x2E,
0x2D, 0x40, 0xD3, 0xFA, 0xE1, 0xBC, 0xB7, 0xE6, 0xB5, 0xD8, 0x3B, 0xF2, 0xA9, 0x94, 0x5F, 0x1E,
0xBD, 0xF0, 0x23, 0x6A, 0xF1, 0xEC, 0x87, 0xD6, 0x45, 0x88, 0x8B, 0x62, 0xB9, 0xC4, 0x2F, 0x0E,
0x4D, 0xA0, 0x73, 0xDA, 0x01, 0x1C, 0x57, 0xC6, 0xD5, 0x38, 0xDB, 0xD2, 0xC9, 0xF4, 0xFF, 0xFE,
0xDD, 0x50, 0xC3, 0x4A, 0x11, 0x4C, 0x27, 0xB6, 0x65, 0xE8, 0x2B, 0x42, 0xD9, 0x24, 0xCF, 0xEE,
0x6D, 0x00, 0x13, 0xBA, 0x21, 0x7C, 0xF7, 0xA6, 0xF5, 0x98, 0x7B, 0xB2, 0xE9, 0x54, 0x9F, 0xDE,
0xFD, 0xB0, 0x63, 0x2A, 0x31, 0xAC, 0xC7, 0x96, 0x85, 0x48, 0xCB, 0x22, 0xF9, 0x84, 0x6F, 0xCE,
0x8D, 0x60, 0xB3, 0x9A, 0x41, 0xDC, 0x97, 0x86, 0x15, 0xF8, 0x1B, 0x92, 0x09, 0xB4, 0x3F, 0xBE,
0x1D, 0x10, 0x03, 0x0A, 0x51, 0x0C, 0x67, 0x76, 0xA5, 0xA8, 0x6B, 0x02, 0x19, 0xE4, 0x0F, 0xAE,
0xAD, 0xC0, 0x53, 0x7A, 0x61, 0x3C, 0x37, 0x66, 0x35, 0x58, 0xBB, 0x72, 0x29, 0x14, 0xDF, 0x9E,
0x3D, 0x70, 0xA3, 0xEA, 0x71, 0x6C, 0x07, 0x56, 0xC5, 0x08, 0x0B, 0xE2, 0x39, 0x44, 0xAF, 0x8E,
0xCD, 0x20, 0xF3, 0x5A, 0x81, 0x9C, 0xD7, 0x46, 0x55, 0xB8, 0x5B, 0x52, 0x49, 0x74, 0x7F, 0x7E,
0x5D, 0xD0, 0x43, 0xCA, 0x91, 0xCC, 0xA7, 0x36, 0xE5, 0x68, 0xAB, 0xC2, 0x59, 0xA4, 0x4F, 0x6E,
0xED, 0x80, 0x93, 0x3A, 0xA1, 0xFC, 0x77, 0x26, 0x75, 0x18, 0xFB, 0x32, 0x69, 0xD4, 0x1F, 0x5E,
0x7D, 0x30, 0xE3, 0xAA, 0xB1, 0x2C, 0x47, 0x16, 0x05, 0xC8, 0x4B, 0xA2, 0x79, 0x04, 0xEF, 0x4E,
0x0D, 0xE0, 0x33, 0x1A, 0xC1, 0x5C, 0x17, 0x06, 0x95, 0x78, 0x9B, 0x12, 0x89, 0x34, 0xBF, 0x3E
};
const unsigned char Key2[] =
{
0x62, 0x4F, 0xE8, 0x15, 0xDE, 0xEB, 0x04, 0x91, 0x1A, 0xC7, 0xE0, 0x4D, 0x16, 0xE3, 0x7C, 0x49,
0xD2, 0x3F, 0xD8, 0x85, 0x4E, 0xDB, 0xF4, 0x01, 0x8A, 0xB7, 0xD0, 0xBD, 0x86, 0xD3, 0x6C, 0xB9,
0x42, 0x2F, 0xC8, 0xF5, 0xBE, 0xCB, 0xE4, 0x71, 0xFA, 0xA7, 0xC0, 0x2D, 0xF6, 0xC3, 0x5C, 0x29,
0xB2, 0x1F, 0xB8, 0x65, 0x2E, 0xBB, 0xD4, 0xE1, 0x6A, 0x97, 0xB0, 0x9D, 0x66, 0xB3, 0x4C, 0x99,
0x22, 0x0F, 0xA8, 0xD5, 0x9E, 0xAB, 0xC4, 0x51, 0xDA, 0x87, 0xA0, 0x0D, 0xD6, 0xA3, 0x3C, 0x09,
0x92, 0xFF, 0x98, 0x45, 0x0E, 0x9B, 0xB4, 0xC1, 0x4A, 0x77, 0x90, 0x7D, 0x46, 0x93, 0x2C, 0x79,
0x02, 0xEF, 0x88, 0xB5, 0x7E, 0x8B, 0xA4, 0x31, 0xBA, 0x67, 0x80, 0xED, 0xB6, 0x83, 0x1C, 0xE9,
0x72, 0xDF, 0x78, 0x25, 0xEE, 0x7B, 0x94, 0xA1, 0x2A, 0x57, 0x70, 0x5D, 0x26, 0x73, 0x0C, 0x59,
0xE2, 0xCF, 0x68, 0x95, 0x5E, 0x6B, 0x84, 0x11, 0x9A, 0x47, 0x60, 0xCD, 0x96, 0x63, 0xFC, 0xC9,
0x52, 0xBF, 0x58, 0x05, 0xCE, 0x5B, 0x74, 0x81, 0x0A, 0x37, 0x50, 0x3D, 0x06, 0x53, 0xEC, 0x39,
0xC2, 0xAF, 0x48, 0x75, 0x3E, 0x4B, 0x64, 0xF1, 0x7A, 0x27, 0x40, 0xAD, 0x76, 0x43, 0xDC, 0xA9,
0x32, 0x9F, 0x38, 0xE5, 0xAE, 0x3B, 0x54, 0x61, 0xEA, 0x17, 0x30, 0x1D, 0xE6, 0x33, 0xCC, 0x19,
0xA2, 0x8F, 0x28, 0x55, 0x1E, 0x2B, 0x44, 0xD1, 0x5A, 0x07, 0x20, 0x8D, 0x56, 0x23, 0xBC, 0x89,
0x12, 0x7F, 0x18, 0xC5, 0x8E, 0x1B, 0x34, 0x41, 0xCA, 0xF7, 0x10, 0xFD, 0xC6, 0x13, 0xAC, 0xF9,
0x82, 0x6F, 0x08, 0x35, 0xFE, 0x0B, 0x24, 0xB1, 0x3A, 0xE7, 0x00, 0x6D, 0x36, 0x03, 0x9C, 0x69,
0xF2, 0x5F, 0xF8, 0xA5, 0x6E, 0xFB, 0x14, 0x21, 0xAA, 0xD7, 0xF0, 0xDD, 0xA6, 0xF3, 0x8C, 0xD9
};
// Decrypt Function
void CAuthCryptography::Decrypt(void* in, void* out, int Length)
{
unsigned char* pIn = (unsigned char*)in;
unsigned char* pOut = (unsigned char*)out;
for (int i = 0; i < Length; i++)
{
pOut[i] = (unsigned char)(pIn[i] ^ 0xAB);
pOut[i] = (unsigned char)((pOut[i] << 4) | (pOut[i] >> 4));
if (UsingAlternate)
{
pOut[i] = (unsigned char)(Key4[In.High] ^ pOut[i]);
pOut[i] = (unsigned char)(Key3[In.Low] ^ pOut[i]);
}
else
{
pOut[i] = (unsigned char)(Key2[In.High] ^ pOut[i]);
pOut[i] = (unsigned char)(Key1[In.Low] ^ pOut[i]);
}
In.Counter++;
}
}
i got this code and it's working but can someone explain to me how it's working becuase i dont understand it?!
or if there is a tut. i can read or something

I suggest you use something like WireShark, tcpdump etc to view the TCP stream, just to make sure you haven't bodged up your tcp data-reading code. More generally, if you are getting data like that, then only the sending side will know why, and you either ask them or look at how that data is handled by some other receiving program they've made (i.e. debug another client, find out what it does with that mess).

When it really is encrypted, your chances are low.
But chances are it's just UTF-7 or UTF-8 encoded, not encrypted.
And if it is SSL on a non-standard port, use oSpy.