TESTS: initial test suite implementation

.gitignore

@@ -30,6 +30,8 @@ install/
 *.pdf
 *.dec
 *.enc
+tests/test-file.out
+tests/ntru_cunit
 
 
 # tmp files

.travis.yml

@@ -29,6 +29,7 @@ before_script:
     - cd ../..
 script:
     - make CC=clang
+    - make CC=clang check
     - make doc
 after_script:
     - ./update-gh-pages.sh

Makefile

@@ -15,9 +15,16 @@ uninstall:
 	$(MAKE) -C src uninstall
 	$(MAKE) -C include uninstall
 
+check:
+	$(MAKE) -C tests check
+
+test:
+	$(MAKE) -C tests check
+
 clean:
 	$(MAKE) -C include clean
 	$(MAKE) -C src clean
+	$(MAKE) -C tests clean
 
 doc:
 	$(MAKE) -C include doc

tests/Makefile

@@ -0,0 +1,47 @@
+include ../common.mk
+
+
+# sources, headers, objects
+CUNIT_SOURCES = \
+				ntru_cunit.c \
+				ntru_file_cunit.c \
+				ntru_poly_cunit.c \
+				ntru_keypair_cunit.c \
+				ntru_encrypt_cunit.c \
+				ntru_decrypt_cunit.c
+
+CUNIT_OBJS = $(patsubst %.c, %.o, $(CUNIT_SOURCES))
+
+CUNIT_HEADERS = \
+				ntru_cunit.h
+
+
+# libs
+LIBS += -L. -lcunit -llz4 -lgmp -lmpfr -lflint \
+		$(shell $(PKG_CONFIG) --libs glib-2.0) -lm
+
+# includes
+INCS = -I. -I../include -I/usr/include/flint $(shell $(PKG_CONFIG) --cflags glib-2.0)
+
+CFLAGS += -D_XOPEN_SOURCE -D_XOPEN_SOURCE_EXTENDED
+
+
+%.o: %.c
+	$(CC) -fPIC $(CFLAGS) $(CPPFLAGS) $(INCS) -c $*.c
+
+check: ntru_cunit
+	./ntru_cunit
+
+test: ntru_cunit
+
+libpqc.a:
+	$(MAKE) -C ../src libpqc.a
+
+ntru_cunit: $(CUNIT_OBJS) $(CUNIT_HEADERS) libpqc.a
+	$(CC) $(CFLAGS) -o $@ $(CUNIT_OBJS) ../src/libpqc.a $(LDFLAGS) $(LIBS)
+
+clean:
+	rm -f *.o ntru_cunit *.orig core test-file.out pub.key
+
+
+.PHONY: check clean test

tests/ntru_cunit.c

