unit-tests: Completed BLISS tests
authorAndreas Steffen <andreas.steffen@strongswan.org>
Mon, 23 Feb 2015 19:28:50 +0000 (20:28 +0100)
committerAndreas Steffen <andreas.steffen@strongswan.org>
Wed, 25 Feb 2015 20:45:34 +0000 (21:45 +0100)
src/libstrongswan/plugins/bliss/tests/Makefile.am
src/libstrongswan/plugins/bliss/tests/bliss_tests.h
src/libstrongswan/plugins/bliss/tests/suites/test_bliss_huffman.c [new file with mode: 0644]
src/libstrongswan/plugins/bliss/tests/suites/test_bliss_keys.c [new file with mode: 0644]
src/libstrongswan/plugins/bliss/tests/suites/test_bliss_sign.c
src/libstrongswan/plugins/bliss/tests/suites/test_bliss_signature.c [new file with mode: 0644]

index 57d58e9..bd87753 100644 (file)
@@ -5,7 +5,10 @@ check_PROGRAMS = $(TESTS)
 bliss_tests_SOURCES = \
        suites/test_bliss_fft.c \
        suites/test_bliss_bitpacker.c \
+       suites/test_bliss_huffman.c \
+       suites/test_bliss_keys.c \
        suites/test_bliss_sampler.c \
+       suites/test_bliss_signature.c \
        suites/test_bliss_sign.c \
        bliss_tests.h bliss_tests.c
 
index 67b0cdd..f0959cc 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Andreas Steffen
+ * Copyright (C) 2014-2015 Andreas Steffen
  * HSR Hochschule fuer Technik Rapperswil
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -15,6 +15,9 @@
 
 TEST_SUITE(bliss_fft_suite_create)
 TEST_SUITE(bliss_bitpacker_suite_create)
+TEST_SUITE(bliss_huffman_suite_create)
+TEST_SUITE(bliss_keys_suite_create)
 TEST_SUITE(bliss_sampler_suite_create)
+TEST_SUITE(bliss_signature_suite_create)
 TEST_SUITE(bliss_sign_suite_create)
 
