implement hybrid encryption

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

diff --git a/tests/testDIPE.cpp b/tests/testDIPE.cpp
index 0a3e209a2be6fff68919733d9d5755f85dab1143..4219ba46ec3f182ef9c178b34478f97628b21424 100644 (file)
--- a/tests/testDIPE.cpp
+++ b/tests/testDIPE.cpp
@@ -24,10 +24,10 @@ TEST(DipeTest, DipeKeygen) {
                element_init_Zr(y[i], *dipe_get_pairing(param));
                element_random(y[i]);
        }
-       
+
        dipe_master_keygen(param, 5, &pk, &msk);
        dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
-       
+
        dipe_free_master_secretkey(msk);
        dipe_free_master_publickey(pk);
        dipe_free_secretkey(sk);
@@ -37,18 +37,18 @@ TEST(DipeTest, DipeKeygen) {
        }
 }
 
-TEST(DipeTest, DipeDecryptFail) {
+TEST(DipeTest, DipeDecapFail) {
        dipe_ctxt_t ctxt;
        dipe_master_publickey_t pk;
        dipe_master_secretkey_t msk;
        dipe_secretkey_t sk;
-       
+
        element_t y[5];
        for (size_t i = 0; i < 5; ++i) {
                element_init_Zr(y[i], *dipe_get_pairing(param));
                element_random(y[i]);
        }
-       
+
        dipe_master_keygen(param, 5, &pk, &msk);
        dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
 
@@ -57,16 +57,16 @@ TEST(DipeTest, DipeDecryptFail) {
        element_init_GT(ptxtp, *dipe_get_pairing(param));
 
        element_random(ptxt);
-       
-       dipe_encrypt(param, pk, y, ptxt, &ctxt);
-       dipe_decrypt(param, sk, "1234567890abcdef", y, ctxt, ptxtp);
+
+       dipe_encap(param, pk, y, ptxt, &ctxt);
+       dipe_decap(param, sk, "1234567890abcdef", y, ctxt, ptxtp);
 
        EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
 
        for (size_t i = 0; i < 5; ++i) {
                element_clear(y[i]);
        }
-       
+
        element_clear(ptxt);
        element_clear(ptxtp);
 
@@ -76,18 +76,18 @@ TEST(DipeTest, DipeDecryptFail) {
        dipe_free_ctxt(ctxt);
 }
 
-TEST(DipeTest, DipeDecryptSuccess) {
+TEST(DipeTest, DipeDecapTrivialSuccess) {
        dipe_ctxt_t ctxt;
        dipe_master_publickey_t pk;
        dipe_master_secretkey_t msk;
        dipe_secretkey_t sk;
-       
+
        element_t y[5];
        for (size_t i = 0; i < 5; ++i) {
                element_init_Zr(y[i], *dipe_get_pairing(param));
                element_set0(y[i]);
        }
-       
+
        dipe_master_keygen(param, 5, &pk, &msk);
        dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
 
@@ -96,18 +96,73 @@ TEST(DipeTest, DipeDecryptSuccess) {
        element_init_GT(ptxtp, *dipe_get_pairing(param));
 
        element_random(ptxt);
-       
-       dipe_encrypt(param, pk, y, ptxt, &ctxt);
-       dipe_decrypt(param, sk, "1234567890abcdef", y, ctxt, ptxtp);
-       element_printf("%B\n", ptxt);
-       element_printf("%B\n", ptxtp);
+
+       dipe_encap(param, pk, y, ptxt, &ctxt);
+       dipe_decap(param, sk, "1234567890abcdef", y, ctxt, ptxtp);
 
        EXPECT_EQ(element_cmp(ptxt, ptxtp), 0);
 
        for (size_t i = 0; i < 5; ++i) {
                element_clear(y[i]);
        }
-       
+
+       element_clear(ptxt);
+       element_clear(ptxtp);
+
+       dipe_free_master_secretkey(msk);
+       dipe_free_master_publickey(pk);
+       dipe_free_secretkey(sk);
+       dipe_free_ctxt(ctxt);
+}
+
+TEST(DipeTest, DipeDecapSuccess) {
+       dipe_ctxt_t ctxt;
+       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);
+
+       element_t ptxt, ptxtp;
+       element_init_GT(ptxt, *dipe_get_pairing(param));
+       element_init_GT(ptxtp, *dipe_get_pairing(param));
+
+       element_random(ptxt);
+
+       dipe_encap(param, pk, x, ptxt, &ctxt);
+
+       dipe_decap(param, sk, "1234567890abcdef", y, ctxt, ptxtp);
+       EXPECT_EQ(element_cmp(ptxt, ptxtp), 0);
+
+       /* non-matching CID */
+       dipe_decap(param, sk, "fedcba0987654321", y, ctxt, ptxtp);
+       EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
+
+       /* inconsistent y value */
+       dipe_decap(param, sk, "1234567890abcdef", x, ctxt, ptxtp);
+       EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
+
+       for (size_t i = 0; i < 6; ++i) {
+               element_clear(y[i]);
+               element_clear(x[i]);
+       }
+
        element_clear(ptxt);
        element_clear(ptxtp);
 
@@ -117,9 +172,64 @@ TEST(DipeTest, DipeDecryptSuccess) {
        dipe_free_ctxt(ctxt);
 }
 
+TEST(DipeTest, DipeDecryptSuccessSmall) {
+       char ctxt[768];
+       char ptxt[768];
+       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 < 768; ++clen) {
+               memset(ctxt, 0, 768);
+               memset(ptxt, 0, 768);
+               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");
+               }
+               else {
+                       ASSERT_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);
+       ::testing::InitGoogleTest(&argc, argv);
 
        dipe_init(fopen("../tests/a.param", "r"), &param);
 
@@ -127,4 +237,3 @@ int main(int argc, char **argv) {
        dipe_free_param(param);
        return result;
 }
-