integrate secret sharing

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

diff --git a/tests/testDIPE.cpp b/tests/testDIPE.cpp
index 782409c0f554760afd2b6349add774d6c6e2ad71..0c8e155b00234e78e1c1fb004964e3e506f81483 100644 (file)
--- a/tests/testDIPE.cpp
+++ b/tests/testDIPE.cpp
@@ -58,8 +58,8 @@ TEST(DipeTest, DipeDecapFail) {
 
        element_random(ptxt);
 
-       dipe_encap(param, pk, y, ptxt, &ctxt);
-       dipe_decap(param, sk, "1234567890abcdef", y, ctxt, ptxtp);
+       dipe_encap(param, 1, &pk, 1, y, ptxt, &ctxt);
+       dipe_decap(param, 1, &sk, "1234567890abcdef", y, ctxt, ptxtp);
 
        EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
 
@@ -97,8 +97,8 @@ TEST(DipeTest, DipeDecapTrivialSuccess) {
 
        element_random(ptxt);
 
-       dipe_encap(param, pk, y, ptxt, &ctxt);
-       dipe_decap(param, sk, "1234567890abcdef", y, ctxt, ptxtp);
+       dipe_encap(param, 1, &pk, 1, y, ptxt, &ctxt);
+       dipe_decap(param, 1, &sk, "1234567890abcdef", y, ctxt, ptxtp);
 
        EXPECT_EQ(element_cmp(ptxt, ptxtp), 0);
 
@@ -145,17 +145,17 @@ TEST(DipeTest, DipeDecapSuccess) {
 
        element_random(ptxt);
 
-       dipe_encap(param, pk, x, ptxt, &ctxt);
+       dipe_encap(param, 1, &pk, 1, x, ptxt, &ctxt);
 
-       dipe_decap(param, sk, "1234567890abcdef", y, ctxt, ptxtp);
+       dipe_decap(param, 1, &sk, "1234567890abcdef", y, ctxt, ptxtp);
        EXPECT_EQ(element_cmp(ptxt, ptxtp), 0);
 
        /* non-matching CID */
-       dipe_decap(param, sk, "fedcba0987654321", y, ctxt, ptxtp);
+       dipe_decap(param, 1, &sk, "fedcba0987654321", y, ctxt, ptxtp);
        EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
 
        /* inconsistent y value */
-       dipe_decap(param, sk, "1234567890abcdef", x, ctxt, ptxtp);
+       dipe_decap(param, 1, &sk, "1234567890abcdef", x, ctxt, ptxtp);
        EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
 
        for (size_t i = 0; i < 6; ++i) {
@@ -198,15 +198,15 @@ TEST(DipeTest, DipeDecryptSuccessSmall) {
 
        dipe_master_keygen(param, 6, &pk, &msk);
        dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
-       overhead = dipe_ciphertext_overhead(param, 6);
+       overhead = dipe_ciphertext_overhead(param, 6, 0);
 
        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);
+               dipe_encrypt(param, 1, &pk, 1, x, 4, ptxt, clen, ctxt);
+               ptxt_len = dipe_decrypt(param, 1, &sk, "1234567890abcdef", y, clen, ctxt, ptxt);
 
                if (clen >= overhead + 4) {
                        EXPECT_EQ(ptxt_len, 4);
@@ -251,7 +251,7 @@ TEST(DipeTest, DipeDecryptSuccessTightSmall) {
 
        dipe_master_keygen(param, 6, &pk, &msk);
        dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
-       overhead = dipe_ciphertext_overhead(param, 6);
+       overhead = dipe_ciphertext_overhead(param, 6, 0);
 
        char ctxt[overhead + 4];
        char ptxt[overhead + 4];
@@ -261,8 +261,8 @@ TEST(DipeTest, DipeDecryptSuccessTightSmall) {
                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);
+               dipe_encrypt(param, 1, &pk, 1, x, 4, ptxt, clen, ctxt);
+               ptxt_len = dipe_decrypt(param, 1, &sk, "1234567890abcdef", y, clen, ctxt, ptxt);
 
                if (clen >= overhead + 4) {
                        EXPECT_EQ(ptxt_len, 4);
@@ -310,15 +310,15 @@ TEST(DipeTest, DipeDecryptSuccessLargeBlocksize) {
 
        dipe_master_keygen(param, 6, &pk, &msk);
        dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
-       overhead = dipe_ciphertext_overhead(param, 6);
+       overhead = dipe_ciphertext_overhead(param, 6, 0);
 
        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);
+               dipe_encrypt(param, 1, &pk, 1, x, 28, ptxt, clen, ctxt);
+               ptxt_len = dipe_decrypt(param, 1, &sk, "1234567890abcdef", y, clen, ctxt, ptxt);
 
                if (clen >= overhead + 28) {
                        EXPECT_EQ(ptxt_len, 28);
@@ -363,7 +363,7 @@ TEST(DipeTest, DipeDecryptSuccessTightLargeBlocksize) {
 
        dipe_master_keygen(param, 6, &pk, &msk);
        dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
-       overhead = dipe_ciphertext_overhead(param, 6);
+       overhead = dipe_ciphertext_overhead(param, 6, 0);
 
        char ctxt[overhead + 28];
        char ptxt[overhead + 28];
@@ -374,8 +374,8 @@ TEST(DipeTest, DipeDecryptSuccessTightLargeBlocksize) {
                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);
+               dipe_encrypt(param, 1, &pk, 1, x, 28, ptxt, clen, ctxt);
+               ptxt_len = dipe_decrypt(param, 1, &sk, "1234567890abcdef", y, clen, ctxt, ptxt);
 
                if (clen >= overhead + 28) {
                        EXPECT_EQ(ptxt_len, 28);
@@ -423,15 +423,15 @@ TEST(DipeTest, DipeDecryptSuccessLargeNonBlocksize) {
 
        dipe_master_keygen(param, 6, &pk, &msk);
        dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
-       overhead = dipe_ciphertext_overhead(param, 6);
+       overhead = dipe_ciphertext_overhead(param, 6, 0);
 
        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);
+               dipe_encrypt(param, 1, &pk, 1, x, 35, ptxt, clen, ctxt);
+               ptxt_len = dipe_decrypt(param, 1, &sk, "1234567890abcdef", y, clen, ctxt, ptxt);
 
                if (clen >= overhead + 35) {
                        EXPECT_EQ(ptxt_len, 35);
@@ -476,7 +476,7 @@ TEST(DipeTest, DipeDecryptSuccessTightLargeNonBlocksize) {
 
        dipe_master_keygen(param, 6, &pk, &msk);
        dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
-       overhead = dipe_ciphertext_overhead(param, 6);
+       overhead = dipe_ciphertext_overhead(param, 6, 0);
 
        char ctxt[overhead + 35];
        char ptxt[overhead + 35];
@@ -487,8 +487,8 @@ TEST(DipeTest, DipeDecryptSuccessTightLargeNonBlocksize) {
                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);
+               dipe_encrypt(param, 1, &pk, 1, x, 35, ptxt, clen, ctxt);
+               ptxt_len = dipe_decrypt(param, 1, &sk, "1234567890abcdef", y, clen, ctxt, ptxt);
 
                if (clen >= overhead + 35) {
                        EXPECT_EQ(ptxt_len, 35);