Chemax, База данных Опции

[Кантемир]

Просто хочу оболочку и возможности сохранить, а база кодов с нула хочу написать
и добавить секреты.
Блин как редактировать база данных?
А может ктонибудь создать прогу на подобия это? Просто там в chemaxе нельзя ни редактировать ни с нула.

[useretail]

Причесал для линукса: linux x86_64 + src
Благоданости: -=CHE@TER=-

CODE

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <errno.h>
#include <inttypes.h>

#define OUTPUT_NAME_MAX 260

static const uint8_t valid_char_mask[32] = {
0x00, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
0x04, 0x80, 0x7B, 0x40, 0xEB, 0xB9, 0x10, 0xF0,
0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF
};

static const uint8_t decryption_keys[3][10] = {
"qs3g#erty0",
"a@g5eDu(*5",
"qZ8&5N3eS0"
};

const char *get_basename(const char *path) {
const char *base = strrchr(path, '/');
return base ? base + 1 : path;
}

void replace_file_ext(char *out, size_t size, const char *filename, const char *new_ext) {
const char *base = get_basename(filename);
const char *dot = strrchr(base, '.');
size_t len = dot ? (size_t)(dot - base) : strlen(base);

if (*new_ext != '.')
snprintf(out, size, "%.*s.%s", (int)len, base, new_ext);
else
snprintf(out, size, "%.*s%s", (int)len, base, new_ext);
}

int decrypt_buffer(uint8_t *buffer, size_t buffer_size, uint32_t key_type) {
if (!buffer || buffer_size == 0 || key_type >= 3) return 0;

const uint8_t *key = decryption_keys[key_type];
size_t i = 0, k = 0;

if (key_type == 0) {
k = buffer_size - 1;
while (k && !buffer[k]) k--;
while (k && (buffer[k] == ';' || (buffer[k] >= '0' && buffer[k] <= '9'))) k--;
if (k && !buffer[k]) {
buffer[k] = ' ';
k++;
i = 0;
while (k < buffer_size && (buffer[k] >= '0' && buffer[k] <= '9')) {
i = i * 10 + (buffer[k++] - '0');
}
for (; k < buffer_size; k++) {
if (!buffer[k]) buffer[k] = ' ';
}
buffer_size = i;
}
}

for (i = 0; i < buffer_size; i++) {
k = i % 10;
if (key_type == 0) {
buffer[i] -= key[k];
} else {
buffer[i] += ((buffer[i] > key[k]) ? 0 : 255) - key[k];
}
}

return 1;
}

uint32_t detect_key_type(const uint8_t *data, size_t size) {
if (!data || size < 128) return 100;

uint8_t temp[128];

for (uint32_t key_index = 0; key_index < 3; key_index++) {
memcpy(temp, data, sizeof(temp));
decrypt_buffer(temp, sizeof(temp), key_index);

int is_valid = 1;
for (size_t j = 0; j < sizeof(temp); j++) {
if (!(valid_char_mask[temp[j] / 8] & (0x80 >> (temp[j] % 8)))) {
is_valid = 0;
break;
}
}
if (is_valid) return key_index;
}
return 100;
}

int main(int argc, char *argv[]) {
if (argc != 2) {
fprintf(stderr, "Usage: %s <cheats.dat>\n", get_basename(argv[0]));
return 1;
}

const char *input_filename = argv[1];
int input_fd = open(input_filename, O_RDONLY);
if (input_fd < 0) {
fprintf(stderr, "Error: could not open input file '%s': %s\n", input_filename, strerror(errno));
return 2;
}

struct stat file_stat;
if (fstat(input_fd, &file_stat) != 0) {
fprintf(stderr, "Error: could not get file info for '%s': %s\n", input_filename, strerror(errno));
close(input_fd);
return 3;
}

size_t file_size = (size_t)file_stat.st_size;
uint8_t *file_buffer = malloc(file_size);
if (!file_buffer) {
fprintf(stderr, "Error: failed to allocate memory (%zu bytes): %s\n", file_size, strerror(errno));
close(input_fd);
return 4;
}

ssize_t bytes_read = read(input_fd, file_buffer, file_size);
if (bytes_read != file_size) {
fprintf(stderr, "Error: failed to read from '%s' (expected %" PRIuPTR " bytes, got %" PRIuPTR " bytes): %s\n",
input_filename, (uintptr_t)file_size, (uintptr_t)bytes_read, strerror(errno));
free(file_buffer);
close(input_fd);
return 5;
}
close(input_fd);

uint32_t key_type = detect_key_type(file_buffer, file_size);
if (!decrypt_buffer(file_buffer, file_size, key_type)) {
fprintf(stderr, "Error: input file is not a valid or supported format\n");
free(file_buffer);
return 6;
}

char output_filename[OUTPUT_NAME_MAX];
replace_file_ext(output_filename, sizeof(output_filename), input_filename, ".txt");

int output_fd = open(output_filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (output_fd < 0) {
fprintf(stderr, "Error: could not create output file '%s': %s\n", output_filename, strerror(errno));
free(file_buffer);
return 7;
}

ssize_t bytes_written = write(output_fd, file_buffer, file_size);
if (bytes_written != file_size) {
fprintf(stderr, "Error: failed to write to '%s' (expected %" PRIuPTR " bytes, got %" PRIuPTR " bytes): %s\n",
output_filename, (uintptr_t)file_size, (uintptr_t)bytes_written, strerror(errno));
close(output_fd);
free(file_buffer);
return 8;
}

close(output_fd);
free(file_buffer);

printf("Success: '%s' decrypted and saved as '%s'\n", input_filename, output_filename);

return 0;
}