X-Git-Url: https://git.siccegge.de//index.cgi?a=blobdiff_plain;f=tests%2FtestDIPE.cpp;h=a436c24c7914be8df0184eb26ea95752031a9a42;hb=HEAD;hp=4219ba46ec3f182ef9c178b34478f97628b21424;hpb=d4e7cbce6db6c8a08ca82b12d9eeaa5a4f59fc3e;p=software%2FDIPE.git

diff --git a/tests/testDIPE.cpp b/tests/testDIPE.cpp
index 4219ba4..a436c24 100644
--- 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) {
@@ -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;
@@ -198,25 +198,307 @@ 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 < 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);
+		dipe_encrypt(param, 1, &pk, 1, x, 4, ptxt, clen, ctxt);
+		ptxt_len = dipe_decrypt(param, 1, &sk, 0, "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, 0);
+
+	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, 1, &pk, 1, x, 4, ptxt, clen, ctxt);
+		ptxt_len = dipe_decrypt(param, 1, &sk, 0, "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, 0);
+
+	for (size_t clen = overhead; clen <= 672; ++clen) {
+		memset(ctxt, 0, 672);
+		memset(ptxt, 0, 672);
+		memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbb", 28);
+
+		dipe_encrypt(param, 1, &pk, 1, x, 28, ptxt, clen, ctxt);
+		ptxt_len = dipe_decrypt(param, 1, &sk, 0, "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, 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, 0);
+
+	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, 1, &pk, 1, x, 28, ptxt, clen, ctxt);
+		ptxt_len = dipe_decrypt(param, 1, &sk, 0, "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, 0);
+
+	for (size_t clen = overhead; clen <= 672; ++clen) {
+		memset(ctxt, 0, 672);
+		memset(ptxt, 0, 672);
+		memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc", 35);
+
+		dipe_encrypt(param, 1, &pk, 1, x, 35, ptxt, clen, ctxt);
+		ptxt_len = dipe_decrypt(param, 1, &sk, 0, "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, 0);
+
+	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, 1, &pk, 1, x, 35, ptxt, clen, ctxt);
+		ptxt_len = dipe_decrypt(param, 1, &sk, 0, "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]);
@@ -227,6 +509,132 @@ TEST(DipeTest, DipeDecryptSuccessSmall) {
 	dipe_free_secretkey(sk);
 }
 
+TEST(DipeTest, DipeDecryptSuccessMultiKey) {
+	size_t ptxt_len;
+	size_t overhead;
+	dipe_master_publickey_t pk[3];
+	dipe_master_secretkey_t msk[3];
+	dipe_secretkey_t sk[3];
+
+	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]);
+	}
+
+	for (size_t i = 0; i < 3; ++i) {
+		dipe_master_keygen(param, 6, &pk[i], &msk[i]);
+		dipe_keygen(param, msk[i], "1234567890abcdef", y, &sk[i]);
+	}
+	overhead = dipe_ciphertext_overhead(param, 6, 0);
+
+	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, 3, pk, 3, x, 35, ptxt, clen, ctxt);
+		ptxt_len = dipe_decrypt(param, 3, sk, 0, "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]);
+	}
+
+	for (size_t i = 0; i < 3; ++i) {
+		dipe_free_master_secretkey(msk[i]);
+		dipe_free_master_publickey(pk[i]);
+		dipe_free_secretkey(sk[i]);
+	}
+}
+
+TEST(DipeTest, DipeDecryptSuccessThreshold) {
+	size_t ptxt_len;
+	size_t overhead;
+	dipe_master_publickey_t pk[3];
+	dipe_master_secretkey_t msk[3];
+	dipe_secretkey_t sk[3];
+
+	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]);
+	}
+
+	for (size_t i = 0; i < 3; ++i) {
+		dipe_master_keygen(param, 6, &pk[i], &msk[i]);
+		dipe_keygen(param, msk[i], "1234567890abcdef", y, &sk[i]);
+	}
+	overhead = dipe_ciphertext_overhead(param, 6, 2);
+
+	char ctxt[overhead + 35];
+	char ptxt[overhead + 35];
+
+
+	for (size_t clen = overhead+20; clen <= overhead + 35; ++clen) {
+		for (size_t kid = 0; kid < 3; ++kid) {
+			memset(ctxt, 0, overhead + 35);
+			memset(ptxt, 0, overhead + 35);
+			memcpy(ptxt, "aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccc", 35);
+
+			dipe_encrypt(param, 3, pk, 1, x, 35, ptxt, clen, ctxt);
+			ptxt_len = dipe_decrypt(param, 1, &sk[kid], 2, "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]);
+	}
+
+	for (size_t i = 0; i < 3; ++i) {
+		dipe_free_master_secretkey(msk[i]);
+		dipe_free_master_publickey(pk[i]);
+		dipe_free_secretkey(sk[i]);
+	}
+}
+
+
+
 
 int main(int argc, char **argv) {
 	::testing::InitGoogleTest(&argc, argv);