n_crypto.c

Go to the documentation of this file.

 
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#define _GNU_SOURCE_WAS_NOT_DEFINED
#endif
 
#include "nilorea/n_common.h"
#include "nilorea/n_base64.h"
#include "nilorea/n_crypto.h"
#include "nilorea/n_thread_pool.h"
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#ifdef __solaris__
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#endif
#if defined(__linux__) || defined(__windows__)
#include <cpuid.h>
#endif
#ifndef __windows__
#include <sys/sysinfo.h>
#endif
#ifdef _GNU_SOURCE_WAS_NOT_DEFINED
#undef _GNU_SOURCE
#endif
 
#ifdef __windows__
#include <windows.h>
#endif
 
static char* __internal_root_key = "ENOFGLUCUNZJADRDMCZZSACRBKXAGSLTTFCICPALKHMWWGLVUIFYSLQJIHHXSHOZGRABFNBHGVTOMEBTVIPXZJHHEKIYWNVTWQKERROCTXFGMMLYUJSJFWLFCHQQMMUM";
 
N_STR* n_vigenere_get_rootkey(size_t rootkey_size) {
    if ((rootkey_size % 2) != 0) {
        n_log(LOG_ERR, "key size %d is not a multiple of 2", rootkey_size);
        return NULL;
    }
    N_STR* output = new_nstr(rootkey_size + 1);
    time_t t = time(NULL);
    if (t == -1) {
        n_log(LOG_ERR, "Error: Unable to get the current time");
        return NULL;
    }
    srand((unsigned int)t);
    for (size_t it = 0; it < rootkey_size; it++) {
        output->data[it] = (char)('A' + rand() % 26);
    }
    output->written = rootkey_size;
    return output;
}
 
N_STR* n_get_current_dir_hd_serial() {
    N_STR* output = NULL;
 
#ifdef __windows__
    DWORD dwVolSerial;
    BOOL bIsRetrieved;
    bIsRetrieved = GetVolumeInformation(NULL, NULL, 0, &dwVolSerial, NULL, NULL, NULL, 0);
 
    if (bIsRetrieved) {
        nstrprintf(output, "%X", (unsigned int)dwVolSerial);
    } else {
        n_log(LOG_ERR, "Could not retrieve current directory disk serial id");
        return NULL;
    }
    return output;
#elif __linux__
    char* curdir = getcwd(NULL, 0);
 
    N_STR* cmd = NULL;
    nstrprintf(cmd, "df -T \"%s\" | awk '/^\\/dev/ {print $1}'", curdir);
    Free(curdir);
 
    N_STR* cur_disk = NULL;
    int ret = -1;
    n_popen(_nstr(cmd), 1024, (void**)&cur_disk, &ret);
    free_nstr(&cmd);
 
    nstrprintf(cmd, "udevadm info --query=all --name=%s | egrep '(ID_SERIAL=|ID_FS_UUID=)' | awk -F'=' '{print $2}'", _nstr(cur_disk));
    n_popen(_nstr(cmd), 1024, (void**)&output, &ret);
    free_nstr(&cmd);
 
    N_STR* hd_serial = NULL;
    nstrprintf(hd_serial, "%s=>%s", _nstr(output), _nstr(cur_disk));
 
    free_nstr(&output);
    free_nstr(&cur_disk);
 
    for (unsigned int it = 0; it < hd_serial->written; it++) {
        if (isspace(hd_serial->data[it])) {
            hd_serial->data[it] = '-';
        }
    }
    return hd_serial;
 
#else  // SOLARIS
 
    char* curdir = getcwd(NULL, 0);
    N_STR* hostid = NULL;
    int ret = -1;
    n_popen("hostid", 1024, (void**)&hostid, &ret);
    Free(curdir);
    nstrprintf(output, "%s:%s", _nstr(hostid), _str(curdir));
    return output;
 
#endif
}
 