@@ -0,0 +1,206 @@
+/*
+ * Copyright (C) 2014 FH Bielefeld
+ *
+ * This file is part of a FH Bielefeld project.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA
+ */
+
+/**
+ * @file ntru_cunit.c
+ * Main cunit file, registering the test suites.
+ * @brief test suite registration
+ */
+
+#include "ntru_cunit.h"
+
+#include <CUnit/Basic.h>
+#include <CUnit/Console.h>
+#include <CUnit/Automated.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+
+int init_suite(void)
+{
+	return 0;
+}
+
+int clean_suite(void)
+{
+	return 0;
+}
+
+int main(void)
+{
+	CU_pSuite pSuite = NULL;
+	int my_stderr;
+
+	/* initialize the CUnit test registry */
+	if (CUE_SUCCESS != CU_initialize_registry())
+		return CU_get_error();
+
+	/* add a suite to the registry */
+	pSuite = CU_add_suite("filereader tests",
+		init_suite,
+		clean_suite);
+	if (NULL == pSuite) {
+		CU_cleanup_registry();
+		return CU_get_error();
+	}
+
+	/* add the tests to the suite */
+	if (
+		(NULL == CU_add_test(pSuite, "test1 reading plain text file",
+							 test_read_text_file1)) ||
+		(NULL == CU_add_test(pSuite, "test2 reading plain text file",
+							 test_read_text_file2)) ||
+		(NULL == CU_add_test(pSuite, "test3 reading plain text file",
+							 test_read_text_file3)) ||
+		(NULL == CU_add_test(pSuite, "test4 reading plain text file",
+							 test_read_text_file4)) ||
+		(NULL == CU_add_test(pSuite, "test1 writing plain text file",
+							 test_write_text_file1)) ||
+		(NULL == CU_add_test(pSuite, "test2 writing plain text file",
+							 test_write_text_file2)) ||
+		(NULL == CU_add_test(pSuite, "test3 writing plain text file",
+							 test_write_text_file3)) ||
+		(NULL == CU_add_test(pSuite, "test4 writing plain text file",
+							 test_write_text_file4)) ||
+		(NULL == CU_add_test(pSuite, "test5 writing plain text file",
+							 test_write_text_file5))
+		) {
+
+		CU_cleanup_registry();
+		return CU_get_error();
+	}
+
+	/* add a suite to the registry */
+	pSuite = CU_add_suite("polynomial tests",
+		init_suite,
+		clean_suite);
+	if (NULL == pSuite) {
+		CU_cleanup_registry();
+		return CU_get_error();
+	}
+
+	/* add the tests to the suite */
+	if (
+		(NULL == CU_add_test(pSuite, "test1 polynomial creation",
+							 test_poly_new1)) ||
+		(NULL == CU_add_test(pSuite, "test2 polynomial creation",
+							 test_poly_new2))
+		) {
+
+		CU_cleanup_registry();
+		return CU_get_error();
+	}
+
+	/* add a suite to the registry */
+	pSuite = CU_add_suite("keypair tests",
+		init_suite,
+		clean_suite);
+	if (NULL == pSuite) {
+		CU_cleanup_registry();
+		return CU_get_error();
+	}
+
+	/* add the tests to the suite */
+	if (
+		(NULL == CU_add_test(pSuite, "test1 keypair creation",
+							 test_create_keypair1)) ||
+		(NULL == CU_add_test(pSuite, "test2 keypair creation",
+							 test_create_keypair2)) ||
+		(NULL == CU_add_test(pSuite, "test1 public key export",
+							 test_export_public_key1)) ||
+		(NULL == CU_add_test(pSuite, "test2 public key export",
+							 test_export_public_key2)) ||
+		(NULL == CU_add_test(pSuite, "test1 priv key export",
+							 test_export_private_key1)) ||
+		(NULL == CU_add_test(pSuite, "test2 priv key export",
+							 test_export_private_key2)) ||
+		(NULL == CU_add_test(pSuite, "test1 pub key import",
+							 test_import_public_key1)) ||
+		(NULL == CU_add_test(pSuite, "test2 pub key import",
+							 test_import_public_key2)) ||
+		(NULL == CU_add_test(pSuite, "test1 priv key import",
+							 test_import_private_key1)) ||
+		(NULL == CU_add_test(pSuite, "test2 priv key import",
+							 test_import_private_key2))
+		) {
+
+		CU_cleanup_registry();
+		return CU_get_error();
+	}
+
+	/* add a suite to the registry */
+	pSuite = CU_add_suite("encryption tests",
+		init_suite,
+		clean_suite);
+	if (NULL == pSuite) {
+		CU_cleanup_registry();
+		return CU_get_error();
+	}
+
+	/* add the tests to the suite */
+	if (
+		(NULL == CU_add_test(pSuite, "test1 string encryption",
+							 test_encrypt_string1))
+		) {
+
+		CU_cleanup_registry();
+		return CU_get_error();
+	}
+
+	/* add a suite to the registry */
+	pSuite = CU_add_suite("decryption tests",
+		init_suite,
+		clean_suite);
+	if (NULL == pSuite) {
+		CU_cleanup_registry();
+		return CU_get_error();
+	}
+
+	/* add the tests to the suite */
+	if (
+		(NULL == CU_add_test(pSuite, "test1 string decryption",
+							 test_decrypt_string1))
+		) {
+
+		CU_cleanup_registry();
+		return CU_get_error();
+	}
+
+	/* save stderr stream and close it */
+	my_stderr = dup(STDERR_FILENO);
+	close(STDERR_FILENO);
+
+	/* Run all tests using the basic interface */
+	CU_basic_set_mode(CU_BRM_VERBOSE);
+	CU_basic_run_tests();
+	printf("\n");
+	CU_basic_show_failures(CU_get_failure_list());
+	printf("\n\n");
+
+	/* Clean up registry and return */
+	CU_cleanup_registry();
+
+	/* restore stderr stream */
+	dup2(my_stderr, STDERR_FILENO);
+
+	return CU_get_error();
+}

