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);
}
}
-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);
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, 1, &pk, 1, y, ptxt, &ctxt);
+ dipe_decap(param, 1, &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);
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);
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, 1, &pk, 1, y, ptxt, &ctxt);
+ dipe_decap(param, 1, &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_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, 1, &pk, 1, x, ptxt, &ctxt);
+
+ dipe_decap(param, 1, &sk, "1234567890abcdef", y, ctxt, ptxtp);
+ EXPECT_EQ(element_cmp(ptxt, ptxtp), 0);
+
+ /* non-matching CID */
+ dipe_decap(param, 1, &sk, "fedcba0987654321", y, ctxt, ptxtp);
+ EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
+
+ /* inconsistent y value */
+ dipe_decap(param, 1, &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);
+
+ dipe_free_master_secretkey(msk);
+ dipe_free_master_publickey(pk);
+ dipe_free_secretkey(sk);
+ dipe_free_ctxt(ctxt);
+}
+
+TEST(DipeTest, DipeDecryptSuccessSmall) {
+ 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, "test", 4);
+
+ 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);
+ 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, 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, "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, "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, "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, "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, "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);
+ ::testing::InitGoogleTest(&argc, argv);
dipe_init(fopen("../tests/a.param", "r"), ¶m);
dipe_free_param(param);
return result;
}
-
projects / software / DIPE.git / blobdiff