N_STR* n_get_cpu_id() {
    N_STR* cpu_id = NULL;
 
#ifndef __sun
    unsigned int a[4] = {0, 0, 0, 0};
 
    if (__get_cpuid_max(0, NULL) >= 1) {
        __get_cpuid(1, &a[0], &a[1], &a[2], &a[3]);
    } else {
        n_log(LOG_ERR, "unable to get CPU id");
        return NULL;
    }
 
    int binaryNum[32];
    memset(&binaryNum, 0, sizeof(binaryNum));
 
    unsigned int n = a[3];
    unsigned int i = 0;
    while (n > 0) {
        // storing remainder in binary array
        binaryNum[i] = n % 2;
        n = n / 2;
        i++;
    }
    n = a[2];
    i = 0;
    while (n > 0) {
        // storing remainder in binary array
        binaryNum[i] = n % 2;
        n = n / 2;
        i++;
    }
    n = a[1];
    i = 0;
    while (n > 0) {
        // storing remainder in binary array
        binaryNum[i] = n % 2;
        n = n / 2;
        i++;
    }
    n = a[0];
    i = 0;
    while (n > 0) {
        // storing remainder in binary array
        binaryNum[i] = n % 2;
        n = n / 2;
        i++;
    }
 
    /*  printf("-------Signature(EAX register):-------");
        printf("\nStepping ID:%d%d%d%d",binaryNum[3],binaryNum[2],binaryNum[1],binaryNum[0]);
        printf("\nModel:%d%d%d%d",binaryNum[7],binaryNum[6],binaryNum[5],binaryNum[4]);
        printf("\nFamily ID:%d%d%d%d",binaryNum[11],binaryNum[10],binaryNum[9],binaryNum[8]);
        printf("\nProcessor Type:%d%d",binaryNum[13],binaryNum[12]);
        printf("\nExtended Model ID:%d%d%d%d",binaryNum[19],binaryNum[18],binaryNum[17],binaryNum[16]);
        printf("\nExtended Family ID:%d%d%d%d%d%d%d%d",binaryNum[27],binaryNum[26],binaryNum[25],binaryNum[24],binaryNum[23],binaryNum[22],binaryNum[21],binaryNum[20]);
        printf("\n"); */
    nstrprintf(cpu_id, "%d%d%d%d-%d%d%d%d-%d%d%d%d-%d%d", binaryNum[3], binaryNum[2], binaryNum[1], binaryNum[0],
               binaryNum[7], binaryNum[6], binaryNum[5], binaryNum[4],
               binaryNum[11], binaryNum[10], binaryNum[9], binaryNum[8],
               binaryNum[13], binaryNum[12]);
 
#else  // We are on SOLARIS
    static const char devname[] = "/dev/cpu/self/cpuid";
 
    struct {
        uint32_t r_eax, r_ebx, r_ecx, r_edx;
    } _r, *rp = &_r;
    int d;
    char* s = NULL;
 
    if ((d = open(devname, O_RDONLY)) != -1) {
        if (pread(d, rp, sizeof(*rp), 0) == sizeof(*rp)) {
            s = (char*)&rp->r_ebx;
        }
        close(d);
    }
    nstrprintf(cpu_id, "%s", s);
#endif
    return cpu_id;
}
 
typedef struct CYPHER_PARAM {
    N_STR* input;
    N_STR* dest;
    N_STR* key;
    bool encipher;
    size_t start_pos;
    size_t end_pos;
} CYPHER_PARAM;
 
