examples/ex_crypto.c

Functions

	Name
int	main(int argc, char * argv[])

Functions Documentation

function main

int main(
    int argc,
    char * argv[]
)

Source code

/*
 * Nilorea Library
 * Copyright (C) 2005-2026 Castagnier Mickael
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */


#include "nilorea/n_log.h"
#include "nilorea/n_list.h"
#include "nilorea/n_str.h"
#include "nilorea/n_base64.h"
#include "nilorea/n_crypto.h"

int main(int argc, char* argv[]) {
    void usage(void) {
        fprintf(stderr,
                "%s usage:\n"
                "     -i input_file [optional] use a file as datas instead of hard coded 3 lines text\n"
                "     -v version\n"
                "     -V log level: LOG_INFO, LOG_NOTICE, LOG_ERR, LOG_DEBUG\n"
                "     -h help\n",
                argv[0]);
    }

    int getoptret = 0, ret = 0,
        log_level = LOG_DEBUG; /* default log level */

    N_STR* input_name = NULL;

    /* Arguments optionnels */
    /* -v version
     * -V log level
     * -h help
     */
    while ((getoptret = getopt(argc, argv, "i:hvV:")) != EOF) {
        switch (getoptret) {
            case 'i':
                input_name = char_to_nstr(optarg);
                break;
            case 'v':
                fprintf(stderr, "Date de compilation : %s a %s.\n", __DATE__, __TIME__);
                exit(1);
            case 'V':
                if (!strcmp("LOG_NULL", optarg))
                    log_level = LOG_NULL;
                else if (!strcmp("LOG_NOTICE", optarg))
                    log_level = LOG_NOTICE;
                else if (!strcmp("LOG_INFO", optarg))
                    log_level = LOG_INFO;
                else if (!strcmp("LOG_ERR", optarg))
                    log_level = LOG_ERR;
                else if (!strcmp("LOG_DEBUG", optarg))
                    log_level = LOG_DEBUG;
                else {
                    fprintf(stderr, "%s n'est pas un niveau de log valide.\n", optarg);
                    exit(-1);
                }
                break;
            default:
            case '?': {
                if (optopt == 'V') {
                    fprintf(stderr, "                                  =>      Missing log level\n");
                } else if (optopt == 'p') {
                    fprintf(stderr, "                                  =>      Missing port\n");
                } else if (optopt == 'i') {
                    fprintf(stderr, "                                  =>      Missing filename\n");
                } else if (optopt != 's') {
                    fprintf(stderr, "                                  =>      Unknow missing option %c\n", optopt);
                }
                usage();
                exit(1);
            }
            case 'h': {
                usage();
                exit(1);
            }
        }
    }
    set_log_level(log_level);

    N_STR* EXAMPLE_TEXT = char_to_nstr(
        "##############################################################\n"
        "# This is an example of crypto encode/decode, with a newline #\n"
        "# This is the end of the test                                #\n"
        "##############################################################");

    n_log(LOG_NOTICE, "Testing crypto, encoding text of size (%ld/%ld):\n%s", EXAMPLE_TEXT->written, EXAMPLE_TEXT->length, _nstr(EXAMPLE_TEXT));
    /*                                   10        20        30        40        50        60     */
    /*                         "1234567890123456789012345678901234567890123456789012345678901234" */
    /* test n_vigenere_get_rootkey */
    N_STR* rootkey = n_vigenere_get_rootkey(128);
    n_log(LOG_DEBUG, "n_vigenere_get_rootkey(128): %s", _nstr(rootkey));
    free_nstr(&rootkey);

    N_STR* key = char_to_nstr("RKCHSLZWFNASULJFVPRVUUUAEUVEMSSGEVNWIMVPZVIWITBGIUBEQVEURBYEWTMCQZZYNWQMRAIBTMHDIKIZHOVZQUFONRQDSRDFNTTGVEKOSTSAEABLOXMGTTWIMPNE");
    n_log(LOG_DEBUG, "key= %s", _nstr(key));

    N_STR* B64_EXAMPLE_TEXT = n_base64_encode(EXAMPLE_TEXT);
    N_STR* encoded_data = n_vigenere_encode(B64_EXAMPLE_TEXT, key);
    n_log(LOG_DEBUG, "encoded data=\n%s", _nstr(encoded_data));

    N_STR* decoded_data = n_vigenere_decode(encoded_data, key);
    N_STR* unbase64 = n_base64_decode(decoded_data);
    n_log(LOG_DEBUG, "decoded data=\n%s", _nstr(unbase64));
    free_nstr(&unbase64);

    /* test n_vigenere_quick_encode / n_vigenere_quick_decode */
    N_STR* quick_src = char_to_nstr("quick encode test");
    N_STR* quick_enc = n_vigenere_quick_encode(quick_src);
    n_log(LOG_DEBUG, "n_vigenere_quick_encode: %s", _nstr(quick_enc));
    N_STR* quick_dec = n_vigenere_quick_decode(quick_enc);
    n_log(LOG_DEBUG, "n_vigenere_quick_decode: %s", _nstr(quick_dec));
    free_nstr(&quick_src);
    free_nstr(&quick_enc);
    free_nstr(&quick_dec);

    N_STR* encoded_question = n_vigenere_get_question(128);
    N_STR* decoded_question = n_vigenere_quick_decode(encoded_question);
    n_log(LOG_DEBUG, "encoded_question: %s", _nstr(encoded_question));
    n_log(LOG_DEBUG, "decoded_question: %s", _nstr(decoded_question));
    free_nstr(&decoded_question);

    N_STR* answer = n_vigenere_get_answer(key, encoded_question);
    n_log(LOG_DEBUG, "answer: %s", _nstr(answer));

    N_STR* decode_qa = n_vigenere_decode_qa(encoded_data, encoded_question, answer);
    n_log(LOG_DEBUG, "encode root decode qa:\n%s", _nstr(decode_qa));
    free_nstr(&decode_qa);

    N_STR* encode_qa = n_vigenere_encode_qa(EXAMPLE_TEXT, encoded_question, answer);
    n_log(LOG_DEBUG, "encode qa:\n%s", _nstr(encode_qa));

    decode_qa = n_vigenere_decode_qa(encode_qa, encoded_question, answer);
    n_log(LOG_DEBUG, "encode qa decode qa:\n%s", _nstr(decode_qa));
    free_nstr(&decode_qa);

    N_STR* decode_qa_root = n_vigenere_decode(encode_qa, key);
    unbase64 = n_base64_decode(decode_qa_root);
    n_log(LOG_DEBUG, "encode qa - decode root:\n%s", _nstr(unbase64));

    free_nstr(&decode_qa_root);
    free_nstr(&encode_qa);

    if (input_name) {
        N_STR* output_name_enc = NULL;
        N_STR* output_name_dec = NULL;
        N_STR* output_name_dec_question = NULL;

        nstrprintf(output_name_enc, "%s.crypt_encoded", _nstr(input_name));
        if (n_vigenere_encode_file(input_name, output_name_enc, key)) {
            n_log(LOG_DEBUG, "Encoded file saved in %s", _nstr(output_name_enc));

            nstrprintf(output_name_dec, "%s.crypt_decoded", _nstr(input_name));
            if (n_vigenere_decode_file(output_name_enc, output_name_dec, key)) {
                n_log(LOG_DEBUG, "Decoded file saved in %s", _nstr(output_name_dec));

                nstrprintf(output_name_dec_question, "%s.crypt_decoded_question", _nstr(input_name));
                if (n_vigenere_decode_file_qa(output_name_enc, output_name_dec_question, encoded_question, answer)) {
                    n_log(LOG_DEBUG, "Decoded with question/answer file saved in %s", _nstr(output_name_dec_question));
                } else {
                    n_log(LOG_ERR, "unable to decode with question answer");
                    ret = 1;
                }
            } else {
                n_log(LOG_ERR, "unable to decode with root key");
                ret = 1;
            }
        } else {
            n_log(LOG_ERR, "unable to encode with root key");
            ret = 1;
        }

        free_nstr(&input_name);
        free_nstr(&output_name_enc);
        free_nstr(&output_name_dec);
        free_nstr(&output_name_dec_question);
    }

    free_nstr(&key);
    free_nstr(&encoded_data);
    free_nstr(&decoded_data);
    free_nstr(&encoded_question);
    free_nstr(&answer);
    free_nstr(&EXAMPLE_TEXT);
    free_nstr(&B64_EXAMPLE_TEXT);
    free_nstr(&unbase64);

    exit(ret);
} /* END_OF_MAIN */