diff --git a/src/libstrongswan/plugins/bliss/tests/suites/test_bliss_huffman.c b/src/libstrongswan/plugins/bliss/tests/suites/test_bliss_huffman.c
new file mode 100644 (file)
index 0000000..5447d07
--- /dev/null
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2015 Andreas Steffen
+ * HSR Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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 General Public License
+ * for more details.
+ */
+
+#include "test_suite.h"
+
+#include <bliss_huffman_coder.h>
+
+static chunk_t data = chunk_from_chars(0x5f, 0x71, 0x9e, 0x4c);
+
+START_TEST(test_bliss_huffman_encode)
+{
+       bliss_bitpacker_t *packer;
+       bliss_huffman_code_t *code;
+       bliss_huffman_coder_t *coder;
+       chunk_t encoding;
+
+       packer = bliss_bitpacker_create(32);
+       ck_assert(packer);
+
+       code = bliss_huffman_code_get_by_id(BLISS_B_I);
+       ck_assert(code);
+
+       coder = bliss_huffman_coder_create(code, packer);
+       ck_assert(coder);
+
+       ck_assert( coder->encode(coder, 0,  0));        /* 0 */
+       ck_assert( coder->encode(coder, 1,  0));        /* 10 */
+       ck_assert( coder->encode(coder, 2,  0));        /* 111 */
+       ck_assert( coder->encode(coder, 0,  1));        /* 1101 */
+       ck_assert( coder->encode(coder, 0, -1));        /* 11000 */
+       ck_assert( coder->encode(coder, 1,  1));        /* 110011 */
+       ck_assert( coder->encode(coder, 1, -1));        /* 1100100 */
+       ck_assert(!coder->encode(coder, 3,  0));        /* 11001010 */
+       ck_assert(!coder->encode(coder, 8,  0));        /* - */
+
+       encoding = packer->extract_buf(packer);
+       ck_assert(chunk_equals(encoding, data));
+
+       chunk_free(&encoding);
+       coder->destroy(coder);
+       packer->destroy(packer);
+}
+END_TEST
+
+START_TEST(test_bliss_huffman_decode)
+{
+       bliss_bitpacker_t *packer;
+       bliss_huffman_code_t *code;
+       bliss_huffman_coder_t *coder;
+       int32_t z1;
+       int16_t z2;
+
+       packer = bliss_bitpacker_create_from_data(data);
+       ck_assert(packer);
+
+       code = bliss_huffman_code_get_by_id(BLISS_II);
+       ck_assert(!code);
+       code = bliss_huffman_code_get_by_id(BLISS_B_II);
+       ck_assert(!code);
+       code = bliss_huffman_code_get_by_id(BLISS_B_I);
+       ck_assert(code);
+
+       coder = bliss_huffman_coder_create(code, packer);
+       ck_assert(coder);
+
+       ck_assert(coder->decode(coder, &z1, &z2));      /* 0 */
+       ck_assert(z1 == 0 && z2 == 0);
+
+       ck_assert(coder->decode(coder, &z1, &z2));      /* 10 */
+       ck_assert(z1 == 1 && z2 == 0);
+
+       ck_assert(coder->decode(coder, &z1, &z2));      /* 111 */
+       ck_assert(z1 == 2 && z2 == 0);
+
+       ck_assert(coder->decode(coder, &z1, &z2));      /* 1101 */
+       ck_assert(z1 == 0 && z2 == 1);
+
+       ck_assert(coder->decode(coder, &z1, &z2));      /* 11000 */
+       ck_assert(z1 == 0 && z2 == -1);
+
+       ck_assert(coder->decode(coder, &z1, &z2));      /* 110011 */
+       ck_assert(z1 == 1 && z2 == 1);
+
+       ck_assert(coder->decode(coder, &z1, &z2));      /* 1100100 */
+       ck_assert(z1 == 1 && z2 == -1);
+
+       ck_assert(!coder->decode(coder, &z1, &z2));     /* 11001010 */
+
+       coder->destroy(coder);
+       packer->destroy(packer);
+}
+END_TEST
+
+Suite *bliss_huffman_suite_create()
+{
+       Suite *s;
+       TCase *tc;
+
+       s = suite_create("bliss_huffman");
+
+       tc = tcase_create("huffman_encode");
+       tcase_add_test(tc, test_bliss_huffman_encode);
+       suite_add_tcase(s, tc);
+
+       tc = tcase_create("huffman_decode");
+       tcase_add_test(tc, test_bliss_huffman_decode);
+       suite_add_tcase(s, tc);
+
+       return s;
+}
diff --git a/src/libstrongswan/plugins/bliss/tests/suites/test_bliss_keys.c b/src/libstrongswan/plugins/bliss/tests/suites/test_bliss_keys.c
new file mode 100644 (file)
index 0000000..f48bc1d
--- /dev/null
@@ -0,0 +1,249 @@
+/*
+ * Copyright (C) 2015 Andreas Steffen
+ * HSR Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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 General Public License
+ * for more details.
+ */
+
+#include "test_suite.h"
+
+#include <bliss_private_key.h>
+#include <bliss_public_key.h>
+
+static chunk_t privkey_chunk[] = {
+       {NULL, 0},
+       chunk_from_chars(0x30, 0x00),
+       chunk_from_chars(0x30, 0x01),
+       chunk_from_chars(0x30, 0x03, 0x06, 0x01, 0x01),
+       chunk_from_chars(0x30, 0x0d, 0x06, 0x0b, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82,
+                                        0xa0, 0x2a, 0x05, 0x02, 0x06),
+       chunk_from_chars(0x30, 0x0f, 0x06, 0x0b, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82,
+                                        0xa0, 0x2a, 0x05, 0x02, 0x05, 0x03, 0x00),
+       chunk_from_chars(0x30, 0x82, 0x04, 0x9a, 0x06, 0x0b, 0x2b, 0x06, 0x01, 0x04,
+                                        0x01, 0x82, 0xa0, 0x2a, 0x05, 0x02, 0x05, 0x03, 0x82, 0x03,
+                                        0x81, 0x00, 0x81, 0xe5, 0xd2, 0x71, 0xeb, 0x98, 0xe5, 0x24,
+                                        0x34, 0xe4, 0x8a, 0x27, 0x23, 0x7d, 0x7d, 0x2c, 0xa3, 0xa7,
+                                        0x3f, 0x87, 0xad, 0xae, 0xfa, 0xe4, 0x66, 0x1c, 0xef, 0x69,
+                                        0x63, 0x5e, 0x91, 0xda, 0x41, 0x45, 0xd5, 0x8a, 0xb5, 0x26,
+                                        0x33, 0x32, 0xe0, 0xa2, 0x9b, 0x52, 0x5e, 0x49, 0x5d, 0x0d,
+                                        0x62, 0x72, 0x68, 0xa5, 0x94, 0x24, 0x03, 0x98, 0x48, 0x60,
+                                        0x4a, 0x98, 0x97, 0x0d, 0x60, 0x7d, 0x00, 0x4f, 0xb9, 0xaf,
+                                        0xcb, 0x6b, 0x41, 0x3d, 0x5b, 0xe4, 0x3e, 0x9a, 0xee, 0x06,
+               /*  100 */       0xa1, 0xd0, 0x93, 0x53, 0x88, 0x58, 0x83, 0xb2, 0x44, 0xa1,
+                                        0x16, 0x58, 0x3d, 0x32, 0xa1, 0x29, 0x85, 0x1a, 0x24, 0xc8,
+                                        0xb8, 0x8c, 0x1f, 0x43, 0xbb, 0x4b, 0xdd, 0x8e, 0x72, 0xd3,
+                                        0xf4, 0xfc, 0x02, 0x69, 0x47, 0xa5, 0x9d, 0xd0, 0xfc, 0xa6,
+                                        0x94, 0x2e, 0x02, 0x6d, 0x85, 0x2c, 0x6d, 0xe3, 0x91, 0xd5,
+                                        0xf1, 0x54, 0xbd, 0x1e, 0x63, 0x6b, 0xee, 0x28, 0xf9, 0xc6,
+                                        0xec, 0x05, 0x99, 0xd5, 0xdd, 0xe5, 0x72, 0x9b, 0xbc, 0xa7,
+                                        0x5a, 0x4a, 0x46, 0x3e, 0xec, 0xd7, 0x0b, 0xc5, 0x23, 0x00,
+                                        0xdc, 0x08, 0x09, 0x57, 0x44, 0x2e, 0x43, 0x0f, 0xea, 0xca,
+                                        0x2a, 0x31, 0xbe, 0xf3, 0x04, 0x8f, 0x8b, 0xa6, 0x3c, 0x35,
+               /*  200 */       0x80, 0x2b, 0xe2, 0x18, 0x22, 0xfd, 0xe9, 0x39, 0x57, 0xed,
+                                        0x77, 0x1d, 0x32, 0x02, 0x48, 0x2c, 0x85, 0x53, 0x9f, 0x4a,
+                                        0xd8, 0x86, 0x4d, 0xd2, 0x26, 0x19, 0x12, 0x19, 0xa2, 0xb5,
+                                        0xdf, 0x02, 0x50, 0xe4, 0x32, 0x9a, 0x27, 0xd0, 0x9e, 0x49,
+                                        0x4a, 0x13, 0x9a, 0xfc, 0x07, 0x98, 0x60, 0x65, 0xf4, 0xc1,
+                                        0x6c, 0x9a, 0x15, 0x28, 0x74, 0x5c, 0xd0, 0xa8, 0xe6, 0x2e,
+                                        0x1f, 0xe9, 0xe6, 0x2b, 0xc8, 0x46, 0xe9, 0x26, 0xb0, 0xf0,
+                                        0x8a, 0xe6, 0x8c, 0x9b, 0xbf, 0x64, 0xa0, 0x59, 0x33, 0x4f,
+                                        0xc0, 0x0c, 0x16, 0x72, 0x89, 0x79, 0x2a, 0x3a, 0x5e, 0x3d,
+                                        0x40, 0xbb, 0x73, 0xa9, 0xc0, 0x52, 0x70, 0x57, 0x06, 0xc1,
+               /*  300 */       0xe7, 0x70, 0xb8, 0x6d, 0x1b, 0x50, 0x61, 0x85, 0xee, 0x3e,
+                                        0xe5, 0x5a, 0x8a, 0x75, 0x9f, 0x1e, 0xb7, 0xea, 0x54, 0x5a,
+                                        0x8f, 0x52, 0xc2, 0xae, 0x2c, 0x7a, 0x58, 0xe6, 0xcb, 0xa6,
+                                        0x9b, 0x68, 0x84, 0x79, 0xf2, 0x82, 0x05, 0x57, 0xaa, 0xd5,
+                                        0x51, 0x82, 0xec, 0x84, 0x63, 0xce, 0xf4, 0xa7, 0xdf, 0x4e,
+                                        0xac, 0x7d, 0xdd, 0xc3, 0x02, 0x68, 0xe0, 0x35, 0xa1, 0x92,
+                                        0x29, 0x02, 0x2c, 0xa0, 0xe4, 0x29, 0x66, 0xd3, 0xe8, 0xd9,
+                                        0x52, 0x0f, 0x3b, 0xec, 0x53, 0x63, 0x57, 0xc3, 0xd2, 0x59,
+                                        0x38, 0xe7, 0x74, 0xf4, 0x1d, 0x03, 0x88, 0x3c, 0xe9, 0x97,
+                                        0x37, 0xd7, 0x12, 0x66, 0x2a, 0xb5, 0xf8, 0xcd, 0x10, 0x87,
+               /*  400 */       0x5d, 0x6a, 0x69, 0xbb, 0x9b, 0xc5, 0x55, 0x3c, 0x09, 0x46,
+                                        0x04, 0x57, 0xc0, 0x2f, 0x77, 0x89, 0xe2, 0x88, 0x15, 0x6b,
+                                        0x71, 0x56, 0xe1, 0xa2, 0x30, 0x71, 0x5f, 0x1d, 0x27, 0x12,
+                                        0xbf, 0xc3, 0x55, 0xde, 0xe5, 0x9c, 0x4e, 0xb8, 0xc6, 0xec,
+                                        0x96, 0x3a, 0x5d, 0x6d, 0xe9, 0xd3, 0xf8, 0x28, 0xda, 0x3f,
+                                        0x75, 0x24, 0xd0, 0x34, 0x50, 0xa6, 0x28, 0x65, 0x6a, 0xe9,
+                                        0xa6, 0x89, 0xe5, 0x5d, 0x45, 0xaf, 0x63, 0x34, 0xaf, 0x31,
+                                        0x29, 0x82, 0xe6, 0x03, 0x80, 0x5c, 0x34, 0x28, 0xd1, 0x9f,
+                                        0xca, 0xd3, 0x96, 0xcb, 0x31, 0xde, 0xdb, 0xf0, 0x07, 0x2b,
+                                        0xc5, 0xbc, 0x29, 0xd1, 0x11, 0xf4, 0x23, 0x3b, 0x14, 0xb5,
+               /*  500 */       0xa6, 0xf1, 0x02, 0x9e, 0x66, 0xbe, 0xdc, 0xc4, 0xca, 0xf7,
+                                        0xc0, 0x81, 0x92, 0x7c, 0xea, 0xe3, 0x42, 0x54, 0x8a, 0x6f,
+                                        0x0a, 0x2a, 0xa7, 0x2a, 0x92, 0xab, 0x09, 0xb1, 0x61, 0x91,
+                                        0xaa, 0x90, 0x54, 0xa3, 0x76, 0x64, 0xe2, 0xfd, 0x81, 0x9a,
+                                        0x4c, 0x35, 0x11, 0x28, 0xf3, 0x14, 0x97, 0x1b, 0x61, 0xa4,
+                                        0x67, 0x43, 0xae, 0x90, 0x6b, 0xe4, 0x29, 0x34, 0xec, 0x08,
+                                        0xbc, 0x6a, 0x82, 0x45, 0xc7, 0x7d, 0xdc, 0xd0, 0x03, 0x98,
+                                        0x29, 0x63, 0x05, 0x94, 0xb2, 0xb9, 0x04, 0xce, 0x34, 0x9a,
+                                        0x64, 0xae, 0x9a, 0xa9, 0x11, 0xa5, 0x13, 0x07, 0xcc, 0x92,
+                                        0xe9, 0xe5, 0x98, 0x13, 0x13, 0x8f, 0x8b, 0xb2, 0x77, 0x75,
+               /*  600 */       0x2a, 0x6f, 0xb1, 0xa6, 0x98, 0xbf, 0x50, 0xaf, 0xa7, 0x15,
+                                        0x2a, 0xe6, 0xdf, 0x41, 0xb6, 0x5e, 0x72, 0xb2, 0x74, 0xf2,
+                                        0x38, 0x88, 0x41, 0x56, 0x53, 0xea, 0x83, 0x23, 0x8a, 0x6d,
+                                        0x6c, 0x64, 0x6c, 0xa6, 0x04, 0x79, 0x51, 0x92, 0x89, 0xbe,
+                                        0x2a, 0x54, 0xd8, 0x5a, 0x8d, 0x5b, 0x9c, 0xfc, 0x62, 0x05,
+                                        0x0f, 0xbd, 0x85, 0x12, 0x57, 0x45, 0x96, 0x2e, 0x8f, 0x76,
+                                        0xd4, 0x33, 0xfb, 0x4a, 0xc2, 0x9f, 0x57, 0x96, 0xb3, 0xa2,
+                                        0xc6, 0xa6, 0x95, 0x3c, 0x9e, 0x7e, 0x15, 0x12, 0xd7, 0xe4,
+                                        0x65, 0x05, 0x5d, 0x72, 0xc2, 0x28, 0x10, 0xa9, 0x68, 0xa9,
+                                        0x01, 0xfe, 0x9e, 0x36, 0x07, 0x80, 0x41, 0xc8, 0xa3, 0x5f,
+               /*  700 */       0x18, 0x3b, 0x38, 0x09, 0x95, 0xe2, 0x87, 0xad, 0x03, 0xfd,
+                                        0xdd, 0xa6, 0xe9, 0x8e, 0xa8, 0x3a, 0xc9, 0x45, 0x7b, 0xdc,
+                                        0xc2, 0x6a, 0x30, 0x78, 0xaa, 0xba, 0x32, 0xe9, 0x8a, 0x65,
+                                        0x48, 0x13, 0x5b, 0x29, 0x18, 0x2e, 0x5c, 0x68, 0x8d, 0x71,
+                                        0x01, 0x09, 0xab, 0x7d, 0x1a, 0xe9, 0x09, 0x74, 0x1b, 0xe1,
+                                        0x90, 0x00, 0xb9, 0xda, 0xa3, 0x03, 0xb7, 0x6c, 0xdd, 0x40,
+                                        0xb6, 0xe3, 0xde, 0xa6, 0x7b, 0xe9, 0x3d, 0x41, 0x4d, 0xc7,
+                                        0xad, 0xa5, 0xf9, 0x8b, 0x88, 0xd4, 0x1a, 0x75, 0xb5, 0xb6,
+                                        0x9f, 0x51, 0x9b, 0x8b, 0xd7, 0xa4, 0x02, 0xb0, 0x62, 0x45,
+                                        0xdd, 0x6c, 0x11, 0x35, 0x03, 0x77, 0x1c, 0xdb, 0xc5, 0xac,
+               /*  800 */       0x60, 0x37, 0x20, 0x15, 0xaf, 0xbd, 0xae, 0x76, 0x51, 0xd2,
+                                        0xfb, 0x63, 0x23, 0x19, 0x81, 0xa6, 0x59, 0x7b, 0x68, 0x00,
+                                        0x3d, 0x68, 0x89, 0x6b, 0x5a, 0x29, 0xbd, 0x4f, 0xc1, 0x50,
+                                        0xe4, 0x98, 0x85, 0xe6, 0x1a, 0xdd, 0xc8, 0xe4, 0xa1, 0x2b,
+                                        0x99, 0x42, 0x81, 0x4d, 0x07, 0xf4, 0x24, 0x93, 0x88, 0xfe,
+                                        0x40, 0x90, 0x5a, 0x56, 0x0b, 0x7f, 0x8d, 0x14, 0x82, 0x6d,
+                                        0xaf, 0xf6, 0x0a, 0x3d, 0xe6, 0x64, 0xb5, 0x48, 0x01, 0x37,
+                                        0xfe, 0xf3, 0xba, 0x67, 0xcc, 0xd2, 0xba, 0x32, 0x76, 0xe8,
+                                        0xa7, 0x41, 0x1f, 0x2a, 0xfc, 0xa9, 0x72, 0x66, 0xc7, 0xd5,
+                                        0x76, 0x02, 0x6b, 0x77, 0xba, 0x6c, 0xd4, 0x84, 0x68, 0x0e,
+               /*  900 */       0x62, 0xc8, 0x43, 0xb0, 0x81, 0xd5, 0x8f, 0xdb, 0x42, 0xc9,
+                                        0xf4, 0xaf, 0x71, 0xbd, 0xb9, 0x6c, 0xd6, 0xdc, 0x03, 0x81,
+                                        0x81, 0x00, 0xc5, 0x10, 0x40, 0x33, 0x0f, 0xc0, 0x14, 0x01,
+                                        0x00, 0x03, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x4c, 0x0f, 0x10,
+                                        0x03, 0x10, 0x00, 0x00, 0x01, 0xc0, 0x43, 0x40, 0x03, 0x5c,
+                                        0x00, 0x07, 0xc0, 0x51, 0x34, 0x01, 0x30, 0x0c, 0x00, 0x00,
+                                        0x04, 0xc0, 0x3d, 0x40, 0x03, 0x07, 0x40, 0xd3, 0x50, 0x0c,
+                                        0x04, 0x03, 0x00, 0x11, 0x41, 0x30, 0x00, 0xc1, 0xc0, 0xc3,
+                                        0x03, 0x5f, 0x04, 0x30, 0x01, 0x40, 0x40, 0x00, 0x40, 0x40,
+                                        0x10, 0x40, 0x05, 0x05, 0x00, 0x53, 0x00, 0x04, 0x50, 0x00,
+               /* 1000 */       0x00, 0x00, 0x0c, 0x00, 0x51, 0x00, 0x00, 0x00, 0x04, 0xc7,
+                                        0x01, 0x50, 0xc0, 0x11, 0x00, 0x04, 0x03, 0xc0, 0x04, 0x00,
+                                        0x70, 0x4c, 0x31, 0x03, 0xc0, 0x40, 0xc4, 0x40, 0x40, 0xc0,
+                                        0x0c, 0x0c, 0xf1, 0x40, 0xc1, 0x31, 0x70, 0x17, 0xc0, 0x30,
+                                        0xc1, 0x04, 0x0c, 0x04, 0x00, 0xc4, 0x01, 0x00, 0x34, 0x00,
+                                        0x03, 0x81, 0x81, 0x00, 0xcc, 0x00, 0x50, 0x30, 0xc4, 0x13,
+                                        0x0f, 0xf0, 0x43, 0x01, 0x33, 0x40, 0x30, 0x01, 0x40, 0x10,
+                                        0x57, 0x04, 0x03, 0x04, 0x10, 0x00, 0xf0, 0x03, 0x04, 0x01,
+                                        0x00, 0x10, 0x34, 0x03, 0xf0, 0x1c, 0x01, 0x40, 0x30, 0xf4,
+                                        0x00, 0x40, 0x34, 0xc3, 0x00, 0x00, 0x01, 0x00, 0x01, 0x10,
+               /* 1100 */       0x3f, 0x03, 0x40, 0x00, 0x10, 0x10, 0x00, 0x40, 0x03, 0x00,
+                                        0x03, 0x04, 0x40, 0x03, 0x00, 0x13, 0x03, 0x00, 0xc0, 0x01,
+                                        0x34, 0x01, 0x00, 0x00, 0x10, 0xf4, 0x00, 0xf0, 0x30, 0x00,
+                                        0x00, 0xc3, 0x1c, 0x41, 0x00, 0x40, 0x30, 0x04, 0x10, 0xc4,
+                                        0x11, 0x03, 0x00, 0x10, 0x04, 0x4f, 0x17, 0xc0, 0x00, 0x30,
+                                        0xcd, 0x3c, 0x40, 0xc4, 0x00, 0xf0, 0x00, 0x00, 0x04, 0x30,
+                                        0x0f, 0x31, 0x34, 0xf0, 0x00, 0x07, 0x0c, 0x34, 0x00, 0x50,
+                                        0x05, 0x03, 0x10, 0x70, 0x00, 0x33, 0x0c, 0x00, 0xc4, 0x54,
+                                        0x07, 0x00)
+};
+
+START_TEST(test_bliss_keys_priv)
+{
+       private_key_t *privkey;
+
+       privkey = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_BLISS,
+                                                                BUILD_BLOB, privkey_chunk[_i], BUILD_END);
+       if (_i == countof(privkey_chunk) - 1)
+       {
+               ck_assert(privkey);
+               privkey->destroy(privkey);
+       }
+       else
+       {
+               ck_assert(!privkey);
+       }
+}
+END_TEST
+
+typedef struct privkey_mod_t privkey_mod_t;
+
+struct privkey_mod_t {
+       int offset;
+       char byte;
+};
+
+static privkey_mod_t privkey_mod[] = {
+       {   20, 0x80 },
+       {   22, 0xc1 },
+       {  920, 0x80 },
+       {  922, 0x85 },
+       { 1052, 0x80 },
+       { 1054, 0x8c }
+};
+
+START_TEST(test_bliss_keys_priv_mod)
+{
+       private_key_t *privkey;
+       chunk_t data;
+
+       data = chunk_clone(privkey_chunk[countof(privkey_chunk) - 1]);
+       data.ptr[privkey_mod[_i].offset] = privkey_mod[_i].byte;
+
+       privkey = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_BLISS,
+                                                                BUILD_BLOB, data, BUILD_END);
+       ck_assert(!privkey);
+       chunk_free(&data);
+}
+END_TEST
+
+static chunk_t pubkey_chunk[] = {
+       {NULL, 0},
+       chunk_from_chars(0x30, 0x00),
+       chunk_from_chars(0x30, 0x01),
+       chunk_from_chars(0x30, 0x02, 0x30, 0x00),
+       chunk_from_chars(0x30, 0x05, 0x30, 0x03, 0x06, 0x01, 0x01),
+       chunk_from_chars(0x30, 0x11, 0x30, 0x0F, 0x06, 0x0b, 0x2b, 0x06, 0x01, 0x04,
+                                        0x01, 0x82, 0xa0, 0x2a, 0x05, 0x01, 0x01, 0x04, 0x00),
+       chunk_from_chars(0x30, 0x12, 0x30, 0x10, 0x06, 0x0b, 0x2b, 0x06, 0x01, 0x04,
+                                        0x01, 0x82, 0xa0, 0x2a, 0x05, 0x01, 0x01, 0x06, 0x01, 0x01),
+       chunk_from_chars(0x30, 0x1c, 0x30, 0x1a, 0x06, 0x0b, 0x2b, 0x06, 0x01, 0x04,
+                                        0x01, 0x82, 0xa0, 0x2a, 0x05, 0x01, 0x01, 0x06, 0x0b, 0x2b,
+                                        0x06, 0x01, 0x04, 0x01, 0x82, 0xa0, 0x2a, 0x05, 0x02, 0x06),
+       chunk_from_chars(0x30, 0x1e, 0x30, 0x1a, 0x06, 0x0b, 0x2b, 0x06, 0x01, 0x04,
+                                        0x01, 0x82, 0xa0, 0x2a, 0x05, 0x01, 0x01, 0x06, 0x0b, 0x2b,
+                                        0x06, 0x01, 0x04, 0x01, 0x82, 0xa0, 0x2a, 0x05, 0x02, 0x05,
+                                        0x03, 0x00)
+};
+
+START_TEST(test_bliss_keys_pub)
+{
+       public_key_t *pubkey;
+
+       pubkey = lib->creds->create(lib->creds, CRED_PUBLIC_KEY, KEY_ANY,
+                                                                BUILD_BLOB, pubkey_chunk[_i], BUILD_END);
+       ck_assert(!pubkey);
+}
+END_TEST
+
+Suite *bliss_keys_suite_create()
+{
+       Suite *s;
+       TCase *tc;
+
+       s = suite_create("bliss_keys");
+
+       tc = tcase_create("keys_priv");
+       tcase_add_loop_test(tc, test_bliss_keys_priv, 0, countof(privkey_chunk));
+       suite_add_tcase(s, tc);
+
+       tc = tcase_create("keys_priv_mod");
+       tcase_add_loop_test(tc, test_bliss_keys_priv_mod, 0, countof(privkey_mod));
+       suite_add_tcase(s, tc);
+
+       tc = tcase_create("keys_pub");
+       tcase_add_loop_test(tc, test_bliss_keys_pub, 0, countof(pubkey_chunk));
+       suite_add_tcase(s, tc);
+
+       return s;
+}
index dbe4591..0414798 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Andreas Steffen
+ * Copyright (C) 2014-2015 Andreas Steffen
  * HSR Hochschule fuer Technik Rapperswil
  *
  * This program is free software; you can redistribute it and/or modify it
 #include <bliss_public_key.h>
 
 static u_int key_type[] = { 1, 3, 4 };