void* n_vigenere_cypher_thread(void* ptr) {
    __n_assert(ptr, return NULL);
    CYPHER_PARAM* params = (CYPHER_PARAM*)ptr;
    __n_assert(params, return NULL);
 
    N_STR* input = params->input;
    N_STR* dest = params->dest;
    N_STR* key = params->key;
 
    __n_assert(input, return NULL);
    __n_assert(input->data, return NULL);
    __n_assert(key, return NULL);
    __n_assert(key->data, return NULL);
 
    bool encipher = params->encipher;
 
    size_t start_pos = params->start_pos;
    size_t end_pos = params->end_pos;
 
    bool cIsUpper = 0;
    size_t keyIndexMod = 0;
    if (encipher) {
        for (size_t i = start_pos; i < end_pos; i++) {
            if ((cIsUpper = n_isupper(input->data[i])) || (n_islower(input->data[i]))) {
                char offset = cIsUpper ? 'A' : 'a';
                keyIndexMod = i % key->written;
                int k = (cIsUpper ? n_toupper(key->data[keyIndexMod]) : n_tolower(key->data[keyIndexMod])) - offset;
                dest->data[i] = (char)((n_mathmod(((input->data[i] + k) - offset), 26)) + offset);
            }
        }
    } else {
        for (size_t i = start_pos; i < end_pos; i++) {
            if ((cIsUpper = n_isupper(input->data[i])) || (n_islower(input->data[i]))) {
                char offset = cIsUpper ? 'A' : 'a';
                keyIndexMod = i % key->written;
                int k = (cIsUpper ? n_toupper(key->data[keyIndexMod]) : n_tolower(key->data[keyIndexMod])) - offset;
                dest->data[i] = (char)((n_mathmod(((input->data[i] - k) - offset), 26)) + offset);
            }
        }
    }
    Free(params);
    return NULL;
}
 
N_STR* n_vigenere_cypher(N_STR* input, N_STR* key, bool encipher, bool in_place) {
    __n_assert(input, return NULL);
    __n_assert(input->data, return NULL);
    __n_assert(key, return NULL);
    __n_assert(key->data, return NULL);
 
    if (input->written == 0) {
        n_log(LOG_ERR, "empty input, written=0");
        return NULL;
    }
 
    if ((key->written % 2) != 0) {
        n_log(LOG_ERR, "odd number of elements in root key %s, %d", _nstr(key), key->written);
        return NULL;
    }
 
    for (size_t i = 0; i < key->written; ++i) {
        if (!isalpha(key->data[i])) {
            n_log(LOG_ERR, "key contain bad char '%c'", key->data[i]);
            return NULL;  // Error
        }
    }
 
    N_STR* dest = NULL;
    if (in_place) {
        dest = input;
    } else {
        dest = nstrdup(input);
    }
 
#ifdef __windows__
    SYSTEM_INFO sysinfo;
    GetSystemInfo(&sysinfo);
    size_t nb_procs = (size_t)sysinfo.dwNumberOfProcessors;
#else
    size_t nb_procs = (size_t)get_nprocs();
#endif
 
    if (nb_procs < 2)
        nb_procs = 2;
 
    THREAD_POOL* thread_pool = new_thread_pool(nb_procs, 0);
 
    size_t bytesteps = input->written / nb_procs;
    if (bytesteps == 0) bytesteps = input->written;
 
    size_t end_pos = 0;
    for (size_t it = 0; it < input->written; it += bytesteps) {
        end_pos = it + bytesteps;
 
        if (end_pos >= input->written)
            end_pos = input->written;
 
        CYPHER_PARAM* params = NULL;
        Malloc(params, CYPHER_PARAM, 1);
        params->input = input;
        params->dest = dest;
        params->key = key;
        params->encipher = encipher;
        params->start_pos = it;
        params->end_pos = end_pos;
 
        if (add_threaded_process(thread_pool, &n_vigenere_cypher_thread, (void*)(intptr_t)params, DIRECT_PROC) == FALSE) {
            n_log(LOG_ERR, "Error adding n_vigenere_cypher_thread to thread pool");
        }
        refresh_thread_pool(thread_pool);
        usleep(1);
    }
    if (end_pos < input->written) {
        CYPHER_PARAM* params = NULL;
        Malloc(params, CYPHER_PARAM, 1);
        params->input = input;
        params->dest = dest;
        params->key = key;
        params->encipher = encipher;
        params->start_pos = end_pos;
        params->end_pos = input->written;
 
        if (add_threaded_process(thread_pool, &n_vigenere_cypher_thread, (void*)(intptr_t)params, DIRECT_PROC) == FALSE) {
            n_log(LOG_ERR, "Error adding n_vigenere_cypher_thread to thread pool");
        }
        refresh_thread_pool(thread_pool);
        usleep(1);
    }
    wait_for_threaded_pool(thread_pool, 100000);
    destroy_threaded_pool(&thread_pool, 100000);
 
    /*
       uint32_t nonAlphaCharCount = 0;
       for( uint32_t i = 0 ; i < input -> written ; i++ )
       {
       char ch = input -> data[ i ];
       if( isalpha( input -> data[ i ] ) )
       {
       bool cIsUpper = isupper( input -> data[ i ] );
       char offset = cIsUpper ? 'A' : 'a';
       int keyIndex = ( i - nonAlphaCharCount ) % key -> written ;
       int k = ( cIsUpper ? toupper( key -> data[ keyIndex % key -> written ] ) : tolower( key -> data[ keyIndex % key -> written ] ) ) - offset ;
       k = encipher ? k : -k;
       ch = (char)( ( n_mathmod( ( ( input -> data[ i ] + k ) - offset ) , 26 ) ) + offset );
       }
       else
       {
       ++nonAlphaCharCount;
       }
       dest -> data[ i ] = ch;
       }
       */
 
    return dest;
}
 