tests/ntru_cunit.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2014 FH Bielefeld
+ *
+ * This file is part of a FH Bielefeld project.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA
+ */
+
+/**
+ * @file ntru_cunit.h
+ * @brief header for ntru_cunit.c
+ */
+
+/*
+ * filereader/writer
+ */
+void test_read_text_file1(void);
+void test_read_text_file2(void);
+void test_read_text_file3(void);
+void test_read_text_file4(void);
+void test_write_text_file1(void);
+void test_write_text_file2(void);
+void test_write_text_file3(void);
+void test_write_text_file4(void);
+void test_write_text_file5(void);
+
+/*
+ * poly
+ */
+void test_poly_new1(void);
+void test_poly_new2(void);
+
+/*
+ * keypair
+ */
+void test_create_keypair1(void);
+void test_create_keypair2(void);
+void test_export_public_key1(void);
+void test_export_public_key2(void);
+void test_export_private_key1(void);
+void test_export_private_key2(void);
+void test_import_public_key1(void);
+void test_import_public_key2(void);
+void test_import_private_key1(void);
+void test_import_private_key2(void);
+
+/*
+ * encryption
+ */
+void test_encrypt_string1(void);
+
+/*
+ * decryption
+ */
+void test_decrypt_string1(void);

tests/ntru_decrypt_cunit.c

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2014 FH Bielefeld
+ *
+ * This file is part of a FH Bielefeld project.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA
+ */
+
+/**
+ * @file ntru_encrypt_cunit.c
+ * Test cases for encrypting strings.
+ * @brief tests for ntru_encrypt.c
+ */
+
+#include "ntru.h"
+#include "ntru_decrypt.h"
+#include "ntru_keypair.h"
+
+#include <CUnit/Basic.h>
+#include <CUnit/Console.h>
+#include <CUnit/Automated.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+
+/**
+ * Test decrypting an encrypted string.
+ */
+void test_decrypt_string1(void)
+{
+	keypair pair;
+	fmpz_poly_t f, g, rnd;
+	int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
+	int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
+	int rnd_c[] = {-1, 0, 1, 1, 1, -1, 0, -1, 0, 0, 0};
+	ntru_params params;
+	string *enc_string,
+		   *dec_string;
+	char dec_c_str[1024];
+
+	params.N = 11;
+	params.p = 3;
+	params.q = 32;
+
+	poly_new(f, f_c, 11);
+	poly_new(g, g_c, 11);
+	poly_new(rnd, rnd_c, 11);
+
+	ntru_create_keypair(&pair, f, g, &params);
+
+	enc_string = read_file("to-decrypt.txt");
+	dec_string = ntru_decrypt_string(enc_string, pair.priv, pair.priv_inv,
+			&params);
+
+	memcpy(dec_c_str, dec_string->ptr, dec_string->len);
+	dec_c_str[dec_string->len] = '\0';
+	string_delete(enc_string);
+	string_delete(dec_string);
+
+	CU_ASSERT_EQUAL(strcmp(dec_c_str, "BLAHFASEL\n"), 0);
+}