+static u_int key_strength[] = { 128, 160, 192 };
 
 START_TEST(test_bliss_sign_all)
 {
+       private_key_t *privkey, *privkey1;
+       public_key_t *pubkey, *pubkey1;
+       chunk_t msg, signature, privkey_blob, pubkey_blob, pubkey_fp, privkey_fp;
+       int k;
+
+       for (k = 0; k < 4; k++)
+       {
+               int verify_count = 1000;
+
+               /* enforce BLISS-B key for k = 2, 3 */
+               lib->settings->set_bool(lib->settings,
+                               "%s.plugins.bliss.use_bliss_b", k >= 2, lib->ns);
+
+               msg = chunk_from_str("Hello Dolly!");
+
+               /* generate private key */
+               privkey = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_BLISS,
+                                                                        BUILD_KEY_SIZE, key_type[_i], BUILD_END);
+               ck_assert(privkey);
+
+               /* generate ASN.1 DER and PEM encoding of private key */
+               ck_assert(privkey->get_encoding(privkey, (k % 2) ?
+                                 PRIVKEY_ASN1_DER : PRIVKEY_PEM, &privkey_blob));
+
+               /* extract public key from private key */
+               pubkey = privkey->get_public_key(privkey);
+               ck_assert(pubkey);
+
+               /* generate ASN.1 DER and PEM encodings of public key */
+               ck_assert(pubkey->get_encoding(pubkey, (k % 2) ?
+                                 PUBKEY_SPKI_ASN1_DER : PUBKEY_PEM, &pubkey_blob));
+
+               /* compare fingerprints of public and private key */
+               ck_assert(pubkey->get_fingerprint(pubkey, (k % 2) ?
+                                 KEYID_PUBKEY_INFO_SHA1 : KEYID_PUBKEY_SHA1, &pubkey_fp));
+               ck_assert(privkey->get_fingerprint(privkey, (k % 2) ?
+                                 KEYID_PUBKEY_INFO_SHA1 : KEYID_PUBKEY_SHA1, &privkey_fp));
+               ck_assert(chunk_equals(pubkey_fp, privkey_fp));
+
+               /* retrieve fingerprints of public and private key from cache */
+               ck_assert(pubkey->get_fingerprint(pubkey, (k % 2) ?
+                                 KEYID_PUBKEY_INFO_SHA1 : KEYID_PUBKEY_SHA1, &pubkey_fp));
+               ck_assert(privkey->get_fingerprint(privkey, (k % 2) ?
+                                 KEYID_PUBKEY_INFO_SHA1 : KEYID_PUBKEY_SHA1, &privkey_fp));
+
+               /* get a reference of the private key and destroy both instances */
+               privkey1 = privkey->get_ref(privkey);
+               ck_assert(privkey1);
+               ck_assert(privkey1 == privkey);
+               privkey->destroy(privkey);
+               privkey1->destroy(privkey1);
+
+               /* get a reference of the public key and destroy both instances */
+               pubkey1 = pubkey->get_ref(pubkey);
+               ck_assert(pubkey1);
+               ck_assert(pubkey1 == pubkey);
+               pubkey->destroy(pubkey);
+               pubkey1->destroy(pubkey1);
+
+               /* enforce BLISS-B key for k = 1, 3 */
+               lib->settings->set_bool(lib->settings,
+                               "%s.plugins.bliss.use_bliss_b", k % 2, lib->ns);
+
+               /* load private key from ASN.1 blob */
+               privkey = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_BLISS,
+                                                                        BUILD_BLOB, privkey_blob, BUILD_END);
+               ck_assert(privkey);
+               ck_assert(privkey->get_type(privkey) == KEY_BLISS);
+               ck_assert(privkey->get_keysize(privkey) == key_strength[_i]);
+               chunk_free(&privkey_blob);
+
+               /* load public key from ASN.1 blob */
+               pubkey = lib->creds->create(lib->creds, CRED_PUBLIC_KEY, KEY_ANY,
+                                                                       BUILD_BLOB, pubkey_blob, BUILD_END);
+               ck_assert(pubkey);
+               ck_assert(pubkey->get_type(pubkey) == KEY_BLISS);
+               ck_assert(pubkey->get_keysize(pubkey) == key_strength[_i]);
+               chunk_free(&pubkey_blob);
+
+               /* generate and verify 1000 BLISS signatures */
+               while (verify_count--)
+               {
+                       ck_assert(privkey->sign(privkey, SIGN_BLISS_WITH_SHA512, msg,
+                                                                       &signature));
+                       ck_assert(pubkey->verify(pubkey, SIGN_BLISS_WITH_SHA512, msg,
+                                                                        signature));
+                       free(signature.ptr);
+               }
+               privkey->destroy(privkey);
+               pubkey->destroy(pubkey);
+       }
+}
+END_TEST
+
+START_TEST(test_bliss_sign_fail)
+{
        private_key_t *privkey;
        public_key_t *pubkey;
-       chunk_t msg, signature;
-       int verify_count = 1000;
-       
-       msg = chunk_from_str("Hello Dolly!");
+       chunk_t msg, signature, encoding, fp;
+
+       /* generate non-supported BLISS-II private key */
+       privkey = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_BLISS,
+                                                                BUILD_KEY_SIZE, BLISS_II, BUILD_END);
+       ck_assert(!privkey);
+
+       /* generate non-supported BLISS-B-II private key */
+       privkey = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_BLISS,
+                                                                BUILD_KEY_SIZE, BLISS_B_II, BUILD_END);
+       ck_assert(!privkey);
+
+       /* generate supported BLISS-B-I private key */
        privkey = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_BLISS,
