--- /dev/null
+#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;
+}
projects / project / luci.git / blobdiff