libreCMC/package/luci/libs/luci-lib-nixio/axTLS/ssl/test/datatest.c.old

#include "crypto.h"

#include <string.h>
#include <stdlib.h>
//#define DEBUG_TEST 

typedef enum {
    encrypt, decrypt
} CryptoMode;

void hex_dump(const char* header, const unsigned char* data, const unsigned int data_length)
{
    unsigned int byte_count;
    printf("%s (%d bytes):\n", header, data_length);
    for(byte_count = 0; byte_count < data_length; ++byte_count)
    {
        printf("%02X", data[byte_count]);
    }
    printf("\n");
}

void do_rsa(const CryptoMode crypto_mode,
            const unsigned char* data, const unsigned int data_length,
            const unsigned char* modulus, const unsigned int modulus_length,
            const unsigned char* exponent, const unsigned int exponent_length,
            unsigned char* result, const unsigned int result_length)
{
    RSA_CTX* rsa_context = NULL;
    BI_CTX *bi_ctx;
    bigint *plaintext_bi;
    bigint *enc_data_bi, *dec_data_bi;

#ifdef DEBUG_TEST
    printf("do_rsa:\n");
    hex_dump("data", data, data_length);
    hex_dump("modulus", modulus, modulus_length);
    hex_dump("exponent", exponent, exponent_length);
#endif

    RSA_priv_key_new(&rsa_context, modulus, modulus_length, exponent, exponent_length, exponent, exponent_length);
    memset(result, 0, result_length);
    bi_ctx = rsa_context->bi_ctx;

    switch(crypto_mode)
    {
    case encrypt:
#ifdef DEBUG_TEST
        printf("encrypt\n");
#endif
        plaintext_bi = bi_import(bi_ctx, data, data_length);
        enc_data_bi = RSA_public(rsa_context, plaintext_bi);
        bi_export(bi_ctx, enc_data_bi, result, result_length);
        break;

    case decrypt:

#ifdef DEBUG_TEST
        printf("decrypt\n");
#endif
        plaintext_bi = bi_import(bi_ctx, data, data_length);
        dec_data_bi = RSA_private(rsa_context, plaintext_bi);
        bi_export(bi_ctx, dec_data_bi, result, result_length);
        break;
    }
#ifdef DEBUG_TEST
    hex_dump("result", result, result_length);
#endif

    RSA_free(rsa_context);
}

void test_matching(char* test_description, 
                   const unsigned char* expected, const unsigned int expected_length,
                   const unsigned char* result, const unsigned int result_length)
{
    int test_result = memcmp(expected, result, expected_length);
    printf("Testing %s ... ", test_description);
    if(test_result == 0)
    {
        printf("ok.\n");
    }
    else
    {
        printf("failed!\n");
        hex_dump("should be", expected, expected_length);
        hex_dump("but is", result, result_length);
    }
}

void encrypt_decrypt_should_yield_original(char* test_description,
                                           const unsigned char* data, const unsigned int data_length,
                                           const unsigned char* modulus, const unsigned int modulus_length,
                                           const unsigned char* private_exponent, const unsigned int private_exponent_length,
                                           const unsigned char* public_exponent, const unsigned int public_exponent_length,
                                           const unsigned char* cryptogram, const unsigned int cryptogram_length)
{
    const unsigned int calculated_cryptogram_length = modulus_length;
    unsigned char* calculated_cryptogram = malloc(calculated_cryptogram_length);
    const unsigned int decrypted_data_length = modulus_length;
    unsigned char* decrypted_data = malloc(decrypted_data_length);

    printf("\nRunning \"%s\" ...\n", test_description);

#ifdef DEBUG_TEST
    printf("encrypt_decrypt_should_yield_original:\n");
    hex_dump("data", data, data_length);
    hex_dump("modulus", modulus, modulus_length);
    hex_dump("private_exponent", private_exponent, private_exponent_length);
    hex_dump("public_exponent", public_exponent, public_exponent_length);
    hex_dump("cryptogram", cryptogram, cryptogram_length);
#endif

    do_rsa(encrypt, data, data_length,
           modulus, modulus_length,
           private_exponent, private_exponent_length,
           calculated_cryptogram, calculated_cryptogram_length);

#ifdef DEBUG_TEST
    hex_dump("calculated_cryptogram", calculated_cryptogram, calculated_cryptogram_length);
#endif

    if(cryptogram != NULL)
    {
        test_matching("cryptogram", cryptogram, cryptogram_length, 
                                    calculated_cryptogram, calculated_cryptogram_length);
    }

    do_rsa(decrypt, calculated_cryptogram, calculated_cryptogram_length,
           modulus, modulus_length,
           public_exponent, public_exponent_length,
           decrypted_data, decrypted_data_length);

    test_matching("decrypted plaintext", data, data_length,
                                         decrypted_data, decrypted_data_length);

    free(calculated_cryptogram);
    free(decrypted_data);
}

