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;
}
extern Data xxtea_file_get_data(const std::string& filename)
{
Data data = FileUtils::getInstance()->getDataFromFile(filename);
if (!data.isNull())
{
bool isXXTEA = true;
unsigned char *buf = data.getBytes();
ssize_t size = data.getSize();
for (int i = 0; isXXTEA && i<xxteaSignLen && i<size; ++i)
{
isXXTEA = buf[i] == xxteaSign[i];
}
if (isXXTEA)
{ // decrypt XXTEA
xxtea_long len = 0;
unsigned char* buffer = xxtea_decrypt(
buf + xxteaSignLen,
(xxtea_long)size - (xxtea_long)xxteaSignLen,
(unsigned char*)xxteaKey.c_str(),
(xxtea_long)xxteaKeyLen,
&len);
data.clear();
data.fastSet(buffer, len);
}
}
return data;
}
unsigned char* CACrypto::decryptXXTEA(unsigned char* ciphertext,
int ciphertextLength,
unsigned char* key,
int keyLength,
int* resultLength)
{
xxtea_long len;
unsigned char* result = xxtea_decrypt(ciphertext, (xxtea_long)ciphertextLength, key, (xxtea_long)keyLength, &len);
*resultLength = (int)len;
return result;
}
unsigned char* HelperFunc::getFileData(const char* pszFileName, const char* pszMode, unsigned long * pSize)
{
ssize_t size;
unsigned char* buf = FileUtils::getInstance()->getFileData(pszFileName, pszMode, &size);
if (NULL==buf || size<1) return NULL;
#ifdef LUASTACK_USED_FOR_QUICK_COCOS2DX
LuaStack* stack = LuaEngine::getInstance()->getLuaStack();
if (NULL==stack) {
return NULL;
}
int xxteaKeyLen = 0;
const char *xxteaKey = stack->getXXTEAKey(&xxteaKeyLen);
int xxteaSignLen = 0;
const char *xxteaSign = stack->getXXTEASign(&xxteaSignLen);
unsigned char* buffer = NULL;
if (xxteaKey && xxteaSign) {
bool isXXTEA = true;
for (int i = 0; isXXTEA && i<xxteaSignLen && i<size; ++i) {
isXXTEA = buf[i] == xxteaSign[i];
}
if (isXXTEA) { // decrypt XXTEA
xxtea_long len = 0;
buffer = xxtea_decrypt(
buf + xxteaSignLen,
(xxtea_long)size - (xxtea_long)xxteaSignLen,
(unsigned char*)xxteaKey,
(xxtea_long)xxteaKeyLen,
&len);
delete []buf;
buf = NULL;
size = len;
} else {
buffer = buf;
}
}
else {
buffer = buf;
}
if (pSize) *pSize = size;
return buffer;
#else
if (pSize) *pSize = size;
return buf;
#endif
}
bool lua_msg_handler(lua_State *state, SockMsg* msg)
{
int functionIndex = -3;
Worker *worker = &g_workers[msg->sock->epoll_idx];
lua_getglobal(worker->state, worker->msg_handler);
lua_pushinteger(state, (int)msg->sock->fd);
#if ENABLE_XXTEA_ZLIB
uLong buf_len = MAX_LUA_MSG_LEN;
uncompress((Bytef*)msg_buf, &buf_len, (Bytef*)MSG_MSG(msg), MSG_LEN(msg));
xxtea_long xxlen = 0;
char* xxresult = (char*)xxtea_decrypt((unsigned char*)msg_buf, buf_len, (unsigned char*)xxtea_key, strlen(xxtea_key), &xxlen);
lua_pushlstring(state, xxresult, xxlen);
free(xxresult);
#else
//printf("lua_msg_handler: %d %s\n", MSG_MSG(msg), MSG_LEN(msg));
lua_pushlstring(state, MSG_MSG(msg), MSG_LEN(msg));
#endif
int traceback = 0;
lua_getglobal(worker->state, worker->trace_handler);
if (!lua_isfunction(worker->state, -1))
{
lua_pop(worker->state, 1); /* L: ... func arg1 arg2 ... */
}
else
{
lua_insert(worker->state, functionIndex - 1); /* L: ... G func arg1 arg2 ... */
traceback = functionIndex - 1;
}
bool ret = lua_pcall(worker->state, 2, 0, traceback);
if(ret != 0)
{
Log();
printf("lua_pcall failed: %s\n", lua_tostring(worker->state, -1));
lua_pop(worker->state, 2);
lua_settop(worker->state, 0);
return false;
}
ret = lua_toboolean(state, -1);
lua_pop(worker->state, 3);
lua_settop(worker->state, 0);
return ret;
}
int LuaStack::luaLoadBuffer(lua_State *L, const char *chunk, int chunkSize, const char *chunkName)
{
int r = 0;
if (_xxteaEnabled && strncmp(chunk, _xxteaSign, _xxteaSignLen) == 0)
{
// decrypt XXTEA
xxtea_long len = 0;
unsigned char* result = xxtea_decrypt((unsigned char*)chunk + _xxteaSignLen,
(xxtea_long)chunkSize - _xxteaSignLen,
(unsigned char*)_xxteaKey,
(xxtea_long)_xxteaKeyLen,
&len);
r = luaL_loadbuffer(L, (char*)result, len, chunkName);
free(result);
}
else
{
r = luaL_loadbuffer(L, chunk, chunkSize, chunkName);
}
#if defined(COCOS2D_DEBUG) && COCOS2D_DEBUG > 0
if (r)
{
switch (r)
{
case LUA_ERRSYNTAX:
CCLOG("[LUA ERROR] load \"%s\", error: syntax error during pre-compilation.", chunkName);
break;
case LUA_ERRMEM:
CCLOG("[LUA ERROR] load \"%s\", error: memory allocation error.", chunkName);
break;
case LUA_ERRFILE:
CCLOG("[LUA ERROR] load \"%s\", error: cannot open/read file.", chunkName);
break;
default:
CCLOG("[LUA ERROR] load \"%s\", error: unknown.", chunkName);
}
}
#endif
return r;
}
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;
}
unsigned char* FileUtils::getDecryptFileData(const char* pszFileName, const char* pszMode, unsigned long * pSize)
{
ssize_t size;
unsigned char* buf = FileUtils::getInstance()->getFileData(pszFileName, pszMode, &size);
if (NULL == buf || size<1) return NULL;
const char *xxteaKey = "ilovecocos2dx";
int xxteaKeyLen = strlen(xxteaKey);
const char *xxteaSign = "XXTEA";
int xxteaSignLen = strlen(xxteaSign);
unsigned char* buffer = NULL;
bool isXXTEA = true;
for (int i = 0; isXXTEA && i<xxteaSignLen && i<size; ++i) {
isXXTEA = buf[i] == xxteaSign[i];
}
if (isXXTEA) { // decrypt XXTEA
xxtea_long len = 0;
buffer = xxtea_decrypt(
buf + xxteaSignLen,
(xxtea_long)size - (xxtea_long)xxteaSignLen,
(unsigned char*)xxteaKey,
(xxtea_long)xxteaKeyLen,
&len);
delete[]buf;
buf = NULL;
size = len;
}
else {
buffer = buf;
}
if (pSize) *pSize = size;
return buffer;
}
unsigned char* CZHelperFunc::getFileData(const char* pszFileName, const char* pszMode, unsigned long * pSize)
{
unsigned long size;
unsigned char* buf = CCFileUtils::sharedFileUtils()->getFileData(pszFileName, pszMode, &size);
if (NULL==buf || size<1) return NULL;
CCLuaStack* stack = CCLuaEngine::defaultEngine()->getLuaStack();
unsigned char* buffer = NULL;
bool isXXTEA = stack && stack->m_xxteaEnabled;
for (unsigned int i = 0; isXXTEA && ((int)i) < stack->m_xxteaSignLen && i < size; ++i)
{
isXXTEA = buf[i] == stack->m_xxteaSign[i];
}
if (isXXTEA)
{
// decrypt XXTEA
xxtea_long len = 0;
buffer = xxtea_decrypt(buf + stack->m_xxteaSignLen,
(xxtea_long)size - (xxtea_long)stack->m_xxteaSignLen,
(unsigned char*)stack->m_xxteaKey,
(xxtea_long)stack->m_xxteaKeyLen,
&len);
delete []buf;
buf = NULL;
size = len;
}
else
{
buffer = buf;
}
if (pSize) *pSize = size;
return buffer;
}
int LuaStack::luaLoadChunksFromZIP(lua_State *L)
{
if (lua_gettop(L) < 1) {
CCLOG("luaLoadChunksFromZIP() - invalid arguments");
return 0;
}
const char *zipFilename = lua_tostring(L, -1);
lua_settop(L, 0);
FileUtils *utils = FileUtils::getInstance();
std::string zipFilePath = utils->fullPathForFilename(zipFilename);
LuaStack *stack = this;
do {
ssize_t size = 0;
void *buffer = nullptr;
unsigned char *zipFileData = utils->getFileData(zipFilePath.c_str(), "rb", &size);
ZipFile *zip = nullptr;
bool isXXTEA = stack && stack->_xxteaEnabled && zipFileData;
for (int i = 0; isXXTEA && i < stack->_xxteaSignLen && i < size; ++i) {
isXXTEA = zipFileData[i] == stack->_xxteaSign[i];
}
if (isXXTEA) { // decrypt XXTEA
xxtea_long len = 0;
buffer = xxtea_decrypt(zipFileData + stack->_xxteaSignLen,
(xxtea_long)size - (xxtea_long)stack->_xxteaSignLen,
(unsigned char*)stack->_xxteaKey,
(xxtea_long)stack->_xxteaKeyLen,
&len);
free(zipFileData);
zipFileData = nullptr;
zip = ZipFile::createWithBuffer(buffer, len);
} else {
if (zipFileData) {
zip = ZipFile::createWithBuffer(zipFileData, size);
}
}
if (zip) {
CCLOG("lua_loadChunksFromZIP() - load zip file: %s%s", zipFilePath.c_str(), isXXTEA ? "*" : "");
lua_getglobal(L, "package");
lua_getfield(L, -1, "preload");
int count = 0;
std::string filename = zip->getFirstFilename();
while (filename.length()) {
ssize_t bufferSize = 0;
unsigned char *zbuffer = zip->getFileData(filename.c_str(), &bufferSize);
if (bufferSize) {
// remove extension
std::size_t found = filename.rfind(".lua");
if (found != std::string::npos)
{
filename.erase(found);
}
// replace path seperator '/' '\' to '.'
for (int i=0; i<filename.size(); i++) {
if (filename[i] == '/' || filename[i] == '\\') {
filename[i] = '.';
}
}
CCLOG("[luaLoadChunksFromZIP] add %s to preload", filename.c_str());
if (stack->luaLoadBuffer(L, (char*)zbuffer, (int)bufferSize, filename.c_str()) == 0) {
lua_setfield(L, -2, filename.c_str());
++count;
}
free(zbuffer);
}
filename = zip->getNextFilename();
}
CCLOG("lua_loadChunksFromZIP() - loaded chunks count: %d", count);
lua_pop(L, 2);
lua_pushboolean(L, 1);
delete zip;
} else {
CCLOG("lua_loadChunksFromZIP() - not found or invalid zip file: %s", zipFilePath.c_str());
lua_pushboolean(L, 0);
}
if (zipFileData) {
free(zipFileData);
}
if (buffer) {
free(buffer);
}
} while (0);
return 1;
}
int LuaStack::luaLoadBuffer(lua_State *L, const char *chunk, int chunkSize, const char *chunkName)
{
int r = 0;
auto skipBOM = [](const char*& chunk, int& chunkSize){
// UTF-8 BOM? skip
if (static_cast<unsigned char>(chunk[0]) == 0xEF &&
static_cast<unsigned char>(chunk[1]) == 0xBB &&
static_cast<unsigned char>(chunk[2]) == 0xBF)
{
chunk += 3;
chunkSize -= 3;
}
};
if (_xxteaEnabled && strncmp(chunk, _xxteaSign, _xxteaSignLen) == 0)
{
// decrypt XXTEA
xxtea_long len = 0;
unsigned char* result = xxtea_decrypt((unsigned char*)chunk + _xxteaSignLen,
(xxtea_long)chunkSize - _xxteaSignLen,
(unsigned char*)_xxteaKey,
(xxtea_long)_xxteaKeyLen,
&len);
skipBOM((const char*&)result, (int&)len);
r = luaL_loadbuffer(L, (char*)result, len, chunkName);
free(result);
}
else
{
skipBOM(chunk, chunkSize);
r = luaL_loadbuffer(L, chunk, chunkSize, chunkName);
}
#if defined(COCOS2D_DEBUG) && COCOS2D_DEBUG > 0
if (r)
{
switch (r)
{
case LUA_ERRSYNTAX:
CCLOG("[LUA ERROR] load \"%s\", error: syntax error during pre-compilation.", chunkName);
break;
case LUA_ERRMEM:
CCLOG("[LUA ERROR] load \"%s\", error: memory allocation error.", chunkName);
break;
case LUA_ERRFILE:
CCLOG("[LUA ERROR] load \"%s\", error: cannot open/read file.", chunkName);
break;
default:
CCLOG("[LUA ERROR] load \"%s\", error: unknown.", chunkName);
}
const char* error = lua_tostring(L, -1);
CCLOG("[LUA_ERROR:] error result: %s", error);
lua_pop(L, 1);
}
#endif
return r;
}
int LuaStack::luaLoadChunksFromZIP(lua_State *L)
{
if (lua_gettop(L) < 1) {
CCLOG("luaLoadChunksFromZIP() - invalid arguments");
return 0;
}
const char *zipFilename = lua_tostring(L, -1);
lua_settop(L, 0);
FileUtils *utils = FileUtils::getInstance();
std::string zipFilePath = utils->fullPathForFilename(zipFilename);
LuaStack *stack = this;
do {
void *buffer = nullptr;
ZipFile *zip = nullptr;
Data zipFileData(utils->getDataFromFile(zipFilePath));
unsigned char* bytes = zipFileData.getBytes();
ssize_t size = zipFileData.getSize();
bool isXXTEA = stack && stack->_xxteaEnabled && size >= stack->_xxteaSignLen
&& memcmp(stack->_xxteaSign, bytes, stack->_xxteaSignLen) == 0;
if (isXXTEA) { // decrypt XXTEA
xxtea_long len = 0;
buffer = xxtea_decrypt(bytes + stack->_xxteaSignLen,
(xxtea_long)size - (xxtea_long)stack->_xxteaSignLen,
(unsigned char*)stack->_xxteaKey,
(xxtea_long)stack->_xxteaKeyLen,
&len);
zip = ZipFile::createWithBuffer(buffer, len);
} else {
if (size > 0) {
zip = ZipFile::createWithBuffer(bytes, (unsigned long)size);
}
}
if (zip) {
CCLOG("lua_loadChunksFromZIP() - load zip file: %s%s", zipFilePath.c_str(), isXXTEA ? "*" : "");
lua_getglobal(L, "package");
lua_getfield(L, -1, "preload");
int count = 0;
std::string filename = zip->getFirstFilename();
while (filename.length()) {
ssize_t bufferSize = 0;
unsigned char *zbuffer = zip->getFileData(filename.c_str(), &bufferSize);
if (bufferSize) {
// remove .lua or .luac extension
size_t pos = filename.find_last_of('.');
if (pos != std::string::npos)
{
std::string suffix = filename.substr(pos, filename.length());
if (suffix == NOT_BYTECODE_FILE_EXT || suffix == BYTECODE_FILE_EXT) {
filename.erase(pos);
}
}
// replace path separator '/' '\' to '.'
for (int i=0; i<filename.size(); i++) {
if (filename[i] == '/' || filename[i] == '\\') {
filename[i] = '.';
}
}
CCLOG("[luaLoadChunksFromZIP] add %s to preload", filename.c_str());
if (stack->luaLoadBuffer(L, (char*)zbuffer, (int)bufferSize, filename.c_str()) == 0) {
lua_setfield(L, -2, filename.c_str());
++count;
}
free(zbuffer);
}
filename = zip->getNextFilename();
}
CCLOG("lua_loadChunksFromZIP() - loaded chunks count: %d", count);
lua_pop(L, 2);
lua_pushboolean(L, 1);
delete zip;
} else {
CCLOG("lua_loadChunksFromZIP() - not found or invalid zip file: %s", zipFilePath.c_str());
lua_pushboolean(L, 0);
}
if (buffer) {
free(buffer);
}
} while (0);
return 1;
}
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;*/
}
}
int LuaStack::lua_loadChunksFromZIP(lua_State *L)
{
if (lua_gettop(L) < 1) {
CCLOG("lua_loadChunksFromZIP() - invalid arguments");
return 0;
}
const char *zipFilename = lua_tostring(L, -1);
lua_settop(L, 0);
FileUtils *utils = FileUtils::getInstance();
std::string zipFilePath = utils->fullPathForFilename(zipFilename);
LuaStack *stack = curStack;
do {
ssize_t size = 0;
void *buffer = NULL;
unsigned char *zipFileData = utils->getFileData(zipFilePath.c_str(), "rb", &size);
ZipFile *zip = NULL;
bool isXXTEA = stack && stack->_xxteaEnabled && zipFileData;
for (int i = 0; isXXTEA && i < stack->_xxteaSignLen && i < size; ++i) {
isXXTEA = zipFileData[i] == stack->_xxteaSign[i];
}
if (isXXTEA) { // decrypt XXTEA
xxtea_long len = 0;
buffer = xxtea_decrypt(zipFileData + stack->_xxteaSignLen,
(xxtea_long)size - (xxtea_long)stack->_xxteaSignLen,
(unsigned char*)stack->_xxteaKey,
(xxtea_long)stack->_xxteaKeyLen,
&len);
delete []zipFileData;
zipFileData = NULL;
zip = ZipFile::createWithBuffer(buffer, len);
} else {
if (zipFileData) {
zip = ZipFile::createWithBuffer(zipFileData, size);
}
}
if (zip) {
CCLOG("lua_loadChunksFromZIP() - load zip file: %s%s", zipFilePath.c_str(), isXXTEA ? "*" : "");
lua_getglobal(L, "package");
lua_getfield(L, -1, "preload");
int count = 0;
std::string filename = zip->getFirstFilename();
while (filename.length()) {
ssize_t bufferSize = 0;
unsigned char *zbuffer = zip->getFileData(filename.c_str(), &bufferSize);
if (bufferSize) {
if (stack->luaLoadBuffer(L, (char*)zbuffer, (int)bufferSize, filename.c_str()) == 0) {
lua_setfield(L, -2, filename.c_str());
++count;
}
delete []zbuffer;
}
filename = zip->getNextFilename();
}
CCLOG("lua_loadChunksFromZIP() - loaded chunks count: %d", count);
lua_pop(L, 2);
lua_pushboolean(L, 1);
delete zip;
} else {
CCLOG("lua_loadChunksFromZIP() - not found or invalid zip file: %s", zipFilePath.c_str());
lua_pushboolean(L, 0);
}
if (zipFileData) {
delete []zipFileData;
}
if (buffer) {
free(buffer);
}
} while (0);
return 1;
}