static int lua_create_lua_msg(lua_State* state)
{
int sockfd = lua_tointeger(state, 1);
size_t len;
const char *str = lua_tolstring(state, 2, &len);
#if ENABLE_XXTEA_ZLIB
xxtea_long xxlen = 0;
unsigned char* xxresult = xxtea_encrypt((unsigned char*)str, len, (unsigned char*)xxtea_key, strlen(xxtea_key), &xxlen);
uLong buf_len = MAX_LUA_MSG_LEN;
compress((Bytef*)msg_buf, &buf_len, (Bytef*)xxresult, xxlen);
#if 0
printf("---- buf_len: %d\n", buf_len);
printf("---- sizeof(msg_buf): %d\n", sizeof(msg_buf));
printf("---- sockfd: %p\n", sockfd);
printf("---- sock: %p\n", g_sock_fd_map[sockfd]);
printf("---- epoll_idx: %d\n", g_sock_fd_map[sockfd]->epoll_idx);
printf("---- luamsg_sending: %p\n", g_workers[g_sock_fd_map[sockfd]->epoll_idx].luamsg_sending);
#endif
g_workers[g_sock_fd_map[sockfd]->epoll_idx].luamsg_sending = create_lua_msg(msg_buf, buf_len);
free(xxresult);
#else
g_workers[g_sock_fd_map[sockfd]->epoll_idx].luamsg_sending = create_lua_msg(str, len);
#endif
return 1;
}
unsigned char *EncryptXXTea::decode()
{
UserData user_d = {10,20,30};
unsigned char *t_data = (unsigned char *)&user_d;
const char *key_s = "YuanfeiTestXXTea";
xxtea_long key_len = strlen(key_s);
xxtea_long ret_len;
unsigned char *bufs=xxtea_encrypt(t_data, sizeof(UserData), (unsigned char*)key_s, key_len, &ret_len);
char t_buf[512];
memset(&t_buf, 0, 512);
memcpy(&t_buf, bufs, ret_len+1);
key_s = "YuanfeiTestXXTea";
key_len = strlen(key_s);
xxtea_long de_len;
unsigned char *de_data=xxtea_decrypt(bufs, ret_len, (unsigned char*)key_s, key_len, &de_len);
memset(&t_buf, 0, 512);
memcpy(&t_buf, de_data, ret_len+1);
UserData decod;
memset(&decod, 0, sizeof(UserData));
memcpy(&decod, de_data, sizeof(UserData));
return nullptr;
}
String xxtea_c::encrypt(String data)
{
// Works only if the Key in setup
if(this->keyset && data.length() != 0)
{
// If the Data within the limits of the Engine
if(data.length() < MAX_XXTEA_DATA8)
{
size_t len;
// Assign the Maximum buffer we have
len = MAX_XXTEA_DATA8;
// Perform Encryption
if(xxtea_encrypt((uint8_t *)data.c_str(),data.length(),
this->data,&len) == XXTEA_STATUS_SUCCESS)
{
String result;
size_t i;
result.reserve(len*2 + 1);
result = "";
for(i=0;i<len;i++)
{
result+=tohex((this->data[i] >> 4) & 0x0F);
result+=tohex(this->data[i] & 0x0F);
}
return result;
}
}
unsigned char* CACrypto::encryptXXTEA(unsigned char* plaintext,
int plaintextLength,
unsigned char* key,
int keyLength,
int* resultLength)
{
xxtea_long len;
unsigned char* result = xxtea_encrypt(plaintext, (xxtea_long)plaintextLength, key, (xxtea_long)keyLength, &len);
*resultLength = (int)len;
return result;
}
//1v1
void CClientSocket::SendFoOne2One(char * bufSend, DWORD dwLen)
{
CHATSEND ct = { ONE2ONE };
char fid[BUFNAME] = {};
_itoa_s(dwLen, fid, 20, 10);
memcpy_s(ct.m_content.o2o.szUid, strlen(m_szUID), m_szUID, strlen(m_szUID));
memcpy_s(ct.m_content.o2o.szFid, strlen(fid), fid, strlen(fid));
memcpy_s(ct.m_content.o2o.szUname, strlen(m_szName), m_szName, strlen(m_szName));
//加密聊天信息
string Content = bufSend;
string key = m_szUID;
string cipherText = xxtea_encrypt(Content, key);
memcpy_s(ct.m_content.o2o.szContent, cipherText.length(), cipherText.c_str(), cipherText.length());
send(m_sClient, (char *)&ct, sizeof(ct), NULL);
}
int main() {
const char *text = "Hello World! 你好，中国！";
const char *key = "1234567890";
size_t len;
unsigned char *encrypt_data = xxtea_encrypt(text, strlen(text), key, &len);
char * base64_data = base64_encode(encrypt_data, len);
printf("%s\n", base64_data);
char *decrypt_data = xxtea_decrypt(encrypt_data, len, key, &len);
if (strncmp(text, decrypt_data, len) == 0) {
printf("success!\n");
}
else {
printf("fail!\n");
}
free(encrypt_data);
free(decrypt_data);
free(base64_data);
return 0;
}
SSAPMessage KPMqtt::sendEncrypt(char* msgJson, unsigned char* key, int keyLength){
//The server does not need a topic
//char* msgJson=msg->toJson();
//Serial.println(msgJson);
xxtea_long len=strlen(msgJson);
xxtea_long encryptedLength=0;
unsigned char *result=new unsigned char[690];
//Serial.println("Antes de encriptar");
unsigned char* encryptedMsg = xxtea_encrypt((unsigned char *)msgJson, len, key, keyLength, &encryptedLength, result);
//Serial.print("Despues de encriptar, Longitud: ");
//Serial.println(encryptedLength);
//Codificado en Base64, ya no es necesario con los cambios hechos en la libreria
delete[] msgJson;
//Serial.print("Memoria antes de codificar a base64: ");
//Serial.println(memoryTest());
char* encodedOutput=new char[690];
int codedLength = base64_encode(encodedOutput, reinterpret_cast<char*>(encryptedMsg), encryptedLength);
//Serial.println("Despues de codificar, Longitud: ");
//Serial.println(codedLength);
//Serial.print("Memoria despues de codificar a base64: ");
//Serial.println(memoryTest());
delete[] encryptedMsg;
char* adjustedEncodedOutput=new char[codedLength+1];
for(int i=0;i<codedLength;i++){
adjustedEncodedOutput[i]=encodedOutput[i];
}
adjustedEncodedOutput[codedLength]='\0';
delete[] encodedOutput;
//Serial.println("Antes de publicar");
client.publish("", (uint8_t*)adjustedEncodedOutput, codedLength, false);
//Serial.println("Despues de publicar");
delete[] adjustedEncodedOutput;
publishResponse=NULL;
for(int i=0; i<MAX_RESPONSE_LOOP_RETRIES && publishResponse==NULL;i++){
delay(1000);
client.loop();
//Serial.println("Esperando respuesta");
}
//Serial.println("Antes de comprobar el nulo:");
//Serial.println(publishResponse);
//Hasta aqui no se pierde memoria en memory leaks
if(publishResponse!=NULL){
char* decodedOutput=new char[690];
int decodedLenght = base64_decode(decodedOutput, publishResponse, strlen(publishResponse));
delete[] publishResponse;
Serial.print("Longitud decodificado");
Serial.println(decodedLenght);
Serial.println("##################################");
unsigned char* adjustedDecodedOutput=new unsigned char[decodedLenght];
for(int i=0;i<decodedLenght;i++){
adjustedDecodedOutput[i]=(unsigned char)decodedOutput[i];
Serial.print((int) adjustedDecodedOutput[i]);
}
Serial.println("\n##################################");
delete[] decodedOutput;
xxtea_long *ret_len;
Serial.println("Antes de descifrar");
//intentar eso, pasar el argumento del resultado por parametros, y que se declare antes para que no lo haga el malloc
unsigned char *result2=new unsigned char[690];
unsigned char * decryptedMsg = xxtea_decrypt(adjustedDecodedOutput, decodedLenght, key, keyLength, ret_len, result2);
/*Serial.println("Parte del desencriptado");
for(int i=0;i<100;i++){
Serial.print((char)result2[i]);
}
Serial.println("Parte del desencriptado");*/
/* Serial.println("Despues de descifrar");
Serial.println("Longitud Respuesta descifrada: ");
Serial.println((int)ret_len);
Serial.println("Respuesta descifrada: ");
Serial.println((char*)decryptedMsg);
delete[] adjustedDecodedOutput;*/
/*
SSAPMessage response = SSAPMessage::fromJSonToSSAPMessage((char*)decryptedMsg);
delete[] decryptedMsg;
if(response.getMessageType()==JOIN){
char* responseBody=response.getBody();//Body lo borro en la funcion principal del programa
SSAPBodyReturnMessage bodyMessage=SSAPBodyReturnMessage::fromJSonToSSAPMessage(responseBody);
if(bodyMessage.isOk()){
delete[] sessionKey;
sessionKey=new char[strlen(bodyMessage.getData())+1];
strcpy(sessionKey, bodyMessage.getData());
}
delete[] bodyMessage.getData();
delete[] bodyMessage.getError();
}
return response;*/
}
}