N_STR* n_vigenere_encode(N_STR* string, N_STR* key) {
    return n_vigenere_cypher(string, key, 1, 0);
}
 
N_STR* n_vigenere_decode(N_STR* string, N_STR* key) {
    return n_vigenere_cypher(string, key, 0, 0);
}
 
N_STR* n_vigenere_encode_in_place(N_STR* string, N_STR* key) {
    return n_vigenere_cypher(string, key, 1, 1);
}
 
N_STR* n_vigenere_decode_in_place(N_STR* string, N_STR* key) {
    return n_vigenere_cypher(string, key, 0, 1);
}
 
N_STR* n_vigenere_quick_encode(N_STR* decoded_data) {
    N_STR* __internal_root_key_nstr = char_to_nstr(__internal_root_key);
 
    N_STR* base64_data = n_base64_encode(decoded_data);
    N_STR* encoded_data = n_vigenere_encode_in_place(base64_data, __internal_root_key_nstr);
    free_nstr(&__internal_root_key_nstr);
 
    return encoded_data;
}
 
N_STR* n_vigenere_quick_decode(N_STR* encoded_data) {
    N_STR* __internal_root_key_nstr = char_to_nstr(__internal_root_key);
 
    N_STR* decoded_data = n_vigenere_decode(encoded_data, __internal_root_key_nstr);
    N_STR* base64_data = n_base64_decode(decoded_data);
 
    free_nstr(&__internal_root_key_nstr);
    free_nstr(&decoded_data);
 
    return base64_data;
}
 
N_STR* n_vigenere_get_question(size_t question_size) {
    size_t it = 0;
 
    if ((question_size % 2) != 0) {
        n_log(LOG_ERR, "odd number of elements for question size, %d", question_size);
        return NULL;
    }
 
    N_STR* output = NULL;
    output = n_get_current_dir_hd_serial();
 
    N_STR* cpu_id = n_get_cpu_id();
    nstrprintf_cat(output, "@%s", _nstr(cpu_id));
    free_nstr(&cpu_id);
 
    if (output) {
        N_STR* tmpoutput = n_base64_encode(output);
        free_nstr(&output);
        output = new_nstr(question_size + 1);
        for (it = 0; it < question_size; it++) {
            int val = tmpoutput->data[it % tmpoutput->written];
            while (val < 'A') val += 26;
            while (val > 'Z') val -= 26;
            output->data[it] = (char)val;
        }
        output->written = question_size;
        free_nstr(&tmpoutput);
    } else {
        // generate random
        output = new_nstr(question_size + 1);
        for (it = 0; it < question_size; it++) {
            int val = rand() % 256;
            while (val < 'A') val += 26;
            while (val > 'Z') val -= 26;
            output->data[it] = (char)val;
        }
    }
 
    N_STR* encoded_data = n_vigenere_quick_encode(output);
    free_nstr(&output);
 
    it = 0;
    while (it < encoded_data->written) {
        if (encoded_data->data[it] == '=') {
            encoded_data->data[it] = '\0';
        }
        it++;
    }
    return encoded_data;
}
 