-                                                                BUILD_KEY_SIZE, key_type[_i], BUILD_END);
+                                                                BUILD_KEY_SIZE, BLISS_B_I, BUILD_END);
        ck_assert(privkey);
 
+       /* wrong private key encoding format */
+       ck_assert(!privkey->get_encoding(privkey, PUBKEY_PEM, &encoding));
+
+       /* wrong fingerprint encoding format */
+       ck_assert(!privkey->get_fingerprint(privkey, KEYID_PGPV4, &fp));
+
+       /* extract public key */
        pubkey = privkey->get_public_key(privkey);
        ck_assert(pubkey);
 
-       while (verify_count--)
-       {
-               ck_assert(privkey->sign(privkey, SIGN_BLISS_WITH_SHA512, msg,
-                                                               &signature));
-               ck_assert(pubkey->verify(pubkey, SIGN_BLISS_WITH_SHA512, msg,
-                                                                signature));
-               free(signature.ptr);
-       }
+       /* wrong private key encoding format */
+       ck_assert(!pubkey->get_encoding(pubkey, PRIVKEY_PEM, &encoding));
+
+       /* wrong fingerprint encoding format */
+       ck_assert(!pubkey->get_fingerprint(pubkey, KEYID_PGPV4, &fp));
+
+       /* encryption / decryption operation is not defined for BLISS */
+       ck_assert(!pubkey->encrypt(pubkey, ENCRYPT_UNKNOWN, chunk_empty, NULL));
+       ck_assert(!privkey->decrypt(privkey, ENCRYPT_UNKNOWN, chunk_empty, NULL));
+
+       /* sign with invalid signature scheme */
+       ck_assert(!privkey->sign(privkey, SIGN_UNKNOWN, msg, &signature));
+
+       /* generate valid signature */
+       msg = chunk_from_str("Hello Dolly!");
+       ck_assert(privkey->sign(privkey, SIGN_BLISS_WITH_SHA512, msg, &signature));
+
+       /* verify with invalid signature scheme */
+       ck_assert(!pubkey->verify(pubkey, SIGN_UNKNOWN, msg, signature));
+
+       /* corrupt signature */
+       signature.ptr[signature.len - 1] ^= 0x80;
+       ck_assert(!pubkey->verify(pubkey, SIGN_BLISS_WITH_SHA512, msg, signature));
+
+       free(signature.ptr);
        privkey->destroy(privkey);
        pubkey->destroy(pubkey);
 }