tests/ntru_encrypt_cunit.c

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2014 FH Bielefeld
+ *
+ * This file is part of a FH Bielefeld project.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA
+ */
+
+/**
+ * @file ntru_encrypt_cunit.c
+ * Test cases for encrypting strings.
+ * @brief tests for ntru_encrypt.c
+ */
+
+#include "ntru.h"
+#include "ntru_encrypt.h"
+#include "ntru_keypair.h"
+
+#include <CUnit/Basic.h>
+#include <CUnit/Console.h>
+#include <CUnit/Automated.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+
+/**
+ * Test encrypting a string.
+ */
+void test_encrypt_string1(void)
+{
+	keypair pair;
+	fmpz_poly_t f, g, rnd;
+	int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
+	int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
+	int rnd_c[] = {-1, 0, 1, 1, 1, -1, 0, -1, 0, 0, 0};
+	ntru_params params;
+	string *enc_string,
+		   *clear_string;
+	char enc_c_str[1024];
+
+	params.N = 11;
+	params.p = 3;
+	params.q = 32;
+
+	poly_new(f, f_c, 11);
+	poly_new(g, g_c, 11);
+	poly_new(rnd, rnd_c, 11);
+
+	ntru_create_keypair(&pair, f, g, &params);
+
+	clear_string = read_file("to-encrypt.txt");
+
+	enc_string = ntru_encrypt_string(clear_string, pair.pub,
+			rnd, &params);
+
+	memcpy(enc_c_str, enc_string->ptr, enc_string->len);
+	enc_c_str[enc_string->len] = '\0';
+	string_delete(enc_string);
+
+	CU_ASSERT_EQUAL(strcmp(enc_c_str,
+				"EAobFg4PHQYZBhEOChkYDg8fBhkGEw4KGRgOD"
+				"x0GGQYREAoZGA4PHQYbBBEODBsWDhEdBhkEER"
+				"AKGxYQDx0IGwQTDgoZGA4RHQgZBBMQChkWDg8"
+				"dCBkGEQ=="), 0);
+}

tests/ntru_file_cunit.c

