tests/testDIPE.cpp

   1 #include <gtest/gtest.h>
   2 #include <pbc/pbc.h>
   3
   4 #include "DIPE.h"
   5
   6 static dipe_param_t param;
   7
   8 TEST(DipeTest, DipeMasterKeygen) {
   9         dipe_master_publickey_t pk;
  10         dipe_master_secretkey_t sk;
  11
  12         dipe_master_keygen(param, 12, &pk, &sk);
  13
  14         dipe_free_master_secretkey(sk);
  15         dipe_free_master_publickey(pk);
  16 }
  17
  18 TEST(DipeTest, DipeKeygen) {
  19         dipe_master_publickey_t pk;
  20         dipe_master_secretkey_t msk;
  21         dipe_secretkey_t sk;
  22         element_t y[5];
  23         for (size_t i = 0; i < 5; ++i) {
  24                 element_init_Zr(y[i], *dipe_get_pairing(param));
  25                 element_random(y[i]);
  26         }
  27
  28         dipe_master_keygen(param, 5, &pk, &msk);
  29         dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
  30
  31         dipe_free_master_secretkey(msk);
  32         dipe_free_master_publickey(pk);
  33         dipe_free_secretkey(sk);
  34
  35         for (size_t i = 0; i < 5; ++i) {
  36                 element_clear(y[i]);
  37         }
  38 }
  39
  40 TEST(DipeTest, DipeDecapFail) {
  41         dipe_ctxt_t ctxt;
  42         dipe_master_publickey_t pk;
  43         dipe_master_secretkey_t msk;
  44         dipe_secretkey_t sk;
  45
  46         element_t y[5];
  47         for (size_t i = 0; i < 5; ++i) {
  48                 element_init_Zr(y[i], *dipe_get_pairing(param));
  49                 element_random(y[i]);
  50         }
  51
  52         dipe_master_keygen(param, 5, &pk, &msk);
  53         dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
  54
  55         element_t ptxt, ptxtp;
  56         element_init_GT(ptxt, *dipe_get_pairing(param));
  57         element_init_GT(ptxtp, *dipe_get_pairing(param));
  58
  59         element_random(ptxt);
  60
  61         dipe_encap(param, pk, y, ptxt, &ctxt);
  62         dipe_decap(param, sk, "1234567890abcdef", y, ctxt, ptxtp);
  63
  64         EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
  65
  66         for (size_t i = 0; i < 5; ++i) {
  67                 element_clear(y[i]);
  68         }
  69
  70         element_clear(ptxt);
  71         element_clear(ptxtp);
  72
  73         dipe_free_master_secretkey(msk);
  74         dipe_free_master_publickey(pk);
  75         dipe_free_secretkey(sk);
  76         dipe_free_ctxt(ctxt);
  77 }
  78
  79 TEST(DipeTest, DipeDecapTrivialSuccess) {
  80         dipe_ctxt_t ctxt;
  81         dipe_master_publickey_t pk;
  82         dipe_master_secretkey_t msk;
  83         dipe_secretkey_t sk;
  84
  85         element_t y[5];
  86         for (size_t i = 0; i < 5; ++i) {
  87                 element_init_Zr(y[i], *dipe_get_pairing(param));
  88                 element_set0(y[i]);
  89         }
  90
  91         dipe_master_keygen(param, 5, &pk, &msk);
  92         dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
  93
  94         element_t ptxt, ptxtp;
  95         element_init_GT(ptxt, *dipe_get_pairing(param));
  96         element_init_GT(ptxtp, *dipe_get_pairing(param));
  97
  98         element_random(ptxt);
  99
 100         dipe_encap(param, pk, y, ptxt, &ctxt);
 101         dipe_decap(param, sk, "1234567890abcdef", y, ctxt, ptxtp);
 102
 103         EXPECT_EQ(element_cmp(ptxt, ptxtp), 0);
 104
 105         for (size_t i = 0; i < 5; ++i) {
 106                 element_clear(y[i]);
 107         }
 108
 109         element_clear(ptxt);
 110         element_clear(ptxtp);
 111
 112         dipe_free_master_secretkey(msk);
 113         dipe_free_master_publickey(pk);
 114         dipe_free_secretkey(sk);
 115         dipe_free_ctxt(ctxt);
 116 }
 117
 118 TEST(DipeTest, DipeDecapSuccess) {
 119         dipe_ctxt_t ctxt;
 120         dipe_master_publickey_t pk;
 121         dipe_master_secretkey_t msk;
 122         dipe_secretkey_t sk;
 123
 124         element_t y[6];
 125         element_t x[6];
 126
 127         for (size_t i = 0; i < 6; i+=2) {
 128                 element_init_Zr(y[i], *dipe_get_pairing(param));
 129                 element_init_Zr(x[i], *dipe_get_pairing(param));
 130                 element_init_Zr(y[i+1], *dipe_get_pairing(param));
 131                 element_init_Zr(x[i+1], *dipe_get_pairing(param));
 132
 133                 element_set1(y[i]);
 134                 element_set1(x[i+1]);
 135                 element_random(y[i+1]);
 136                 element_neg(x[i], y[i+1]);
 137         }
 138
 139         dipe_master_keygen(param, 6, &pk, &msk);
 140         dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
 141
 142         element_t ptxt, ptxtp;
 143         element_init_GT(ptxt, *dipe_get_pairing(param));
 144         element_init_GT(ptxtp, *dipe_get_pairing(param));
 145
 146         element_random(ptxt);
 147
 148         dipe_encap(param, pk, x, ptxt, &ctxt);
 149
 150         dipe_decap(param, sk, "1234567890abcdef", y, ctxt, ptxtp);
 151         EXPECT_EQ(element_cmp(ptxt, ptxtp), 0);
 152
 153         /* non-matching CID */
 154         dipe_decap(param, sk, "fedcba0987654321", y, ctxt, ptxtp);
 155         EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
 156
 157         /* inconsistent y value */
 158         dipe_decap(param, sk, "1234567890abcdef", x, ctxt, ptxtp);
 159         EXPECT_NE(element_cmp(ptxt, ptxtp), 0);
 160
 161         for (size_t i = 0; i < 6; ++i) {
 162                 element_clear(y[i]);
 163                 element_clear(x[i]);
 164         }
 165
 166         element_clear(ptxt);
 167         element_clear(ptxtp);
 168
 169         dipe_free_master_secretkey(msk);
 170         dipe_free_master_publickey(pk);
 171         dipe_free_secretkey(sk);
 172         dipe_free_ctxt(ctxt);
 173 }
 174
 175 TEST(DipeTest, DipeDecryptSuccessSmall) {
 176         char ctxt[768];
 177         char ptxt[768];
 178         size_t ptxt_len;
 179         size_t overhead;
 180         dipe_master_publickey_t pk;
 181         dipe_master_secretkey_t msk;
 182         dipe_secretkey_t sk;
 183
 184         element_t y[6];
 185         element_t x[6];
 186
 187         for (size_t i = 0; i < 6; i+=2) {
 188                 element_init_Zr(y[i], *dipe_get_pairing(param));
 189                 element_init_Zr(x[i], *dipe_get_pairing(param));
 190                 element_init_Zr(y[i+1], *dipe_get_pairing(param));
 191                 element_init_Zr(x[i+1], *dipe_get_pairing(param));
 192
 193                 element_set1(y[i]);
 194                 element_set1(x[i+1]);
 195                 element_random(y[i+1]);
 196                 element_neg(x[i], y[i+1]);
 197         }
 198
 199         dipe_master_keygen(param, 6, &pk, &msk);
 200         dipe_keygen(param, msk, "1234567890abcdef", y, &sk);
 201         overhead = dipe_ciphertext_overhead(param, 6);
 202
 203         for (size_t clen = overhead; clen < 768; ++clen) {
 204                 memset(ctxt, 0, 768);
 205                 memset(ptxt, 0, 768);
 206                 memcpy(ptxt, "test", 4);
 207
 208                 dipe_encrypt(param, pk, x, 4, ptxt, clen, ctxt);
 209                 ptxt_len = dipe_decrypt(param, sk, "1234567890abcdef", y, clen, ctxt, ptxt);
 210
 211                 if (clen >= overhead) {
 212                         ASSERT_EQ(ptxt_len, 4);
 213                         ASSERT_STREQ(ptxt, "test");
 214                 }
 215                 else {
 216                         ASSERT_EQ(ptxt_len, 0);
 217                 }
 218         }
 219
 220         for (size_t i = 0; i < 6; ++i) {
 221                 element_clear(y[i]);
 222                 element_clear(x[i]);
 223         }
 224
 225         dipe_free_master_secretkey(msk);
 226         dipe_free_master_publickey(pk);
 227         dipe_free_secretkey(sk);
 228 }
 229
 230
 231 int main(int argc, char **argv) {
 232         ::testing::InitGoogleTest(&argc, argv);
 233
 234         dipe_init(fopen("../tests/a.param", "r"), &param);
 235
 236         int result = RUN_ALL_TESTS();
 237         dipe_free_param(param);
 238         return result;
 239 }