@@ -55,10 +185,14 @@ Suite *bliss_sign_suite_create()
 
        s = suite_create("bliss_sign");
 
-       tc = tcase_create("all");
+       tc = tcase_create("sign_all");
        test_case_set_timeout(tc, 30);
        tcase_add_loop_test(tc, test_bliss_sign_all, 0, countof(key_type));
        suite_add_tcase(s, tc);
 
+       tc = tcase_create("sign_fail");
+       tcase_add_test(tc, test_bliss_sign_fail);
+       suite_add_tcase(s, tc);
+
        return s;
 }
diff --git a/src/libstrongswan/plugins/bliss/tests/suites/test_bliss_signature.c b/src/libstrongswan/plugins/bliss/tests/suites/test_bliss_signature.c
new file mode 100644 (file)
index 0000000..2a2f48c
--- /dev/null
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2015 Andreas Steffen
+ * HSR Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program 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 General Public License
+ * for more details.
+ */
+
+#include "test_suite.h"
+
+#include <bliss_signature.h>
+
+static chunk_t data = chunk_from_chars(
+       0xC1, 0xA1, 0x96, 0x98, 0x4F, 0x60, 0xF5, 0xCA, 0x89, 0x9E,
+       0x78, 0xAF, 0x64, 0xDD, 0x01, 0x76, 0x04, 0x29, 0x11, 0xD0,
+       0x21, 0x9E, 0xE4, 0x2D, 0xC5, 0x82, 0x69, 0x19, 0x82, 0x75,
+       0x30, 0xAC, 0xB0, 0x64, 0xCB, 0x65, 0x19, 0x22, 0x4A, 0x03,
+       0x03, 0x61, 0x4A, 0x37, 0x8E, 0xA3, 0xB6, 0xB3, 0x58, 0x44,
+       0xFD, 0x68, 0x38, 0xF1, 0x4B, 0xCF, 0xE8, 0xA2, 0x05, 0x39,
+       0x87, 0xE0, 0x5E, 0x7C, 0x45, 0x33, 0x4A, 0xEB, 0x2E, 0xCF,
+       0x98, 0x01, 0x3D, 0x28, 0x60, 0xCE, 0x90, 0x45, 0xF0, 0x8E,
+       0x36, 0x25, 0x50, 0x8B, 0xA2, 0xC0, 0x6E, 0xDF, 0xC2, 0xA1,
+       0x35, 0xC1, 0x16, 0x14, 0xE8, 0x6A, 0xE3, 0x9C, 0x0B, 0x32,
+       0x53, 0x55, 0x60, 0x52, 0x43, 0x93, 0xBB, 0x9F, 0x1D, 0x17,
+       0xDC, 0x6E, 0x26, 0x99, 0x60, 0x83, 0x12, 0x53, 0xB0, 0x2B,
+       0x36, 0xE2, 0x95, 0xA7, 0xBF, 0x9B, 0xC0, 0x0A, 0x63, 0xD6,
+       0x32, 0xA9, 0xE2, 0xAD, 0x02, 0x53, 0x10, 0x81, 0x00, 0xD4,
+       0x9A, 0xC2, 0x04, 0x1B, 0x48, 0x53, 0x37, 0xF0, 0x95, 0x39,
+       0x4B, 0x2E, 0x37, 0x28, 0xE2, 0x70, 0xAD, 0xB5, 0xF1, 0x63,
+       0x48, 0x17, 0xEF, 0x45, 0xC0, 0x30, 0xA6, 0xAA, 0x37, 0x9A,
+       0x00, 0x8F, 0x8D, 0xAC, 0x66, 0x2C, 0x96, 0x8C, 0xC2, 0x74,
+       0x9D, 0x66, 0x16, 0x5D, 0x70, 0x70, 0x1D, 0x2F, 0x11, 0xBD,
+       0x11, 0x62, 0x58, 0xC6, 0xB2, 0xA6, 0xFA, 0xB7, 0x8C, 0x10,
+       0x6A, 0x13, 0x34, 0x25, 0xB8, 0xF2, 0x46, 0xE3, 0x08, 0xAD,
+       0x8D, 0x49, 0x33, 0x24, 0x37, 0xA5, 0x0A, 0xF9, 0x5E, 0x95,
+       0xF9, 0x50, 0xDA, 0x2B, 0x80, 0x4F, 0x10, 0x4F, 0xAB, 0xE4,
+       0x96, 0xB1, 0xA1, 0x28, 0xCE, 0x6D, 0xB6, 0x17, 0x33, 0x2A,
+       0xE0, 0xC3, 0x80, 0xAA, 0x3D, 0x1A, 0x5C, 0x48, 0xA0, 0x48,
+       0x60, 0xCC, 0xC7, 0x29, 0x4F, 0xB8, 0x96, 0xDF, 0xC6, 0x6A,
+       0xC2, 0x83, 0x5E, 0xFC, 0xD7, 0x4E, 0xCA, 0x14, 0xB4, 0xC6,
+       0x30, 0x29, 0xC7, 0xCE, 0x79, 0x42, 0x2D, 0x22, 0x28, 0x99,
+       0x59, 0x14, 0xFB, 0x04, 0xAD, 0x79, 0x3C, 0x74, 0x34, 0xC6,
+       0x7A, 0x1C, 0x13, 0x07, 0x17, 0xB1, 0x8A, 0x02, 0xA7, 0x70,
+       0x3C, 0x5B, 0xBA, 0x88, 0xA2, 0xE6, 0x4B, 0x2A, 0xC1, 0x1E,
+       0x42, 0xDD, 0x83, 0x2B, 0x00, 0xCC, 0xF8, 0x80, 0x03, 0x7E,
+       0x97, 0xA4, 0x04, 0xE1, 0xB2, 0x0B, 0xE2, 0xF3, 0x91, 0x91,
+       0x80, 0xA0, 0xC5, 0x44, 0x67, 0xB1, 0x56, 0xD0, 0x13, 0x58,
+       0x7B, 0x6E, 0x12, 0xE7, 0x3A, 0x90, 0xE4, 0x2C, 0x44, 0x17,
+       0xA3, 0xBD, 0x21, 0x68, 0x45, 0x61, 0x20, 0x57, 0x8D, 0x4A,
+       0xF1, 0xE6, 0xD3, 0x17, 0xC9, 0xB0, 0xF8, 0x3A, 0x87, 0x6A,
+       0x7E, 0x25, 0x45, 0xDC, 0x9A, 0x1D, 0xAC, 0x10, 0xB6, 0xF6,
+       0x07, 0x4C, 0x50, 0x92, 0xF9, 0xE1, 0x3E, 0xAD, 0x3B, 0x80,
+       0x20, 0xA8, 0x34, 0x04, 0xD6, 0x0D, 0x2D, 0x46, 0x69, 0x5E,
+       0x8C, 0x4B, 0xB0, 0x1C, 0x37, 0xD8, 0x0D, 0x72, 0x7B, 0xE6,
+       0xEE, 0x04, 0x81, 0x98, 0x78, 0x69, 0x88, 0xD8, 0xDF, 0x04,
+       0xF0, 0x80, 0xE2, 0x0A, 0xD3, 0x60, 0x94, 0xDF, 0x49, 0xF7,
+       0x52, 0x95, 0xA6, 0xAF, 0x8C, 0x13, 0x10, 0x09, 0xAA, 0x03,
+       0xAC, 0x2C, 0x89, 0x2D, 0x2C, 0x61, 0x0F, 0xBE, 0x5C, 0x29,
+       0x01, 0x7C, 0x9E, 0xD2, 0xFF, 0x34, 0xA1, 0x9E, 0xEE, 0xBF,
+       0x28, 0x18, 0x3A, 0x17, 0xA6, 0x40, 0x94, 0xD5, 0xC4, 0xEC,
+       0x27, 0x0A, 0x40, 0x1C, 0xC4, 0x16, 0x80, 0x4E, 0x6F, 0xDD,
+       0xA5, 0x6A, 0x03, 0xE8, 0xBA, 0xB2, 0xAA, 0x7A, 0x7F, 0x4B,
+       0x30, 0x11, 0x11, 0x12, 0x4A, 0xFE, 0xB2, 0x99, 0xC6, 0x12,
+       0x1A, 0x98, 0xC0, 0x15, 0x41, 0xE1, 0x55, 0x35, 0x54, 0xF2,
+       0x1C, 0xE2, 0x78, 0x85, 0x66, 0xD3, 0x9C, 0x8A, 0x88, 0x7C,
+       0x86, 0x7F, 0x48, 0xBE, 0xB7, 0x1C, 0xE4, 0xCF, 0x35, 0xEE,
+       0x24, 0xA6, 0x62, 0xD6, 0x36, 0x1F, 0x66, 0x10, 0x5D, 0xEF,
+       0x07, 0x64, 0xA8, 0xD0, 0xAD, 0x2F, 0x47, 0x02, 0xA2, 0x0F,
+       0x73, 0x96, 0x2A, 0x21, 0x20, 0x36, 0x01, 0xA3, 0x2F, 0x5E,
+       0xC8, 0x80, 0x3A, 0x54, 0xA6, 0xB5, 0xD0, 0x19, 0xBF, 0xC4,
+       0x35, 0x01, 0x0B, 0x2A, 0x8E, 0x61, 0x4A, 0xDD, 0xB2, 0x4A,
+       0xE1, 0x0C, 0x15, 0x94, 0x9C, 0xD2, 0x54, 0x93, 0x85, 0x16,
+       0x49, 0x69, 0xA0, 0x41, 0x34, 0x16, 0x69, 0x28, 0x74, 0x11,
+       0x88, 0x44, 0xC8, 0x46, 0x5E, 0x62, 0xFF, 0x6E, 0xC5, 0xA8,
+       0xE8, 0x8A, 0x8A, 0xFA, 0x2D, 0x94, 0x14, 0xD4, 0x51, 0x16,
+       0xB0, 0x40, 0xDC, 0xF3, 0xAA, 0x97, 0x39, 0x1A, 0xDA, 0x7F,
+       0x41, 0x61, 0x25, 0x1E, 0xDF, 0x46, 0x29, 0x44, 0x80, 0xEA,
+       0x10, 0xE4, 0x0F, 0x94, 0xA6, 0x52, 0x20, 0x06, 0x9C, 0x69,
+       0x48, 0x1F, 0x45, 0x30, 0x4B, 0x21, 0x02, 0xE6, 0xF3, 0x44,
+       0x35, 0xC1, 0xC8, 0xC9, 0x68, 0x6C, 0x43, 0xA4, 0x56, 0x07,
+       0x36, 0x11, 0xFB, 0x6D, 0x8E, 0xF0, 0x62, 0x5A, 0x3C, 0x8B,
+       0x23, 0xF1, 0x46, 0xE2, 0x76, 0x2A, 0x6F, 0xBB, 0x09, 0x24,
+       0x18, 0x64, 0xE6, 0x5C, 0xD0, 0x85, 0x69, 0xF0, 0x4F, 0x66,
+       0x97, 0x40, 0x01, 0x27, 0xD1, 0x41, 0xCC, 0xEB, 0x4D, 0xB7,
+       0x04, 0xC4, 0x91, 0xE0, 0x95, 0x8A, 0x43, 0x26, 0x2D, 0x1F,
+       0x88, 0xA0, 0xD8
+);
+
+START_TEST(test_bliss_signature_fail)
+{
+       bliss_param_set_t set2 = { .id = BLISS_B_II };
+       bliss_param_set_t *set;
+       bliss_signature_t *signature;
+       chunk_t encoding;
+       int k;
+
+       signature = bliss_signature_create(&set2);
+       ck_assert(signature);
+       encoding = signature->get_encoding(signature);
+       ck_assert(encoding.len == 0);
+       signature->destroy(signature);
+
+       signature  = bliss_signature_create_from_data(&set2, data);
+       ck_assert(!signature);
+
+       set = bliss_param_set_get_by_id(BLISS_B_I);
+       ck_assert(set);
+
+       for (k = 0; k < data.len - 2; k++)
+       {
+               chunk_t fragment = { data.ptr, k };
+
+               signature  = bliss_signature_create_from_data(set, fragment);
+               ck_assert(!signature);
+       }
+       signature  = bliss_signature_create_from_data(set, data);
+       ck_assert(signature);
+       signature->destroy(signature);
+}
+END_TEST
+
+Suite *bliss_signature_suite_create()
+{
+       Suite *s;
+       TCase *tc;
+
+       s = suite_create("bliss_signature");
+
+       tc = tcase_create("signature_fail");
+       tcase_add_test(tc, test_bliss_signature_fail);
+       suite_add_tcase(s, tc);
+
+       return s;
+}