Парни есть кто шарит в C++?
Мне нужно в компрессоре вырезать дебаг секции, что-бы не можно было просматривать содержимое файла(исходного кода) в сторонних софтах
В моём случае это smx файл
Сторонний софт https://headlinedev.xyz/lysis/
Код
<code =


#define _CRT_SECURE_NO_WARNINGS

#include <cstdio>
#include <fstream>
#include <smx/smx-headers.h>
#include <zlib.h>
#include <ctime>

using namespace std;
using namespace sp;

char *rand_string(char *str, size_t size);
void* memmem(const void *haystack, size_t haystack_len, const void * const needle, const size_t needle_len);
void* compress(sp_file_hdr_t *header, void* buffer, unsigned long& destlenn);
void* decompress(sp_file_hdr_t *header, void* buffer, unsigned long& destlenn);

int main()
{
srand((unsigned int)time(NULL));
FILE* ifs = fopen(".\orig.smx", "rb");
if (ifs == NULL)
{
fputs("Cannot open "orig.smx" file.n", stdout);
system("pause");
return 0;
}
fseek(ifs, 0, SEEK_END);
size_t length = ftell(ifs);
fseek(ifs, 0, SEEK_SET);

char *buffer = new char[length];
fread(buffer, length, 1, ifs);
fclose(ifs);

if (length < sizeof(sp_file_hdr_t))
{
fputs("Not smx file: bad headern", stdout);
delete[] buffer;
return 0;
}

sp_file_hdr_t *header = (sp_file_hdr_t *)buffer;

switch (header->compression)
{
case SmxConsts::FILE_COMPRESSION_NONE:
{

break;
}
case SmxConsts::FILE_COMPRESSION_GZ:
{
unsigned long destlen = 0;
int suze = length;
char* url;
char* key_p;
char key[65];
int* pp;
void* compressed;
void* decompressed;
void* temp;

repeat:

header = (sp_file_hdr_t *)buffer;

decompressed = decompress(header, buffer, destlen);
printf("Decompressed: %lun", header->disksize);

temp = new char[header->dataoffs + destlen];
memcpy(temp, buffer, header->dataoffs);
memcpy((char*)temp + header->dataoffs, decompressed, destlen); // ?+1

url = (char*)memmem(temp, destlen, "http://license.hotstar-project.net/", 35);
strcpy(url, "http://client809.4bo.ru/83_019310111021000100101");
key_p = (char*)memmem(temp, destlen, "sm=%s", 5);
key_p += 8;
rand_string(key, 64);
strcpy(key_p, key);

pp = (int*) memmem(temp, header->dataoffs + destlen, &suze, sizeof(suze));

compressed = compress(header, temp, destlen);
*pp = header->disksize;
decompress(header, buffer, destlen);
compressed = compress(header, temp, destlen);
if (header->disksize != *pp)
{
delete compressed;
delete decompressed;
delete temp;
goto repeat;
}

printf("Compressed: %lun", header->disksize);

FILE* patched = fopen("dev-version.smx", "wb");
fwrite(buffer, header->dataoffs, 1, patched);
fwrite(compressed, destlen, 1, patched);
printf("Key: %sn", key);
system("pause");
delete[] temp;

break;
}
default:
fputs("Unknown compression typen", stdout);
}

delete[] buffer;
return 0;
}

void *memmem(const void *haystack, size_t haystack_len, const void * const needle, const size_t needle_len)
{
if (haystack == NULL) return NULL; // or assert(haystack != NULL);
if (haystack_len == 0) return NULL;
if (needle == NULL) return NULL; // or assert(needle != NULL);
if (needle_len == 0) return NULL;

for (const char *h = (char*)haystack; haystack_len >= needle_len; ++h, --haystack_len) {
if (!memcmp(h, needle, needle_len)) {
return (void*)h;
}
}
return NULL;
}

char *rand_string(char *str, size_t size)
{
const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJK0123456789";
if (size) {
--size;
for (size_t n = 0; n < size; n++) {
int key = rand() % (int)(sizeof charset - 1);
str[n] = charset[key];
}
str[size] = '';
}
return str;
}

void* compress(sp_file_hdr_t *header, void* buffer, unsigned long& destlenn)
{
if (header->disksize != header->imagesize)
{
fputs("Illegal image size: no compression but not equal disksizen", stdout);
delete[] buffer;
return 0;
}

size_t uncompressedSize = header->disksize - header->dataoffs;
const uint8_t *src = (uint8_t *)buffer + header->dataoffs;
uLong destlen = compressBound((uLong)uncompressedSize);
char *compressed = new char[destlen];
uint8_t *dest = (uint8_t *)compressed;


int r = compress2(dest, &destlen, src, (uLong)uncompressedSize, Z_BEST_COMPRESSION);
if (r != Z_OK)
{
printf("Unable to compress, error %d", r);
delete[] compressed;
delete[] buffer;
return 0;
}

header->disksize = header->dataoffs + destlen;
header->compression = SmxConsts::FILE_COMPRESSION_GZ;
destlenn = destlen;
return dest;
}

void* decompress(sp_file_hdr_t *header, void* buffer, unsigned long& destlenn)
{
size_t compressedSize = header->disksize - header->dataoffs;
const uint8_t *src = (uint8_t *)buffer + header->dataoffs;
uLongf destlen = header->imagesize - header->dataoffs;
char *uncompressed = new char[destlen];
uint8_t *dest = (uint8_t *)uncompressed;

int r = uncompress(dest, &destlen, src, (uLong)compressedSize);
if (r != Z_OK)
{
printf("Could not decode compressed region: %dn", r);
delete[] uncompressed;
delete[] buffer;
return 0;
}

header->disksize = header->dataoffs + destlen;
if (header->disksize != header->imagesize)
fputs("Imagesize not equal disksize after uncopressionn", stdout);
header->compression = SmxConsts::FILE_COMPRESSION_NONE;
destlenn = destlen;
return uncompressed;
}
</code>
________
посл. ред. 06.06.2020 в 19:52; всего 1 раз(а); by V0L4OK