Cifrado de recursos de imagen, cifrado de archivos Lua
El problema de la protección de recursos se encuentra a menudo en el desarrollo de juegos. En la actualidad, los tipos de archivos que a menudo se cifran en el desarrollo de juegos son: imágenes, archivos Lua, audio y otros archivos, pero el cifrado también es un arma de doble filo.
Si necesita seguridad, debe gastar una cierta cantidad de recursos para implementarla. En la actualidad, la herramienta TexturePacker también se utiliza para cifrar en Internet, pero la pertinencia no es lo suficientemente fuerte.
Analice el principio como:
1. Conversión de formato: una forma de convertir archivos que deben cifrarse en secuencias;
2. Cifrado: según sus necesidades, utilice métodos de cifrado, MD5, AES e incluso cambie directamente el desplazamiento. Agregue algunos caracteres especiales propios para hacer que el archivo sea un cifrado simple. Después del cifrado, básicamente se garantiza que el tipo de imagen no se puede previsualizar ni reproducir con un software especial Abierto, el archivo Lua se distorsiona después del cifrado;
3. Guarde el archivo de formato personalizado: guárdelo como su propio tipo especial de nombre de archivo, como "xx.d" "xx.xyz" y así sucesivamente.
4. Descifrado de imágenes: modifique la ruta de adquisición de la biblioteca subyacente cocos2dx y modifique el código fuente al cargar el procesamiento de textura de CCImage;
5. Interfaz de archivo Lua especial: modifique el método de carga Lua correspondiente;
Una vez que los principios básicos estén claros, hablaré sobre algunos métodos de cifrado de uso común en mis proyectos:
La primera es la forma de formatear y cifrar:
bool PublicCommen :: recode_getFileByName (string pFileName) {unsigned long nSize = 0;
char sin firmar * pBuffer = CCFileUtils :: sharedFileUtils () -> getFileData (
pFileName.c_str (), "rb", & nSize);
unsigned char * newBuf = new unsigned char [nSize]; int newblen = nSize; if (pBuffer! = NULL && nSize> 0)
{for (int i = 0; i newBuf [i] = pBuffer [i] + MD5;
} string savepath = pFileName;
savepath = savepath.substr (0, savepath.length () - 4);
savepath = savepath + "xx.X";
ARCHIVO * fp = fopen (savepath.c_str (), "wb +");
fwrite (newBuf, 1, newblen, fp);
fclose (fp);
CCLOG ("guardar archivo ok. Ruta =% s", savepath.c_str ()); devuelve verdadero;
} falso retorno;
}
Por lo general, puede escribir una aplicación para atravesar los archivos de recursos que deben transferirse en el directorio personalizado y, en consecuencia, convertir y cifrar todos los recursos; dentro de newBuf [i] = pBuffer [i] + MD5; ¡este párrafo se puede reproducir libremente! ¡Necesito corresponder al descifrar!
Por supuesto, también puedes usarlo en tu juego para modificar CCFileUtils :: fullPathForFilename en la parte inferior de Cocos2d-x para obtener la ruta completa;
Hablemos de descifrado:
El descifrado de la imagen debe modificarse en la clase CCTextureCache :: addImage de cocos2dx CCTexture2D
CCTexture2D * CCTextureCache :: addImage (const char * ruta)
{
CCAssert (ruta! = NULL, "TextureCache: fileimage NO DEBE ser NULL");
CCTexture2D * textura = NULL;
CCImage * pImage = NULL; // Dividir directorio y nombre de archivo // MUTEX: // Necesario ya que addImageAsync llama a este método desde un hilo diferente // pthread_mutex_lock (m_pDictLock); std :: string pathKey = ruta;
pathKey = CCFileUtils :: sharedFileUtils () -> fullPathForFilename (pathKey.c_str ()); si (pathKey.size () == 0)
{return NULL;
}
textura = (CCTexture2D *) m_pTextures-> objectForKey (pathKey.c_str ());
std :: string fullpath = pathKey; // (CCFileUtils :: sharedFileUtils () -> fullPathFromRelativePath (ruta)); si (! textura)
{
std :: string lowerCase (clave de ruta); for (unsigned int i = 0; i <lowerCase.length (); ++ i)
{
lowerCase [i] = tolower (lowerCase [i]);
} // todas las imágenes son manejadas por UIImage excepto la extensión PVR que maneja nuestro propio controlador do {if (std :: string :: npos! = lowerCase.find (". pvr"))
{
textura = esto-> addPVRImage (fullpath.c_str ());
} else if (std :: string :: npos! = lowerCase.find (“. pkm”))
{// Formato de archivo ETC1, solo compatible con Android texture = this-> addETCImage (fullpath.c_str ());
} más {
CCImage :: EImageFormat eImageFormat = CCImage :: kFmtUnKnown; if (std :: string :: npos! = lowerCase.find (“. png”))
{
eImageFormat = CCImage :: kFmtPng;
} else if (std :: string :: npos! = lowerCase.find (". jpg") || std :: string :: npos! = lowerCase.find (". jpeg"))
{
eImageFormat = CCImage :: kFmtJpg;
} else if (std :: string :: npos! = lowerCase.find (". tif") || std :: string :: npos! = lowerCase.find (". tiff"))
{
eImageFormat = CCImage :: kFmtTiff;
} else if (std :: string :: npos! = lowerCase.find (“. webp”))
{
eImageFormat = CCImage :: kFmtWebp;
} else if (std :: string :: npos! = lowerCase.find ("XX.X"))
{
eImageFormat = CCImage :: xxxxx;
}
pImage = new CCImage ();
CC_BREAK_IF (NULL == pImage); bool bRet = pImage-> initWithImageFile (ruta completa.c_str (), eImageFormat);
CC_BREAK_IF (! BRet);
textura = nuevo CCTexture2D (); if (textura && textura-> initWithImage (pImage))
{#if CC_ENABLE_CACHE_TEXTURE_DATA // almacenar en caché el nombre del archivo de textura VolatileTexture :: addImageTexture (texture, fullpath.c_str (), eImageFormat); #endif m_pTextures-> setObject (textura, pathKey.c_str ());
textura-> liberación ();
} más {
CCLOG ("cocos2d: No se pudo crear la textura para el archivo:% s en CCTextureCache", ruta);
}
}
} while (0);
}
CC_SAFE_RELEASE (pImage); // pthread_mutex_unlock (m_pDictLock); textura de retorno;
}
Y agregue su tipo de imagen cifrada en el tipo de imagen de CCImage, como: CCImage :: xxxxx; luego siga
bool bRet = pImage-> initWithImageFile (ruta completa.c_str (), eImageFormat);
Método CCImage :: initWithImageFile en CCImage.mm:
bool CCImage :: initWithImageFile (const char * strPath, EImageFormat eImgFmt / * = eFmtPng * /)
{bool bRet = falso;
unsigned long nSize = 0;
char sin firmar * pBuffer = CCFileUtils :: sharedFileUtils () -> getFileData (
CCFileUtils :: sharedFileUtils () -> fullPathForFilename (strPath) .c_str (), "rb", & nSize); si (eImgFmt == xxxxxx)
{para (int i = 0; i <nTamaño; i ++) {
pBuffer [i] = pBuffer [i] -MD5;
}
pBuffer [nSize] = pBuffer [nSize] -1;
eImgFmt = kFmtPng;
} if (pBuffer! = NULL && nSize> 0)
{
bRet = initWithImageData (pBuffer, nSize, eImgFmt);
}
CC_SAFE_DELETE_ARRAY (pBuffer); return bRet;
}
Entre ellos, pBuffer [i] = pBuffer [i] -MD5; debe corresponder al tiempo de cifrado anterior, ¡juegue usted mismo!
Ok, siempre que sea una imagen y la imagen pertenezca a su tipo personalizado, la textura real será descifrada.
El descifrado de Lua es básicamente la misma idea, pero el descifrado debe descifrarse por separado antes de cargar el método Lua, y se considera multiplataforma.