N_STR* n_vigenere_get_answer(N_STR* root_key, N_STR* question) {
    __n_assert(root_key, return NULL);
    __n_assert(question, return NULL);
 
    N_STR* decoded_question = n_vigenere_quick_decode(question);
 
    if (root_key->written < decoded_question->written) {
        n_log(LOG_ERR, "root key of size %d is lower than question key of size %d", root_key->written, decoded_question->written);
        free_nstr(&decoded_question);
        return NULL;
    }
    if ((root_key->written % decoded_question->written) != 0) {
        n_log(LOG_ERR, "question key of size %d is not a multiple of root key of size %d", decoded_question->written, root_key->written);
        free_nstr(&decoded_question);
        return NULL;
    }
 
    N_STR* answer = new_nstr(root_key->length + 1);
    for (uint32_t it = 0; it < root_key->written; it++) {
        int32_t val = (root_key->data[it % root_key->written] - 'A') + (decoded_question->data[it % decoded_question->written] - 'A');
        val = val % 26;
        val = val + 'A';
        answer->data[it] = (char)val;
    }
    free_nstr(&decoded_question);
    answer->written = root_key->written;
    return answer;
}
 
int n_vigenere_encode_file(N_STR* in, N_STR* out, N_STR* key) {
    __n_assert(in, return FALSE);
    __n_assert(out, return FALSE);
    __n_assert(key, return FALSE);
 
    if ((key->written % 2) != 0) {
        n_log(LOG_ERR, "odd number of elements in key %s, %d", _nstr(key), key->written);
        return FALSE;
    }
 
    N_STR* file = file_to_nstr(_nstr(in));
    if (!file) {
        n_log(LOG_ERR, "error loading %s", _nstr(in));
        return FALSE;
    }
 
    N_STR* base64_data = n_base64_encode(file);
    free_nstr(&file);
 
    if (!base64_data) {
        n_log(LOG_ERR, "Could not base64 decode data from file %s", _nstr(in));
        return FALSE;
    }
 
    N_STR* encoded_data = n_vigenere_encode_in_place(base64_data, key);
    if (!encoded_data) {
        n_log(LOG_ERR, "Could not decode data from file %s", _nstr(in));
        return FALSE;
    }
 
    int ret = nstr_to_file(encoded_data, _nstr(out));
    free_nstr(&encoded_data);
 
    return ret;
}
 
int n_vigenere_decode_file(N_STR* in, N_STR* out, N_STR* key) {
    __n_assert(in, return FALSE);
    __n_assert(out, return FALSE);
    __n_assert(key, return FALSE);
 
    if ((key->written % 2) != 0) {
        n_log(LOG_ERR, "odd number of elements in key %s , %d", _nstr(key), key->written);
        return FALSE;
    }
 
    N_STR* file = file_to_nstr(_nstr(in));
    if (!file) {
        n_log(LOG_ERR, "error loading %s", _nstr(in));
        return FALSE;
    }
 
    N_STR* decoded_data = n_vigenere_decode_in_place(file, key);
    if (!decoded_data) {
        n_log(LOG_ERR, "Could not decode data from file %s", _nstr(in));
        return FALSE;
    }
 
    N_STR* base64_data = n_base64_decode(decoded_data);
    free_nstr(&decoded_data);
    if (!base64_data) {
        n_log(LOG_ERR, "Could not base64 decode data from file %s", _nstr(in));
        return FALSE;
    }
 
    int ret = nstr_to_file(base64_data, _nstr(out));
    free_nstr(&base64_data);
 
    return ret;
}
 