@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2014 FH Bielefeld
+ *
+ * This file is part of a FH Bielefeld project.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA
+ */
+
+/**
+ * @file ntru_file_cunit.c
+ * Test cases for file reading and writing.
+ * @brief tests for ntru_file.c
+ */
+
+#include "ntru.h"
+
+#include <CUnit/Basic.h>
+#include <CUnit/Console.h>
+#include <CUnit/Automated.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+
+/**
+ * Read a valid text file and compare it with the correct expected
+ * string.
+ */
+void test_read_text_file1(void)
+{
+	string *tmp_str = read_file("test-file.txt");
+	char actual_string[512];
+	char *expected_string = "This test file is a test file.\n";
+	memcpy(actual_string, tmp_str->ptr, tmp_str->len);
+	actual_string[tmp_str->len] = '\0';
+
+	string_delete(tmp_str);
+
+	CU_ASSERT_PTR_NOT_NULL(actual_string);
+	CU_ASSERT_EQUAL((strcmp(actual_string, expected_string)), 0);
+}
+
+/**
+ * Read a valid text file and compare it with an uncorrect expected
+ * string.
+ */
+void test_read_text_file2(void)
+{
+	string *tmp_str = read_file("test-file.txt");
+	char actual_string[512];
+	char *expected_string = "foo\n";
+	memcpy(actual_string, tmp_str->ptr, tmp_str->len);
+	actual_string[tmp_str->len] = '\0';
+
+	string_delete(tmp_str);
+
+	CU_ASSERT_PTR_NOT_NULL(actual_string);
+	CU_ASSERT_NOT_EQUAL((strcmp(actual_string, expected_string)), 0);
+}
+
+/**
+ * Read an invalid text file.
+ */
+void test_read_text_file3(void)
+{
+	string *actual_string = read_file("asd");
+
+	CU_ASSERT_PTR_NULL(actual_string);
+}
+
+/**
+ * Pass NULL to the read_file() function.
+ */
+void test_read_text_file4(void)
+{
+	string *actual_string = read_file(NULL);
+
+	CU_ASSERT_PTR_NULL(actual_string);
+}
+
+/**
+ * Test if writing the file works, without checking the content.
+ */
+void test_write_text_file1(void)
+{
+	string *tmp_str = read_file("test-file.txt");
+	write_file(tmp_str, "test-file.out");
+	string_delete(tmp_str);
+
+	CU_ASSERT_EQUAL(0, access("test-file.out", F_OK));
+}
+
+/**
+ * Test if the written file has the expected content.
+ */
+void test_write_text_file2(void)
+{
+	string *tmp_str = read_file("test-file.txt");
+	char actual_string[512];
+	char *expected_string = "This test file is a test file.\n";
+
+	write_file(tmp_str, "test-file.out");
+	string_delete(tmp_str);
+	tmp_str = read_file("test-file.out");
+
+	memcpy(actual_string, tmp_str->ptr, tmp_str->len);
+	actual_string[tmp_str->len] = '\0';
+
+	string_delete(tmp_str);
+
+	CU_ASSERT_PTR_NOT_NULL(actual_string);
+	CU_ASSERT_EQUAL((strcmp(actual_string, expected_string)), 0);
+}
+
+/**
+ * Check error handling when trying to write to directory.
+ */
+void test_write_text_file3(void)
+{
+	string str;
+	char *c_str = "This test file is a test file.\n";
+	str.ptr = c_str;
+	str.len = 0;
+	str.len = strlen(c_str);
+
+	CU_ASSERT_EQUAL(false, write_file(&str, "."));
+}
+
+/**
+ * Check error handling when passing NULL pointers.
+ */
+void test_write_text_file4(void)
+{
+	CU_ASSERT_EQUAL(false, write_file(NULL, "test-file.out"));
+}
+
+/**
+ * Check error handling when passing NULL pointers.
+ */
+void test_write_text_file5(void)
+{
+	string str;
+	char *c_str = "This test file is a test file.\n";
+	str.ptr = c_str;
+	str.len = strlen(c_str);
+
+	CU_ASSERT_EQUAL(false, write_file(&str, NULL));
+}

tests/ntru_keypair_cunit.c

