compress ciphertext slightly and add way more tests

[software/DIPE.git] / tests / testDIPE.cpp

diff --git a/tests/testDIPE.cpp b/tests/testDIPE.cpp
index 4219ba46ec3f182ef9c178b34478f97628b21424..782409c0f554760afd2b6349add774d6c6e2ad71 100644 (file)
--- a/tests/testDIPE.cpp
+++ b/tests/testDIPE.cpp
@@ -173,8 +173,8 @@ TEST(DipeTest, DipeDecapSuccess) {
 }
 
 TEST(DipeTest, DipeDecryptSuccessSmall) {
-       char ctxt[768];
-       char ptxt[768];
+       char ctxt[672];
+       char ptxt[672];
        size_t ptxt_len;
        size_t overhead;
        dipe_master_publickey_t pk;
@@ -200,23 +200,135 @@ TEST(DipeTest, DipeDecryptSuccessSmall) {
        dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
        overhead = dipe_ciphertext_overhead(param, 6);
 
-       for (size_t clen = overhead; clen < 768; ++clen) {
-               memset(ctxt, 0, 768);
-               memset(ptxt, 0, 768);
+       for (size_t clen = overhead; clen < 672; ++clen) {
+               memset(ctxt, 0, 672);
+               memset(ptxt, 0, 672);
                memcpy(ptxt, "test", 4);
 
                dipe_encrypt(param, pk, x, 4, ptxt, clen, ctxt);
                ptxt_len = dipe_decrypt(param, sk, "1234567890abcdef", y, clen, ctxt, ptxt);
 
-               if (clen >= overhead) {
-                       ASSERT_EQ(ptxt_len, 4);
-                       ASSERT_STREQ(ptxt, "test");
+               if (clen >= overhead + 4) {
+                       EXPECT_EQ(ptxt_len, 4);
+                       EXPECT_STREQ(ptxt, "test");
                }
                else {
-                       ASSERT_EQ(ptxt_len, 0);
+                       EXPECT_EQ(ptxt_len, 0);
                }
        }
-       
+
+       for (size_t i = 0; i < 6; ++i) {
+               element_clear(y[i]);
+               element_clear(x[i]);
+       }
+
+       dipe_free_master_secretkey(msk);
+       dipe_free_master_publickey(pk);
+       dipe_free_secretkey(sk);
+}
+
+TEST(DipeTest, DipeDecryptSuccessTightSmall) {
+       size_t ptxt_len;
+       size_t overhead;
+       dipe_master_publickey_t pk;
+       dipe_master_secretkey_t msk;
+       dipe_secretkey_t sk;
+
+       element_t y[6];
+       element_t x[6];
+
+       for (size_t i = 0; i < 6; i+=2) {
+               element_init_Zr(y[i], *dipe_get_pairing(param));
+               element_init_Zr(x[i], *dipe_get_pairing(param));
+               element_init_Zr(y[i+1], *dipe_get_pairing(param));
+               element_init_Zr(x[i+1], *dipe_get_pairing(param));
+
+               element_set1(y[i]);
+               element_set1(x[i+1]);
+               element_random(y[i+1]);
+               element_neg(x[i], y[i+1]);
+       }
+
+       dipe_master_keygen(param, 6, &pk, &msk);
+       dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
+       overhead = dipe_ciphertext_overhead(param, 6);
+
+       char ctxt[overhead + 4];
+       char ptxt[overhead + 4];
+
+       for (size_t clen = overhead; clen <= overhead + 4; ++clen) {
+               memset(ctxt, 0, overhead + 4);
+               memset(ptxt, 0, overhead + 4);
+               memcpy(ptxt, "test", 4);
+
+               dipe_encrypt(param, pk, x, 4, ptxt, clen, ctxt);
+               ptxt_len = dipe_decrypt(param, sk, "1234567890abcdef", y, clen, ctxt, ptxt);
+
+               if (clen >= overhead + 4) {
+                       EXPECT_EQ(ptxt_len, 4);
+                       EXPECT_STREQ(ptxt, "test");
+               }
+               else {
+                       EXPECT_EQ(ptxt_len, 0);
+               }
+       }
+
+       for (size_t i = 0; i < 6; ++i) {
+               element_clear(y[i]);
+               element_clear(x[i]);
+       }
+
+       dipe_free_master_secretkey(msk);
+       dipe_free_master_publickey(pk);
+       dipe_free_secretkey(sk);
+}
+
+
+TEST(DipeTest, DipeDecryptSuccessLargeBlocksize) {
+       char ctxt[672];
+       char ptxt[672];
+       size_t ptxt_len;
+       size_t overhead;
+       dipe_master_publickey_t pk;
+       dipe_master_secretkey_t msk;
+       dipe_secretkey_t sk;
+
+       element_t y[6];
+       element_t x[6];
+
+       for (size_t i = 0; i < 6; i+=2) {
+               element_init_Zr(y[i], *dipe_get_pairing(param));
+               element_init_Zr(x[i], *dipe_get_pairing(param));
+               element_init_Zr(y[i+1], *dipe_get_pairing(param));
+               element_init_Zr(x[i+1], *dipe_get_pairing(param));
+
+               element_set1(y[i]);
+               element_set1(x[i+1]);
+               element_random(y[i+1]);
+               element_neg(x[i], y[i+1]);
+       }
+
+       dipe_master_keygen(param, 6, &pk, &msk);
+       dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
+       overhead = dipe_ciphertext_overhead(param, 6);
+
+       for (size_t clen = overhead; clen <= 672; ++clen) {
+               memset(ctxt, 0, 672);
+               memset(ptxt, 0, 672);
+               memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbb", 28);
+
+               dipe_encrypt(param, pk, x, 28, ptxt, clen, ctxt);
+               ptxt_len = dipe_decrypt(param, sk, "1234567890abcdef", y, clen, ctxt, ptxt);
+
+               if (clen >= overhead + 28) {
+                       EXPECT_EQ(ptxt_len, 28);
+                       EXPECT_STREQ(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbb");
+               }
+               else {
+                       EXPECT_EQ(ptxt_len, 0);
+               }
+       }
+
        for (size_t i = 0; i < 6; ++i) {
                element_clear(y[i]);
                element_clear(x[i]);
@@ -227,6 +339,178 @@ TEST(DipeTest, DipeDecryptSuccessSmall) {
        dipe_free_secretkey(sk);
 }
 
+TEST(DipeTest, DipeDecryptSuccessTightLargeBlocksize) {
+       size_t ptxt_len;
+       size_t overhead;
+       dipe_master_publickey_t pk;
+       dipe_master_secretkey_t msk;
+       dipe_secretkey_t sk;
+
+       element_t y[6];
+       element_t x[6];
+
+       for (size_t i = 0; i < 6; i+=2) {
+               element_init_Zr(y[i], *dipe_get_pairing(param));
+               element_init_Zr(x[i], *dipe_get_pairing(param));
+               element_init_Zr(y[i+1], *dipe_get_pairing(param));
+               element_init_Zr(x[i+1], *dipe_get_pairing(param));
+
+               element_set1(y[i]);
+               element_set1(x[i+1]);
+               element_random(y[i+1]);
+               element_neg(x[i], y[i+1]);
+       }
+
+       dipe_master_keygen(param, 6, &pk, &msk);
+       dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
+       overhead = dipe_ciphertext_overhead(param, 6);
+
+       char ctxt[overhead + 28];
+       char ptxt[overhead + 28];
+
+
+       for (size_t clen = overhead; clen <= overhead + 28; ++clen) {
+               memset(ctxt, 0, overhead + 28);
+               memset(ptxt, 0, overhead + 28);
+               memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbb", 28);
+
+               dipe_encrypt(param, pk, x, 28, ptxt, clen, ctxt);
+               ptxt_len = dipe_decrypt(param, sk, "1234567890abcdef", y, clen, ctxt, ptxt);
+
+               if (clen >= overhead + 28) {
+                       EXPECT_EQ(ptxt_len, 28);
+                       EXPECT_STREQ(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbb");
+               }
+               else {
+                       EXPECT_EQ(ptxt_len, 0);
+               }
+       }
+
+       for (size_t i = 0; i < 6; ++i) {
+               element_clear(y[i]);
+               element_clear(x[i]);
+       }
+
+       dipe_free_master_secretkey(msk);
+       dipe_free_master_publickey(pk);
+       dipe_free_secretkey(sk);
+}
+
+
+TEST(DipeTest, DipeDecryptSuccessLargeNonBlocksize) {
+       char ctxt[672];
+       char ptxt[672];
+       size_t ptxt_len;
+       size_t overhead;
+       dipe_master_publickey_t pk;
+       dipe_master_secretkey_t msk;
+       dipe_secretkey_t sk;
+
+       element_t y[6];
+       element_t x[6];
+
+       for (size_t i = 0; i < 6; i+=2) {
+               element_init_Zr(y[i], *dipe_get_pairing(param));
+               element_init_Zr(x[i], *dipe_get_pairing(param));
+               element_init_Zr(y[i+1], *dipe_get_pairing(param));
+               element_init_Zr(x[i+1], *dipe_get_pairing(param));
+
+               element_set1(y[i]);
+               element_set1(x[i+1]);
+               element_random(y[i+1]);
+               element_neg(x[i], y[i+1]);
+       }
+
+       dipe_master_keygen(param, 6, &pk, &msk);
+       dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
+       overhead = dipe_ciphertext_overhead(param, 6);
+
+       for (size_t clen = overhead; clen <= 672; ++clen) {
+               memset(ctxt, 0, 672);
+               memset(ptxt, 0, 672);
+               memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc", 35);
+
+               dipe_encrypt(param, pk, x, 35, ptxt, clen, ctxt);
+               ptxt_len = dipe_decrypt(param, sk, "1234567890abcdef", y, clen, ctxt, ptxt);
+
+               if (clen >= overhead + 35) {
+                       EXPECT_EQ(ptxt_len, 35);
+                       EXPECT_STREQ(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc");
+               }
+               else {
+                       EXPECT_EQ(ptxt_len, 0);
+               }
+       }
+
+       for (size_t i = 0; i < 6; ++i) {
+               element_clear(y[i]);
+               element_clear(x[i]);
+       }
+
+       dipe_free_master_secretkey(msk);
+       dipe_free_master_publickey(pk);
+       dipe_free_secretkey(sk);
+}
+
+TEST(DipeTest, DipeDecryptSuccessTightLargeNonBlocksize) {
+       size_t ptxt_len;
+       size_t overhead;
+       dipe_master_publickey_t pk;
+       dipe_master_secretkey_t msk;
+       dipe_secretkey_t sk;
+
+       element_t y[6];
+       element_t x[6];
+
+       for (size_t i = 0; i < 6; i+=2) {
+               element_init_Zr(y[i], *dipe_get_pairing(param));
+               element_init_Zr(x[i], *dipe_get_pairing(param));
+               element_init_Zr(y[i+1], *dipe_get_pairing(param));
+               element_init_Zr(x[i+1], *dipe_get_pairing(param));
+
+               element_set1(y[i]);
+               element_set1(x[i+1]);
+               element_random(y[i+1]);
+               element_neg(x[i], y[i+1]);
+       }
+
+       dipe_master_keygen(param, 6, &pk, &msk);
+       dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
+       overhead = dipe_ciphertext_overhead(param, 6);
+
+       char ctxt[overhead + 35];
+       char ptxt[overhead + 35];
+
+
+       for (size_t clen = overhead; clen <= overhead + 35; ++clen) {
+               memset(ctxt, 0, overhead + 35);
+               memset(ptxt, 0, overhead + 35);
+               memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc", 35);
+
+               dipe_encrypt(param, pk, x, 35, ptxt, clen, ctxt);
+               ptxt_len = dipe_decrypt(param, sk, "1234567890abcdef", y, clen, ctxt, ptxt);
+
+               if (clen >= overhead + 35) {
+                       EXPECT_EQ(ptxt_len, 35);
+                       EXPECT_STREQ(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc");
+               }
+               else {
+                       EXPECT_EQ(ptxt_len, 0);
+               }
+       }
+
+       for (size_t i = 0; i < 6; ++i) {
+               element_clear(y[i]);
+               element_clear(x[i]);
+       }
+
+       dipe_free_master_secretkey(msk);
+       dipe_free_master_publickey(pk);
+       dipe_free_secretkey(sk);
+}
+
+
+
 
 int main(int argc, char **argv) {
        ::testing::InitGoogleTest(&argc, argv);