/* configure without CRT!

   prepare data with: 
   > echo "<string>" |
     ruby -ne '$_.gsub!(/ /, "").scan(/../).each_with_index \
      { |b, i| print "\"\n\"" if i % 16 == 0; print "\\x" + b;}' */
int main(int argc, char *argv[])
{
#if 0
    unsigned char stuff[] = { 
        0x22, 0x33, 0x44, 0x81, 
        0xF1, 0xFF, 0xAA, 0xBB, 
        0xCC, 0xDD, 0xEE , 0x01,
        0x45, 0x44, 0xfa, 0x8d,
        0xfa, 0x20, 0x99, 0xFF,
        0xab, 0xda, 0xac, 0x40 };
    unsigned char resA[sizeof(stuff)*2], resB[sizeof(stuff)*2];

    BI_CTX *bi_ctx = bi_initialize();
    bigint *bi_data1, *bi_data2, *res1, *res2;
    bi_data1 = bi_import(bi_ctx, stuff, sizeof(stuff));
    bi_data2 = bi_import(bi_ctx, stuff, sizeof(stuff));

    res1 = bi_multiply(bi_ctx, bi_copy(bi_data1), bi_copy(bi_data2));
    res2 = bi_multiply(bi_ctx, bi_data1, bi_data2);
    bi_print("MULTIPLY", res1);
    bi_print("SQUARE", res2);
    bi_export(bi_ctx, res1, resA, sizeof(resA));
    bi_export(bi_ctx, res2, resB, sizeof(resB));
    if (memcmp(resA, resB, sizeof(resA)))
        printf("OUCH - difference!\n");
    bi_terminate(bi_ctx);

    exit(0);
#endif
    encrypt_decrypt_should_yield_original("Works only with Montgomery",
        (const unsigned char*) /* data */
        "\xBC\xD3\x12\x6C\x93\x13\x14\x4C\x00\x5D\xFD\xBF\xDE\xE4\xD3\x60"
        "\x29\xB8\xAE\x47\xBE\x0B\xB6\x0A\x39\x88\xB7\x93\x19\x14\xE8\x88"
        "\x4A\xDE\x00\x46\x89\x5A\x11\x1A\xC4\x8F\xE8\xF7\x27\xAC\x59\x80"
        "\x03\xC1\x93\x14\x01\x00\x93\x15\x07\x00\x00\x00\x01\x01\x05\x20"
        "\x93\x16\x0F\x42\x34\x33\x3A\x58\x30\x30\x30\x31\x30\x31\x30\x30"
        "\x30\x31\x92\x6B\x10\x6C\x69\x62\x65\x6C\x6D\x65\x74\x72\x65\x65"
        "\x2E\x73\x6F\x2E\x30\x93\x18\x02\xA5\x92\x92\x6C\x03\x96\xE3\x0C"
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xB7\xBE", 128,
        (const unsigned char*) /* modulus */
        "\xc4\x5a\xcb\x35\x95\xad\x32\x4a\xcf\x9c\x82\x45\x13\xb7\x42\x35"
        "\x22\x32\x6d\x2e\x6d\x26\x2e\x6d\x00\x9b\xae\x2d\x9e\x78\x1e\xdd"
        "\x40\x23\x17\xa8\xbb\xa1\x07\x86\xb4\x3c\xbc\xe8\xd5\xfc\xd9\xeb"
        "\x3c\xad\x63\x11\xf3\x1d\x64\x81\x96\xf2\xf5\xfe\xca\x5a\xf7\x8a"
        "\x15\xcb\x90\x81\x68\xae\x59\xb4\xe1\xa4\x41\x99\xcd\xf3\x98\xbd"
        "\x3c\x48\x37\xdb\xa1\xc3\x1c\x6f\x43\xd1\x89\x23\xe5\x3d\xa3\xa5"
        "\x92\x7b\x19\x14\x1e\x7a\xf3\x88\x8a\x36\x21\x3e\x16\x40\x3c\xd7"
        "\xd3\xdb\x13\xaf\xc9\x68\x45\x84\xb3\x39\x8f\x02\xed\x28\x02\x5f", 128,
        (const unsigned char*) /* private exponent */
        "\x5d\x19\xb7\xb4\x66\x8d\xc2\x84\xda\x3f\x99\x3c\xeb\x86\x3e\xec"
        "\x36\x94\xb6\x54\x07\x08\xcd\x86\x7d\x7d\x53\x6e\xe9\xee\x86\xa3"
        "\xdd\x5f\x46\x3e\x89\x08\x67\x2b\x25\x96\x8e\xf3\xcf\x52\x9e\x78"
        "\xfd\x42\x30\xf1\x37\xd6\xbd\xea\xfc\x09\xa3\x3d\xf5\xf0\x7f\xe1"
        "\xb1\xe0\x69\x13\x44\xf9\x8b\x95\x58\x2a\x81\xb3\xa8\x15\xce\x7e"
        "\xd3\xea\x97\x0a\xa2\x14\xd4\xae\xc7\x75\xbb\x9f\x68\xa5\x53\x0e"
        "\x85\x29\x88\x48\x6c\xc9\xcc\xde\x72\x40\x3a\x4c\x82\xde\x3c\xfb"
        "\x08\xf8\x2c\x26\xb5\xd4\xea\xc4\xca\x98\x6e\x43\x3e\x67\x54\xc1", 128,
        (const unsigned char*) /* public exponent */
        "\x01\x00\x01", 3,
        (const unsigned char*) /* precalculated encrypted data */
        "\x93\xE8\x1F\xF9\x70\xFA\xAA\xED\x54\xFD\x48\x37\xC9\x71\x9A\x11"
        "\x69\x80\xB4\x22\x0C\xAD\x5A\x95\x65\xCA\x7C\xF7\x70\x56\x92\xCB"
        "\x45\x6D\x58\x84\x21\x80\x23\x76\x21\x4A\x61\x99\xC1\x11\x9C\x0F"
        "\x40\xED\x80\x9C\x8F\x3A\x4F\x01\xB5\x72\xC3\x24\xAE\xF3\x6B\x98"
        "\xA8\x60\xAC\xAF\x95\x98\x9A\xAA\xA4\x28\xF2\x02\x05\xFC\xF3\xDD"
        "\xB0\x5A\x4E\xDE\x3C\x41\x4B\x1C\x5B\x1F\xF6\x3D\xAF\x93\x43\xCB"
        "\xD8\xC7\x24\x97\x8F\x49\xE5\x5B\x10\x51\x3B\x1E\xA6\x39\xEA\x4E"
        "\xA5\xE0\x71\x8C\xCA\x34\x8C\x2F\x6C\x5C\x78\x34\x86\x7C\x54\x6A", 128);

    encrypt_decrypt_should_yield_original("Works only with Barrett",
        (const unsigned char*) /* data */
        "\x36\x42\x32\xe4\x1e\x78\x02\x8e\xfb\x64\x5f\x0c\xfc\x5a\xd7\x5c"
        "\xe4\xb5\x91\x5c\x4b\x00\x87\x28\x87\x9b\xa0\x4b\x09\xc2\x6b\x64"
        "\xac\x4b\xcf\xa5\xee\x8a\xb7\xc9\xc9\x90\x02\xc1\xa3\x47\x5c\x6b"
        "\x71\x5d\x5d\x49\x27\xe1\x15\xc6\xcf\x37\x9e\xa7\x0f\xa1\xad\x96"
        "\x83\xef\x4b\x53\x68\xcd\x77\xfc\x14\x5f\xf5\xb7\x78\xb0\x10\xeb"
        "\x0d\x61\x94\x01\xf6\xaa\x1b\x19\x23\x39\xa7\xcc\x6c\x42\x4a\x87"
        "\x79\x27\x04\xc6\xec\x8e\x50\xba\xb9\x26\x89\xd4\x00\x01\x25\xe5"
        "\xf3\x9e\x98\x0c\x8d\x2e\x43\x1e\xe9\x29\x90\xd2\x75\x61\x85\xe7", 128,
        (const unsigned char*) /* modulus */
        "\x37\x0c\x32\xe4\x1e\x78\x02\x8e\xfb\x64\x5f\x0c\xfc\x5a\xd7\x5c"
        "\xe4\xb5\x91\x5c\x4b\x00\x87\x28\x87\x9b\xa0\x4b\x09\xc2\x6b\x64"
        "\xac\x4b\xcf\xa5\xee\x8a\xb7\xc9\xc9\x90\x02\xc1\xa3\x47\x5c\x6b"
        "\x71\x5d\x5d\x49\x27\xe1\x15\xc6\xcf\x37\x9e\xa7\x0f\xa1\xad\x96"
        "\x83\xef\x4b\x53\x68\xcd\x77\xfc\x14\x5f\xf5\xb7\x78\xb0\x10\xeb"
        "\x0d\x61\x94\x01\xf6\xaa\x1b\x19\x23\x39\xa7\xcc\x6c\x42\x4a\x87"
        "\x79\x27\x04\xc6\xec\x8e\x50\xba\xb9\x26\x89\xd4\x00\x01\x25\xe5"
        "\xf3\x9e\x98\x0c\x8d\x2e\x43\x1e\xe9\x29\x90\xd2\x75\x61\x85\xe7", 128,
        (const unsigned char*) /* private exponent */
        "\x16\x3a\x76\xd2\x66\xfb\x4f\x0d\x2d\xb6\x7a\x2b\x64\x3b\xca\x7b"
        "\x58\x5f\x79\x33\x2b\x96\x2a\xfd\xd2\xc4\xa5\x15\xa7\xfb\x3a\x22"
        "\x8c\xf0\x90\x09\x11\x2a\x32\xcc\xe8\xf7\x9e\x25\x53\x29\x9d\xc8"
        "\x45\x1e\xce\x6c\x9c\x0d\xe8\x1d\x3f\xcf\xd5\xe0\xe0\x0f\x09\x69"
        "\x2d\xe7\xd5\xe6\xe5\x10\xd9\x4e\x20\xdb\xbd\xa1\x04\x6b\xe6\x1d"
        "\x4c\x79\x28\x47\x30\x11\xde\x14\xb4\x6e\x35\x98\x38\x50\x44\x82"
        "\xbd\xc4\xfb\x03\xb3\xf6\x5e\x5a\x29\xfa\x29\xaa\xde\xe4\xfd\x15"
        "\xbe\xed\x4f\x93\x9d\x0d\x29\xe8\xd7\xa3\xf4\x18\xc8\x98\xb1\x01", 128, 
        (const unsigned char*) /* public exponent */
        "\x01\x00\x01", 3,
        NULL, 0);

    encrypt_decrypt_should_yield_original("Works always",
        (const unsigned char*) /* data */
        "\xB9\x42\x32\xe4\x1e\x78\x02\x8e\xfb\x64\x5f\x0c\xfc\x5a\xd7\x5c"
        "\xe4\xb5\x91\x5c\x4b\x00\x87\x28\x87\x9b\xa0\x4b\x09\xc2\x6b\x64"
        "\xac\x4b\xcf\xa5\xee\x8a\xb7\xc9\xc9\x90\x02\xc1\xa3\x47\x5c\x6b"
        "\x71\x5d\x5d\x49\x27\xe1\x15\xc6\xcf\x37\x9e\xa7\x0f\xa1\xad\x96"
        "\x83\xef\x4b\x53\x68\xcd\x77\xfc\x14\x5f\xf5\xb7\x78\xb0\x10\xeb"
        "\x0d\x61\x94\x01\xf6\xaa\x1b\x19\x23\x39\xa7\xcc\x6c\x42\x4a\x87"
        "\x79\x27\x04\xc6\xec\x8e\x50\xba\xb9\x26\x89\xd4\x00\x01\x25\xe5"
        "\xf3\x9e\x98\x0c\x8d\x2e\x43\x1e\xe9\x29\x90\xd2\x75\x61\x85\xe7", 128,
        (const unsigned char*) /* modulus */
        "\xB9\x77\xEC\x83\x95\xAF\xB1\xF8\x21\x21\xFF\x05\x5E\x0C\x91\x0C"
        "\x2E\xD5\xD2\x94\x1C\x38\x5E\xED\x5A\xCF\x84\xD0\x12\x8B\xAA\x4B"
        "\x3A\x63\x65\x78\x13\xED\x24\x4E\x83\xF2\xF5\x02\x66\x5D\xFC\xC1"
        "\x80\x5B\x78\x78\xB4\x0B\x45\xE5\x22\xC6\xCD\xEB\xCC\x74\x0B\x0B"
        "\xD8\x8B\x91\x99\x48\x8E\x74\xA9\xD0\x1A\x39\x94\xC2\xD4\x2E\x9A"
        "\x8C\x0C\x35\x0D\x97\x8F\xC4\x62\x20\xE9\x78\x40\x97\x05\x98\xE6"
        "\x22\x48\x3D\x3D\xCA\x6A\x3F\xEF\xB0\x23\x14\x30\xDA\x35\x46\x65"
        "\x55\xEF\xEB\xA1\xA9\xCF\x83\xE7\xEF\xF2\x83\x6D\x38\xEA\x88\xED", 128,
        (const unsigned char*) /* private exponent */
        "\x52\x2A\x68\xE3\x9A\xAA\xED\xA3\x49\xBA\x6F\xEA\x86\xD1\xF6\x68"
        "\x79\x4F\x4D\x2D\x44\x9B\x4C\xA2\xC6\xBA\x6C\xD2\x69\x84\xEA\x7A"
        "\xCD\x71\x3F\x80\xC5\x03\x28\x34\x88\x8C\x58\x33\x29\xFA\xB5\x81"
        "\x5C\x46\x29\xC6\xFF\xAC\x86\xD8\x8E\x61\x98\xD4\xC0\x0D\x20\xDE"
        "\xEB\x61\x1C\x0C\x3C\x19\xA3\x75\x10\x7D\xDA\xA9\x55\xA7\x64\x5F"
        "\xE0\xB6\x35\x62\x00\xD9\xD2\xF7\xA4\xDF\x85\xFF\xDF\x86\x75\x29"
        "\x66\x16\x03\x8C\xC0\xB0\x3F\xAB\xBA\x41\xB3\x3C\x76\x58\xB6\xE2"
        "\x1F\x36\x47\x5F\x1F\x0E\x4C\xB5\x29\x90\xDC\xA1\xF8\xFA\x58\x19", 128,
        (const unsigned char*) /* public exponent */
        "\x01\x00\x01", 3,
        NULL, 0);

    return 0;
}