@@ -0,0 +1,341 @@
+/*
+ * Copyright (C) 2014 FH Bielefeld
+ *
+ * This file is part of a FH Bielefeld project.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA
+ */
+
+/**
+ * @file ntru_keypair_cunit.c
+ * Test cases for generating private and public keys.
+ * @brief tests for ntru_keypair.c
+ */
+
+#include "ntru.h"
+#include "ntru_keypair.h"
+
+#include <CUnit/Basic.h>
+#include <CUnit/Console.h>
+#include <CUnit/Automated.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+
+/**
+ * Test keypair creation.
+ */
+void test_create_keypair1(void)
+{
+	keypair pair;
+	fmpz_poly_t f, g, pub, priv_inv;
+	int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
+	int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
+	int pub_c[] = { 8, 25, 22, 20, 12, 24, 15, 19, 12, 19, 16 };
+	int priv_inv_c[] = { 1, 2, 0, 2, 2, 1, 0, 2, 1, 2, 0 };
+	ntru_params params;
+	params.N = 11;
+	params.p = 3;
+	params.q = 32;
+
+	poly_new(f, f_c, 11);
+	poly_new(g, g_c, 11);
+	poly_new(pub, pub_c, 11);
+	poly_new(priv_inv, priv_inv_c, 11);
+
+	CU_ASSERT_EQUAL(true, ntru_create_keypair(&pair, f, g, &params));
+	CU_ASSERT_EQUAL(1, fmpz_poly_equal(pub, pair.pub));
+	CU_ASSERT_EQUAL(1, fmpz_poly_equal(priv_inv, pair.priv_inv));
+	CU_ASSERT_EQUAL(1, fmpz_poly_equal(f, pair.priv));
+}
+
+/**
+ * Test keypair creation error handling via non-invertible polynomial.
+ */
+void test_create_keypair2(void)
+{
+	keypair pair;
+	fmpz_poly_t f, g, priv_inv;
+	int f_c[] = { 0, 0, 1, 0, -1, 0, 0, 0, 0, 1, -1 };
+	int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
+	int priv_inv_c[] = { 1, 2, 0, 2, 2, 1, 0, 2, 1, 2, 0 };
+	ntru_params params;
+	params.N = 11;
+	params.p = 3;
+	params.q = 32;
+
+	poly_new(f, f_c, 11);
+	poly_new(g, g_c, 11);
+	poly_new(priv_inv, priv_inv_c, 11);
+
+	CU_ASSERT_EQUAL(false, ntru_create_keypair(&pair, f, g, &params));
+}
+
+/**
+ * Test exporting public key and reading the resulting file.
+ */
+void test_export_public_key1(void)
+{
+	keypair pair;
+	fmpz_poly_t f, g;
+	int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
+	int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
+	ntru_params params;
+	string *pub_string;
+	char *expected_pub_c_str = "CBkWFAwYDxMMExA=";
+	char actual_pub_c_str[512] = "\0";
+
+	params.N = 11;
+	params.p = 3;
+	params.q = 32;
+
+	poly_new(f, f_c, 11);
+	poly_new(g, g_c, 11);
+
+	ntru_create_keypair(&pair, f, g, &params);
+	export_public_key("pub.key", pair.pub, &params);
+
+	if ((pub_string = read_file("pub.key"))) {
+		memcpy(actual_pub_c_str, pub_string->ptr, pub_string->len);
+		actual_pub_c_str[pub_string->len] = '\0';
+		string_delete(pub_string);
+	}
+
+	remove("pub.key");
+
+	CU_ASSERT_EQUAL(strcmp(expected_pub_c_str, actual_pub_c_str), 0);
+}
+
+/**
+ * Test error handling of exporting public key.
+ */
+void test_export_public_key2(void)
+{
+	keypair pair;
+	fmpz_poly_t f, g;
+	int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
+	int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
+	ntru_params params;
+	string *pub_string;
+	char *expected_pub_c_str = "CBkWFAwYDxMMExA=";
+	char actual_pub_c_str[512] = "\0";
+
+	params.N = 11;
+	params.p = 3;
+	params.q = 32;
+
+	poly_new(f, f_c, 11);
+	poly_new(g, g_c, 11);
+
+	ntru_create_keypair(&pair, f, g, &params);
+	export_public_key(".", pair.pub, &params);
+
+	if ((pub_string = read_file("pub.key"))) {
+		memcpy(actual_pub_c_str, pub_string->ptr, pub_string->len);
+		actual_pub_c_str[pub_string->len] = '\0';
+		string_delete(pub_string);
+	}
+
+	CU_ASSERT_NOT_EQUAL(strcmp(expected_pub_c_str, actual_pub_c_str), 0);
+}
+
+/**
+ * Test exporting private key and reading the resulting file.
+ */
+void test_export_private_key1(void)
+{
+	keypair pair;
+	fmpz_poly_t f, g;
+	int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
+	int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
+	ntru_params params;
+	string *pub_string;
+	char *expected_priv_c_str = "AgEBAgAAAAEAAQE=";
+	char actual_priv_c_str[512] = "\0";
+
+	params.N = 11;
+	params.p = 3;
+	params.q = 32;
+
+	poly_new(f, f_c, 11);
+	poly_new(g, g_c, 11);
+
+	ntru_create_keypair(&pair, f, g, &params);
+	export_priv_key("priv.key", pair.pub, &params);
+
+	if ((pub_string = read_file("priv.key"))) {
+		memcpy(actual_priv_c_str, pub_string->ptr, pub_string->len);
+		actual_priv_c_str[pub_string->len] = '\0';
+		string_delete(pub_string);
+	}
+
+	remove("priv.key");
+
+	CU_ASSERT_EQUAL(strcmp(expected_priv_c_str, actual_priv_c_str), 0);
+}
+
+/**
+ * Test error handling of exporting private key.
+ */
+void test_export_private_key2(void)
+{
+	keypair pair;
+	fmpz_poly_t f, g;
+	int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
+	int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
+	ntru_params params;
+	string *pub_string;
+	char *expected_priv_c_str = "AgEBAgAAAAEAAQE=";
+	char actual_priv_c_str[512] = "\0";
+
+	params.N = 11;
+	params.p = 3;
+	params.q = 32;
+
+	poly_new(f, f_c, 11);
+	poly_new(g, g_c, 11);
+
+	ntru_create_keypair(&pair, f, g, &params);
+	export_priv_key(".", pair.pub, &params);
+
+	if ((pub_string = read_file("priv.key"))) {
+		memcpy(actual_priv_c_str, pub_string->ptr, pub_string->len);
+		actual_priv_c_str[pub_string->len] = '\0';
+		string_delete(pub_string);
+	}
+
+	CU_ASSERT_NOT_EQUAL(strcmp(expected_priv_c_str, actual_priv_c_str), 0);
+}
+
+/**
+ * Test importing public key and reading.
+ */
+void test_import_public_key1(void)
+{
+	keypair pair;
+	fmpz_poly_t f, g, pub;
+	int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
+	int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
+	ntru_params params;
+
+	fmpz_poly_init(pub);
+
+	params.N = 11;
+	params.p = 3;
+	params.q = 32;
+
+	poly_new(f, f_c, 11);
+	poly_new(g, g_c, 11);
+
+	ntru_create_keypair(&pair, f, g, &params);
+	export_public_key("pub.key", pair.pub, &params);
+	import_public_key(pub, "pub.key", &params);
+
+	remove("pub.key");
+
+	CU_ASSERT_EQUAL(1, fmpz_poly_equal(pub, pair.pub));
+}
+
+/**
+ * Test error handling of importing public key.
+ */
+void test_import_public_key2(void)
+{
+	keypair pair;
+	fmpz_poly_t f, g, pub;
+	int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
+	int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
+	ntru_params params;
+
+	fmpz_poly_init(pub);
+
+	params.N = 11;
+	params.p = 3;
+	params.q = 32;
+
+	poly_new(f, f_c, 11);
+	poly_new(g, g_c, 11);
+
+	ntru_create_keypair(&pair, f, g, &params);
+	export_public_key("pub.key", pair.pub, &params);
+	import_public_key(pub, "foo", &params);
+
+	remove("pub.key");
+
+	CU_ASSERT_NOT_EQUAL(1, fmpz_poly_equal(pub, pair.pub));
+}
+
+/**
+ * Test importing private key and reading.
+ */
+void test_import_private_key1(void)
+{
+	keypair pair;
+	fmpz_poly_t f, g, priv, priv_inv;
+	int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
+	int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
+	ntru_params params;
+
+	fmpz_poly_init(priv);
+	fmpz_poly_init(priv_inv);
+
+	params.N = 11;
+	params.p = 3;
+	params.q = 32;
+
+	poly_new(f, f_c, 11);
+	poly_new(g, g_c, 11);
+
+	ntru_create_keypair(&pair, f, g, &params);
+	export_priv_key("priv.key", pair.priv, &params);
+	import_priv_key(priv, priv_inv, "priv.key", &params);
+
+	remove("priv.key");
+
+	CU_ASSERT_EQUAL(1, fmpz_poly_equal(priv, pair.priv));
+}
+
+/**
+ * Test error handling of importing private key.
+ */
+void test_import_private_key2(void)
+{
+	keypair pair;
+	fmpz_poly_t f, g, priv, priv_inv;
+	int f_c[] = { -1, 1, 1, 0, -1, 0, 1, 0, 0, 1, -1 };
+	int g_c[] = { -1, 0, 1, 1, 0, 1, 0, 0, -1, 0, -1 };
+	ntru_params params;
+
+	fmpz_poly_init(priv);
+	fmpz_poly_init(priv_inv);
+
+	params.N = 11;
+	params.p = 3;
+	params.q = 32;
+
+	poly_new(f, f_c, 11);
+	poly_new(g, g_c, 11);
+
+	ntru_create_keypair(&pair, f, g, &params);
+	export_priv_key("priv.key", pair.priv, &params);
+	import_priv_key(priv, priv_inv, ".", &params);
+
+	remove("priv.key");
+
+	CU_ASSERT_NOT_EQUAL(1, fmpz_poly_equal(priv, pair.priv));
+}

