encript data system

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>

#define WHERESTR "ERROR (Line: %d): "

#define PRINT_(...) {           \
    fprintf(stderr, __VA_ARGS__);   \
    putchar('\n');          \
    exit(EXIT_FAILURE);         \
    }
#define ERROR(_fmt, ...) PRINT_(WHERESTR _fmt, __LINE__, __VA_ARGS__)

#define VERSION_    0.01
#define BYTE_       0x0FF
#define FILE_KEY    "file.key"

enum {
    enabled = 0,
    disabled
} current_register_status;

enum {
    recover = 0,
    modify
} set_data;

typedef struct data {
    unsigned int id;
    char message[16];
    signed char status;
} data_t;

typedef struct node {
    data_t data;
    struct node *next;
} node_t;

static char key_word[16]; // (DON'T CHANGE!!!)
static unsigned char KEY_MAX, KEY_MIN;

static void brute_force(const char *file_name)
{
    FILE *stream;
    data_t tmp, aux;
    register i, j;
    register offset;
    char c, *ptr;

    stream = fopen(file_name, "rb");
    if (stream == NULL)
    ERROR("%s", "Error in opening the file.");

    fread((void*) &tmp, sizeof(data_t), 1, stream);
    fprintf(stdout, "READ-> ID: %d | Message: %s | Status: %d\n",
    tmp.id, tmp.message, tmp.status);

    for(i = 0; i < 256; i++) {
    for(j = 0; j < 256; j++) {
        memcpy(&aux, &tmp, sizeof(data_t));
        for(ptr = (char *)&aux, offset = 0;offset < (sizeof(data_t)); offset++, ptr += 0x1) {
        *ptr = ((~(*ptr)) ^ (i*j)) - (KEY_MAX & KEY_MIN);
        }
        if(aux.status == 0 && (aux.message[0] >= 'A' && aux.message[0] <= 'z')) {
        fprintf(stdout, "COUNT: [%d] I: %d J: %d || READ-> ID: %d | Message: %s | Status: %d\n\n",
            i*j, i, j, aux.id, aux.message, aux.status);
        //scanf("\n%c", &c);
        }
    }
    }
    printf("Loops amount: %d\n", i * j);

    fclose(stream);
}

static unsigned sort_key_value(void)
{
    register i;
    unsigned total;

    for(total = i = 0; i < 15; i++) {
    total += (unsigned int) key_word[i];
    key_word[i] = ~key_word[i]; // Invert bytes in the key.
    }

    // Set a integer to a byte!
    KEY_MIN = (total & BYTE_);
    KEY_MAX = ((total >> 4) & BYTE_);

    //fprintf(stdout, "KEY_MIN %d Key_MAX %d", KEY_MIN, KEY_MAX);

    return total;
}

/* Simple cryptography */
static void modify_data(data_t *tmp, int option)
{
    register offset;
    register offset_key;
    char *ptr;

    /*for(ptr = (char *) tmp, offset = 0; offset < (sizeof(data_t)); offset++, ptr += 0x1)
    fprintf(stdout, "Current-> Address: %x Data: %d\n", ptr, *ptr); */

    if(option) {
    for (ptr = (char *) tmp, offset = offset_key = 0; offset < (sizeof(data_t));
        offset++, offset_key++, ptr += 0x1) {
        if (offset_key == 0xF)
        offset_key = 0;

        *ptr = ~((*ptr + (KEY_MAX & KEY_MIN)) ^ key_word[offset_key]);

    }
        /*fprintf(stdout, "Modified-> Address: %x Data: %d\n", ptr,
         * ptr = (~(*ptr + BYTE_)) ^ KEY_VALUE); */
    fprintf(stdout, "SEC_DATA-> ID: %d | Message: %s | Status: %d\n", tmp->id,
        tmp->message, tmp->status);

    } else {
    for (ptr = (char *) tmp, offset = offset_key = 0; offset < (sizeof(data_t));
        offset++, offset_key++, ptr += 0x1) {
        if (offset_key == 0xF)
        offset_key = 0;

        *ptr = ((~(*ptr)) ^ key_word[offset_key]) - (KEY_MAX & KEY_MIN);
    }
        //*ptr = (~(*ptr ^ (KEY_MAX + KEY_MIN))) - BYTE_;

        /*fprintf(stdout, "Recover-> Address: %x Data: %d\n", ptr,
         * ptr = (~(*ptr ^ KEY_VALUE)) - BYTE_); */
    }
}

