This course will introduce you to Ruby, as well as teach you about classes, methods, variables, data structures, loops, enumerable methods, and finishing touches.
CONST CHAR* buf TO BYTE*!
I am trying to do a cryptography, but to no avail .... the code does not compile. How do I convert const char * buf to BYTE? Or is there another way?
i call crypto here:
return this error:
I cannot seem to adapt this... please help me :(
#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");
}
i call crypto here:
void process_send(SOCKET s, const char* buf, int *len, int flags) {
unsigned int command = (*(unsigned short*)buf);
process_data(ENCRYPT, server_keys, buf, buf,*len);
}
}
return this error:
Error 1 error C2664: 'process_data' : cannot convert parameter 3 from 'const char *' to 'BYTE *'
I cannot seem to adapt this... please help me :(
Who is Participating?
Experts Exchange Solution brought to you by
Enjoy your complimentary solution view.
Get every solution instantly with Premium.
Start your 7-day free trial.
I wear a lot of hats...
"The solutions and answers provided on Experts Exchange have been extremely helpful to me over the last few years. I wear a lot of hats - Developer, Database Administrator, Help Desk, etc., so I know a lot of things but not a lot about one thing. Experts Exchange gives me answers from people who do know a lot about one thing, in a easy to use platform." -Todd S.
Yes, this error is correct, the buf passed to the function is a const char *, in words this means it's a pointer to const char, so the compiler has to throw an error in case the type is (implicit) changed to a none-const type.
This is good and correct, because when I call a function and pass a string to it I usually expect the string stays unchanged. Further there are cases where changing such a const char can lead to crash, i.e. when such a pointer is initialized using a string literal, i.e.:
This even demonstrates that just casting away the const is not a good idea.
A type-safe solution would be to remove the const from the function declaration:
Const-ness is an important aspect in C/C++ and should always be considered.
Hope that helps,
ZOPPO
This is good and correct, because when I call a function and pass a string to it I usually expect the string stays unchanged. Further there are cases where changing such a const char can lead to crash, i.e. when such a pointer is initialized using a string literal, i.e.:
const char* p = "hello world.";
char* p1 = (char*)p; // cast the 'const' away
p1[0] = 'H'
This even demonstrates that just casting away the const is not a good idea.
A type-safe solution would be to remove the const from the function declaration:
void process_send(SOCKET s, char* buf, int *len, int flags) { ... }
Const-ness is an important aspect in C/C++ and should always be considered.
Hope that helps,
ZOPPO
Hey Zoppo, i changed my cod to
How can I convert from char* to BYTE*?
void process_send(SOCKET s, char* buf, int *len, int flags) {
How can I convert from char* to BYTE*?
typedef unsigned char BYTE;
void myFunction(BYTE* in, size_t length);
/////////// MAIN ///////////
int main()
{
char data[10];
myFunction((BYTE*)data, 10);
return 0;
}
void myFunction(BYTE* in, size_t length)
{
}
>> How can I convert from char* to BYTE*?
You can simply cast is, i.e.:
char* text = strdup( "Hello world." );
BYTE* data = (BYTE*)text;
BTW: Just for interest I'd like to ask if there is any reason why you don't use any C++ functionality? Except the leading #include <cdstdio> everything seems to be pure C. Therefor I wrote the code I posted above in the same way, but the complete problem could probably be solved better/nicer/safer when using standard C++ functionalities and STL.
Best regards,
ZOPPO
You can simply cast is, i.e.:
char* text = strdup( "Hello world." );
BYTE* data = (BYTE*)text;
BTW: Just for interest I'd like to ask if there is any reason why you don't use any C++ functionality? Except the leading #include <cdstdio> everything seems to be pure C. Therefor I wrote the code I posted above in the same way, but the complete problem could probably be solved better/nicer/safer when using standard C++ functionalities and STL.
Best regards,
ZOPPO
never use those jurrassic C-Style arrays in C++.that is not true in general. for example there is no better way in c++ to initialize arrays with plain data like the crypto tables but to use c arrays.
and if those arrays are constant there is no reason to convert to std::array or std::vector.
if you need to change values you can combine both:
static BYTE keys[] = { 0x12, 0x34, 0xab, 0x00, ... };
static size_t NUMKEYS = sizeof(keys)/sizeof(keys[0]));
std::vector<BYTE> vkeys(&keys[0], &keys[NUMKEYS]);
here the vkeys uses the fact that pointers to plain c arrays can be used as iterators for to copy the static data ino dynamic c++ template arrays.
Sara
but the complete problem could probably be solved better/nicer/safer when using standard C++ functionalities and STL.
the sample code is too short to decide whether c++ classes and STL give advantage. for example socket programming is highly made in c and using c++ types would require mcuh more efforts to convert from c++ to c types and reverse as if all is done with c types. that must not mean that you would use the ansi c compiler but simply use c++ where it fits better and use c where you have to provide data for a c interface.
Sara
void process_send(SOCKET s, char* buf, int *len, int flags) {
How can I convert from char* to BYTE*?
as Zoppo showed in his sample code you simply could cast the char* to BYTE* because char size is 1 byte same as BYTE which is typedef'd as
typedef unsigned char BYTE;
i. e. a BYTE simply is an unsigned char what is an 8-bit unsigned integer (range 0 to 255) while char can be used as a signed 8-bit integer (if not used for text) where the highest bit (bit 7) is used as sign bit and the range is from -128 to +127.
void process_send(SOCKET s, char* buf, int *len, int flags)
{
BYTE * pbuf = (BYTE*)buf;
// now pbuf can be used wherever a writeable BYTE array was required
// alternatively use buf if a char* or const char* is required
// not 'len' should be the size of the buffer and not the length of any text within the buffer
...
Sara
Allow me to disagree:never use those jurrassic C-Style arrays in C++.that is not true in general. for example there is no better way in c++ to initialize arrays with plain data like the crypto tables but to use c arrays.
#include <iostream>
#include <array>
#include <vector>
int main()
{
std::array<char, 5> data_1{'a', 'b', 'c', 'd', 'e'};
std::vector<char> data_2{'f', 'g', 'h', 'i', 'j'};
for(auto item: data_1)
std::cout << item;
std::cout << std::endl;
for(auto item: data_2)
std::cout << item;
std::cout << std::endl;
std::cin.get();
return 0;
}
As for giving the array (or vector) as parameters to C function, the data() member function exist for that purpose.
Plus, functions can return STL container objects (like almost any object).
Experts Exchange Solution brought to you by
Your issues matter to us.
Facing a tech roadblock? Get the help and guidance you need from experienced professionals who care. Ask your question anytime, anywhere, with no hassle.
Start your 7-day free trial
the code you posted is c++-11 extension where you cannot rely on that it was available at the user's environment.
the initialization of c structures and arrays also would work for 2d and 3 d arrays and for complex and even nested structures.
you may try to initialize a std::array as it was done iin the original posted code for variable
i personally don't use c++-11 enhancements (so it could well be that i am wrong) but have doubts that they are as mighty as c initializations.
Sara
the initialization of c structures and arrays also would work for 2d and 3 d arrays and for complex and even nested structures.
you may try to initialize a std::array as it was done iin the original posted code for variable
BYTE server_keys[2][256]
i personally don't use c++-11 enhancements (so it could well be that i am wrong) but have doubts that they are as mighty as c initializations.
Sara
It's more than this solution.Get answers and train to solve all your tech problems - anytime, anywhere.Try it for free Edge Out The Competitionfor your dream job with proven skills and certifications.Get started today Stand Outas the employee with proven skills.Start learning today for free Move Your Career Forwardwith certification training in the latest technologies.Start your trial today
System Programming
From novice to tech pro — start learning today.
-
Microsoft ApplicationsCertification: MOS Microsoft Office Specialist - Word 2016 Part … 174 lessons
Experts Exchange Solution brought to you by
Enjoy your complimentary solution view.
Get every solution instantly with Premium.
Start your 7-day free trial.
The type std::array exist for a reason, and is more safe, less error prone and don't decay to troublemaking raw pointers.
Concerning your issue:
Did you try static_cast ?