tests/ntru_poly_cunit.c

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2014 FH Bielefeld
+ *
+ * This file is part of a FH Bielefeld project.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA
+ */
+
+/**
+ * @file ntru_poly_cunit.c
+ * Test cases for polynomial creation.
+ * @brief tests for ntru_poly.c
+ */
+
+#include "ntru.h"
+
+#include <CUnit/Basic.h>
+#include <CUnit/Console.h>
+#include <CUnit/Automated.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <fmpz_poly.h>
+#include <fmpz.h>
+
+
+/**
+ * Test creating a new polynomial.
+ */
+void test_poly_new1(void)
+{
+	fmpz_poly_t new_poly;
+	int c[11] = { 1, 0, 1, 0, 1, 1, 0, 1, 0, -1 , 1};
+
+	poly_new(new_poly, c, 11);
+
+	CU_ASSERT_EQUAL(fmpz_cmp_si(fmpz_poly_get_coeff_ptr(new_poly, 0), 1), 0);
+	CU_ASSERT_EQUAL(fmpz_cmp_si(fmpz_poly_get_coeff_ptr(new_poly, 1), 0), 0);
+	CU_ASSERT_EQUAL(fmpz_cmp_si(fmpz_poly_get_coeff_ptr(new_poly, 2), 1), 0);
+	CU_ASSERT_EQUAL(fmpz_cmp_si(fmpz_poly_get_coeff_ptr(new_poly, 3), 0), 0);
+	CU_ASSERT_EQUAL(fmpz_cmp_si(fmpz_poly_get_coeff_ptr(new_poly, 4), 1), 0);
+	CU_ASSERT_EQUAL(fmpz_cmp_si(fmpz_poly_get_coeff_ptr(new_poly, 5), 1), 0);
+	CU_ASSERT_EQUAL(fmpz_cmp_si(fmpz_poly_get_coeff_ptr(new_poly, 6), 0), 0);
+	CU_ASSERT_EQUAL(fmpz_cmp_si(fmpz_poly_get_coeff_ptr(new_poly, 7), 1), 0);
+	CU_ASSERT_EQUAL(fmpz_cmp_si(fmpz_poly_get_coeff_ptr(new_poly, 8), 0), 0);
+	CU_ASSERT_EQUAL(fmpz_cmp_si(fmpz_poly_get_coeff_ptr(new_poly, 9), -1), 0);
+	CU_ASSERT_EQUAL(fmpz_cmp_si(fmpz_poly_get_coeff_ptr(new_poly, 10), 1), 0);
+}
+
+/**
+ * Test creating a new polynomial, without coefficients.
+ */
+void test_poly_new2(void)
+{
+	fmpz_poly_t new_poly;
+
+	poly_new(new_poly, NULL, 0);
+
+	CU_ASSERT_PTR_NULL(fmpz_poly_get_coeff_ptr(new_poly, 0));
+}

tests/test-file.txt

@@ -0,0 +1 @@
+This test file is a test file.

tests/to-decrypt.txt

@@ -0,0 +1 @@
+EAobFg4PHQYZBhEOChkYDg8fBhkGEw4KGRgODx0GGQYREAoZGA4PHQYbBBEODBsWDhEdBhkEERAKGxYQDx0IGwQTDgoZGA4RHQgZBBMQChkWDg8dCBkGEQ==

tests/to-encrypt.txt

@@ -0,0 +1 @@
+BLAHFASEL