static void create_key(void)
{
    FILE *stream;
    int i;

    stream = fopen(FILE_KEY, "r+b");
    if (stream == NULL)
    ERROR("%s (%s)", "File doesn't exist:", FILE_KEY);

    fprintf(stdout, "* Checking for the key: ");

    for(i = 0; fread((void*) key_word, sizeof(char), 15, stream); i++);

    if(!i) {
    srand(time(NULL));
    fprintf(stdout, "Generating a new key...");
    for(i = 0; i < 15; i++)
        key_word[i] = (((int)rand()) % (CHAR_MAX-0xA) + 0xA);

    fprintf(stream, "%s", key_word);
    fprintf(stdout, " (Key was created sucessfully!)\n");
    } else
    fprintf(stdout, " (Key already exists!)\n");

    fclose(stream);
}

static void insert(node_t *head, data_t *buffer)
{
    node_t *new_node, *p;

    new_node = malloc(sizeof(node_t));
    if (new_node == NULL)
    ERROR("%s", "Memory can't be allocated.");

    /* Filling data in the node */
    memcpy(&new_node->data, buffer, sizeof(data_t));
    new_node->next = NULL;

    for(p = head; p->next != NULL; p = p->next)
    ;
    p->next = new_node;
}

static void free_node(node_t *head)
{
    node_t *p, *tmp;

    for(p = head; p->next != NULL; free(tmp)) {
    tmp = p;
    p = p->next;
    }
}

static void record_data(const char *file_name)
{
    FILE *stream;
    data_t tmp;
    signed char ret;

    stream = fopen(file_name, "ab");
    if (stream == NULL)
    ERROR("%s", "Error in opening the file.");

    tmp.id = 0;
    printf("Input 'ID' / 'Message': ");
    scanf("%d\n", &tmp.id);
    fgets(tmp.message, 15, stdin);

    tmp.message[strlen(tmp.message)-1] = '\0';
    tmp.status = enabled;

    /* Current point at begin of the file */
    fseek(stream, 0, SEEK_SET);

    modify_data(&tmp, modify);
    ret = fwrite((const void*) &tmp, sizeof(data_t), 1, stream);
    if (ret < 0)
    ERROR("%s", "fwrite does not work.");

    modify_data(&tmp, recover);
    fprintf(stdout, "WRITE-> ID: %d | Message: %s | Status: %d\n", tmp.id,
        tmp.message, tmp.status);

    fclose(stream);
}

static void read_file(const char *file_name, int option)
{
    FILE *stream;
    data_t tmp;

    stream = fopen(file_name, "rb");
    if (stream == NULL)
    ERROR("%s", "Error in opening the file.");

    /* Current point at begin of the file */
    fseek(stream, 0, SEEK_SET);

    while(fread((void*) &tmp, sizeof(data_t), 1, stream)) {
    modify_data(&tmp, recover);
    if(option == enabled) {
        if (tmp.status == disabled)
        continue;
    } else if(option == disabled) {
        if (tmp.status == enabled)
        continue;
    }

    fprintf(stdout, "READ-> ID: %d | Message: %s | Status: %d\n",
        tmp.id, tmp.message, tmp.status);
    }
    fclose(stream);
}