N_STR* n_vigenere_encode_qa(N_STR* input_data, N_STR* question, N_STR* answer) {
    __n_assert(input_data, return NULL);
    __n_assert(question, return NULL);
    __n_assert(answer, return NULL);
 
    N_STR* b64_encoded = n_base64_encode(input_data);
    if (!b64_encoded) {
        n_log(LOG_ERR, "could not base64 decode: input_data %p", input_data);
        return NULL;
    }
 
    N_STR* encoded_with_answer_data = n_vigenere_encode_in_place(b64_encoded, answer);
    if (!encoded_with_answer_data) {
        n_log(LOG_ERR, "could not encode: input_data %p", input_data);
        return NULL;
    }
 
    N_STR* decoded_question = n_vigenere_quick_decode(question);
    N_STR* encoded_data = n_vigenere_decode_in_place(encoded_with_answer_data, decoded_question);
    free_nstr(&decoded_question);
    if (!encoded_data) {
        n_log(LOG_ERR, "could not decode: input_data %p", input_data);
        return NULL;
    }
 
    return encoded_data;
}
 
N_STR* n_vigenere_decode_qa(N_STR* input_data, N_STR* question, N_STR* answer) {
    __n_assert(input_data, return NULL);
    __n_assert(input_data->data, return NULL);
    __n_assert(question, return NULL);
    __n_assert(question->data, return NULL);
    __n_assert(answer, return NULL);
    __n_assert(answer->data, return NULL);
 
    N_STR* decoded_question = n_vigenere_quick_decode(question);
 
    N_STR* encoded_data = n_vigenere_encode(input_data, decoded_question);
    free_nstr(&decoded_question);
    if (!encoded_data) {
        n_log(LOG_ERR, "could not encode input_data %p", input_data);
        return NULL;
    }
    n_log(LOG_DEBUG, "encoded_data: %d/%d", encoded_data->written, encoded_data->length);
 
    N_STR* encoded_with_answer_data = n_vigenere_decode_in_place(encoded_data, answer);
    if (!encoded_with_answer_data) {
        n_log(LOG_ERR, "could not decode: input_data %p", input_data);
        return NULL;
    }
    n_log(LOG_DEBUG, "encoded_with_answer_data: %d/%d", encoded_with_answer_data->written, encoded_with_answer_data->length);
 
    N_STR* b64_decoded = n_base64_decode(encoded_with_answer_data);
    free_nstr(&encoded_with_answer_data);
    if (!b64_decoded) {
        n_log(LOG_ERR, "could not base64 decode: input_data %p", input_data);
        return NULL;
    }
    n_log(LOG_DEBUG, "b64_decoded: %d/%d", b64_decoded->written, b64_decoded->length);
    return b64_decoded;
}
 
int n_vigenere_decode_file_qa(N_STR* in, N_STR* out, N_STR* question, N_STR* answer) {
    __n_assert(in, return FALSE);
    __n_assert(out, return FALSE);
    __n_assert(question, return FALSE);
    __n_assert(answer, return FALSE);
 
    N_STR* input_data = file_to_nstr(_nstr(in));
    if (!input_data) {
        n_log(LOG_ERR, "could not load input file %s", _nstr(in));
        return FALSE;
    }
 
    N_STR* decoded = n_vigenere_decode_qa(input_data, question, answer);
    free_nstr(&input_data);
 
    int ret = nstr_to_file(decoded, _nstr(out));
    free_nstr(&decoded);
 
    return ret;
}
 
int n_vigenere_encode_file_qa(N_STR* in, N_STR* out, N_STR* question, N_STR* answer) {
    __n_assert(in, return FALSE);
    __n_assert(out, return FALSE);
    __n_assert(question, return FALSE);
    __n_assert(answer, return FALSE);
 
    N_STR* input_data = file_to_nstr(_nstr(in));
    if (!input_data) {
        n_log(LOG_ERR, "could not load input file %s", _nstr(in));
        return FALSE;
    }
 
    N_STR* encoded = n_vigenere_encode_qa(input_data, question, answer);
    free_nstr(&input_data);
 
    int ret = nstr_to_file(encoded, _nstr(out));
    free_nstr(&encoded);
 
    return ret;
}