static void create_new_file(node_t *head, const char *file_name)
{
    FILE *stream;
    node_t *p;
    signed char ret;

    /* Remove current file */
    if (remove(file_name) != 0)
    ERROR("%s", "Error on deleting file");

    stream = fopen(file_name, "ab");
    if (stream == NULL)
    ERROR("%s", "Error in opening the file.");

    /* Current point at begin of the file */
    fseek(stream, 0, SEEK_SET);

    /* Rewrite old file */
    for(p = head; p->next != NULL; ) {
    p = p->next;

    modify_data(&p->data, modify);
    ret = fwrite((const void*) &p->data, sizeof(data_t), 1, stream);
    if (ret < 0)
        ERROR("%s", "fwrite does not work.");

    modify_data(&p->data, recover);
    fprintf(stdout, "RE-WRITE-> ID: %d | Message: %s | Status: %d\n",
        p->data.id, p->data.message, p->data.status);
    }

    fprintf(stdout, "File disabled sucessfully!\n");
    fclose(stream);
}

static void disable_file(const char *file_name)
{
    FILE *stream;
    data_t tmp;
    node_t *head;
    unsigned int buffer;
    static signed char flag_disabled;

    stream = fopen(file_name, "r+");
    if (stream == NULL)
    ERROR("%s", "Error in opening the file.");

    printf("ID to be disabled': ");
    scanf("\n%d", &buffer);

    /* Allocate a dummy node */
    head = malloc(sizeof(node_t));
    if (head == NULL)
        error("memory can't be allocated");
    head->next = NULL;

    /* Current point at begin of the file */
    fseek(stream, 0, SEEK_SET);

    while (fread((void*) &tmp, sizeof(data_t), 1, stream)) {
    modify_data(&tmp, recover);
    if (tmp.id == buffer) {
        tmp.status = disabled;
        flag_disabled = 1;
    }
    /* Insert a file content in the node */
    insert(head, &tmp);
    }

    if(flag_disabled) {
    fclose(stream);
    create_new_file(head, file_name);
    } else {
    fprintf(stdout, "File disabled unsucessfully!\n");
    fclose(stream);
    }
    free_node(head);
}

static void inline
start_program(const char *file_name)
{
    register i;
    signed char c;
    unsigned KEY_VALUE;

    char *menu[] = {
    "- Insert data:\t[0]",
    "- Remove data:\t[1]",
    "- Data report:\t[2]",
    "- Deleted list:\t[3]",
    "- Force Brute:\t[4]",
    "- Exit program:\t[5]",
    "* Choose a option: "
    };

    fprintf(stdout, "***Welcome to the Encrypted Data System (v%.2f)***\n\t%s\n\n",
        VERSION_, "(( Created by Utroz ))");

    /* Key manager */
    create_key();
    KEY_VALUE = sort_key_value();

    printf("* Current Key (%s)-> %d\n* Current DataBase file-> %s\n",
       FILE_KEY, KEY_VALUE, file_name);

    while (1) {
    putchar('\n');
    for(i = 0; i <= 6; i++)
        fprintf(stdout, "%s\n", menu[i]);

    scanf("\n%c", &c);
    switch (c) {
        case '0':
        record_data(file_name);
        break;
        case '1':
        disable_file(file_name);
        break;
        case '2':
        read_file(file_name, enabled);
        break;
        case '3':
        read_file(file_name, disabled);
        break;
        case '4':
        brute_force(file_name);
        break;
        case '5':
        read_file(file_name, enabled);
        fprintf(stdout, "\n* Terminate program execution.\n");
        exit(EXIT_SUCCESS);
        break;
        default:
        fprintf(stdout, "Option invalid!\n");
        break;
    }
    }
}

int main(int argc, char *argv[])
{
    FILE *fp;
    signed char c;

    /* Creating a file which still
     * does not exist! */
    if (argc != 2)
    ERROR("Usage-> %s filename.log", argv[0]);

    fp = fopen(argv[1], "a");
    if (fp == NULL)
    ERROR("%s", "Error in opening the file.");
    fclose(fp);

    /* Initializes program */
    start_program(argv[1]);

    return 0;
}