1 /*############################################################################
2   # Copyright 2016-2017 Intel Corporation
3   #
4   # Licensed under the Apache License, Version 2.0 (the "License");
5   # you may not use this file except in compliance with the License.
6   # You may obtain a copy of the License at
7   #
8   #     http://www.apache.org/licenses/LICENSE-2.0
9   #
10   # Unless required by applicable law or agreed to in writing, software
11   # distributed under the License is distributed on an "AS IS" BASIS,
12   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   # See the License for the specific language governing permissions and
14   # limitations under the License.
15   ############################################################################*/
16 
17 /*!
18  * \file
19  * \brief Member unit tests.
20  */
21 #include <cstring>
22 #include <vector>
23 
24 #include "epid/common-testhelper/epid_gtest-testhelper.h"
25 #include "gtest/gtest.h"
26 
27 #include "epid/common-testhelper/epid2params_wrapper-testhelper.h"
28 #include "epid/common-testhelper/errors-testhelper.h"
29 #include "epid/common-testhelper/mem_params-testhelper.h"
30 #include "epid/common-testhelper/prng-testhelper.h"
31 #include "epid/member/tiny/unittests/member-testhelper.h"
32 
33 extern "C" {
34 #include "epid/member/api.h"
35 }
operator ==(MemberPrecomp const & lhs,MemberPrecomp const & rhs)36 bool operator==(MemberPrecomp const& lhs, MemberPrecomp const& rhs) {
37   return 0 == std::memcmp(&lhs, &rhs, sizeof(lhs));
38 }
39 /// compares GroupPubKey values
40 bool operator==(GroupPubKey const& lhs, GroupPubKey const& rhs);
41 
42 /// compares MembershipCredential values
43 bool operator==(MembershipCredential const& lhs,
44                 MembershipCredential const& rhs);
45 namespace {
46 //////////////////////////////////////////////////////////////////////////
47 // EpidMemberDeinit Tests
TEST_F(EpidMemberTest,DeinitWorksGivenNullMemberCtx)48 TEST_F(EpidMemberTest, DeinitWorksGivenNullMemberCtx) {
49   EpidMemberDeinit(nullptr);
50 }
51 
52 //////////////////////////////////////////////////////////////////////////
53 // EpidMemberGetSize Tests
TEST_F(EpidMemberTest,GetSizeFailsGivenNullParams)54 TEST_F(EpidMemberTest, GetSizeFailsGivenNullParams) {
55   size_t ctx_size = 0;
56   MemberParams params = {0};
57   EXPECT_EQ(kEpidBadArgErr, EpidMemberGetSize(&params, nullptr));
58   EXPECT_EQ(kEpidBadArgErr, EpidMemberGetSize(nullptr, &ctx_size));
59   EXPECT_EQ(kEpidBadArgErr, EpidMemberGetSize(nullptr, nullptr));
60 }
61 
62 //////////////////////////////////////////////////////////////////////////
63 // EpidMemberGetSize Tests
TEST_F(EpidMemberTest,GetSizeWorksGivenValidParams)64 TEST_F(EpidMemberTest, GetSizeWorksGivenValidParams) {
65   size_t ctx_size = 0;
66   Prng my_prng;
67   MemberParams params = {0};
68   SetMemberParams(&Prng::Generate, &my_prng, nullptr, &params);
69   EXPECT_EQ(kEpidNoErr, EpidMemberGetSize(&params, &ctx_size));
70 }
71 
72 //////////////////////////////////////////////////////////////////////////
73 // EpidMemberInit Tests
TEST_F(EpidMemberTest,InitFailsGivenNullParameters)74 TEST_F(EpidMemberTest, InitFailsGivenNullParameters) {
75   size_t ctx_size = 0;
76   MemberCtx* ctx = nullptr;
77   Prng my_prng;
78   MemberParams params = {0};
79   std::vector<uint8_t> ctx_buf;
80   SetMemberParams(&Prng::Generate, &my_prng, nullptr, &params);
81   EXPECT_EQ(kEpidNoErr, EpidMemberGetSize(&params, &ctx_size));
82   ctx_buf.resize(ctx_size);
83   ctx = (MemberCtx*)&ctx_buf[0];
84 
85   EXPECT_EQ(kEpidBadArgErr, EpidMemberInit(nullptr, nullptr));
86   EXPECT_EQ(kEpidBadArgErr, EpidMemberInit(&params, nullptr));
87   EXPECT_EQ(kEpidBadArgErr, EpidMemberInit(nullptr, ctx));
88 }
89 
TEST_F(EpidMemberTest,InitFailsGivenInvalidParameters)90 TEST_F(EpidMemberTest, InitFailsGivenInvalidParameters) {
91   FpElemStr f = {
92       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
93       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
94       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
95   };
96   size_t ctx_size = 0;
97   MemberCtx* ctx = nullptr;
98   Prng my_prng;
99   MemberParams params = {0};
100   std::vector<uint8_t> ctx_buf;
101   SetMemberParams(&Prng::Generate, &my_prng, &f, &params);
102   EXPECT_EQ(kEpidNoErr, EpidMemberGetSize(&params, &ctx_size));
103   ctx_buf.resize(ctx_size);
104   ctx = (MemberCtx*)&ctx_buf[0];
105 
106   EXPECT_EQ(kEpidBadArgErr, EpidMemberInit(&params, ctx));
107 }
108 
TEST_F(EpidMemberTest,InitSucceedsGivenValidParameters)109 TEST_F(EpidMemberTest, InitSucceedsGivenValidParameters) {
110   FpElemStr f = {
111       0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
112       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
113       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
114   };
115   size_t ctx_size = 0;
116   MemberCtx* ctx = nullptr;
117   Prng my_prng;
118   MemberParams params = {0};
119   std::vector<uint8_t> ctx_buf;
120   SetMemberParams(&Prng::Generate, &my_prng, &f, &params);
121   EXPECT_EQ(kEpidNoErr, EpidMemberGetSize(&params, &ctx_size));
122   ctx_buf.resize(ctx_size);
123   ctx = (MemberCtx*)&ctx_buf[0];
124 
125   EXPECT_EQ(kEpidNoErr, EpidMemberInit(&params, ctx));
126   EpidMemberDeinit(ctx);
127 }
128 
TEST_F(EpidMemberTest,InitSucceedsGivenValidParametersWithNoF)129 TEST_F(EpidMemberTest, InitSucceedsGivenValidParametersWithNoF) {
130   size_t ctx_size = 0;
131   MemberCtx* ctx = nullptr;
132   Prng my_prng;
133   MemberParams params = {0};
134   std::vector<uint8_t> ctx_buf;
135   SetMemberParams(&Prng::Generate, &my_prng, nullptr, &params);
136   EXPECT_EQ(kEpidNoErr, EpidMemberGetSize(&params, &ctx_size));
137   ctx_buf.resize(ctx_size);
138   ctx = (MemberCtx*)&ctx_buf[0];
139 
140   EXPECT_EQ(kEpidNoErr, EpidMemberInit(&params, ctx));
141   EpidMemberDeinit(ctx);
142 }
143 
144 //////////////////////////////////////////////////////////////////////////
145 // EpidMemberCreate Tests
TEST_F(EpidMemberTest,CreateIsNotImplemented)146 TEST_F(EpidMemberTest, CreateIsNotImplemented) {
147   MemberCtx* ctx = nullptr;
148   Prng my_prng;
149   MemberParams params = {0};
150   SetMemberParams(&Prng::Generate, &my_prng, nullptr, &params);
151   EXPECT_EQ(kEpidNotImpl, EpidMemberCreate(&params, &ctx));
152   EpidMemberDelete(&ctx);
153 }
154 
155 //////////////////////////////////////////////////////////////////////////
156 // EpidMemberStartup
TEST_F(EpidMemberTest,StartupFailsGivenNullParameters)157 TEST_F(EpidMemberTest, StartupFailsGivenNullParameters) {
158   EXPECT_EQ(kEpidBadArgErr, EpidMemberStartup(nullptr));
159 }
160 
TEST_F(EpidMemberTest,StartupSucceedsGivenValidParameters)161 TEST_F(EpidMemberTest, StartupSucceedsGivenValidParameters) {
162   Prng prng;
163   GroupPubKey pub_key = this->kGroupPublicKey;
164   PrivKey priv_key = this->kMemberPrivateKey;
165   MemberParams params = {0};
166   SetMemberParams(&Prng::Generate, &prng, nullptr, &params);
167   MemberCtxObj member(&params);
168   EXPECT_EQ(kEpidNoErr, EpidProvisionKey(member, &pub_key, &priv_key, nullptr));
169 
170   EXPECT_EQ(kEpidNoErr, EpidMemberStartup(member));
171 }
172 
173 //////////////////////////////////////////////////////////////////////////
174 // EpidMemberSetHashAlg
TEST_F(EpidMemberTest,SetHashAlgFailsGivenNullPtr)175 TEST_F(EpidMemberTest, SetHashAlgFailsGivenNullPtr) {
176   EXPECT_EQ(kEpidBadArgErr, EpidMemberSetHashAlg(nullptr, kSha256));
177 }
TEST_F(EpidMemberTest,CanSetHashAlgoToSHA256)178 TEST_F(EpidMemberTest, CanSetHashAlgoToSHA256) {
179   Prng my_prng;
180   MemberCtxObj member_ctx(&Prng::Generate, &my_prng);
181   EXPECT_EQ(kEpidNoErr, EpidMemberSetHashAlg(member_ctx, kSha256));
182 }
TEST_F(EpidMemberTest,DISABLED_CanSetHashAlgoToSHA384)183 TEST_F(EpidMemberTest, DISABLED_CanSetHashAlgoToSHA384) {
184   Prng my_prng;
185   MemberCtxObj member_ctx(&Prng::Generate, &my_prng);
186   EXPECT_EQ(kEpidNoErr, EpidMemberSetHashAlg(member_ctx, kSha384));
187 }
TEST_F(EpidMemberTest,CanSetHashAlgoToSHA512)188 TEST_F(EpidMemberTest, CanSetHashAlgoToSHA512) {
189   Prng my_prng;
190   MemberCtxObj member_ctx(&Prng::Generate, &my_prng);
191   EXPECT_EQ(kEpidNoErr, EpidMemberSetHashAlg(member_ctx, kSha512));
192 }
TEST_F(EpidMemberTest,DISABLED_CanSetHashAlgoToSHA512256)193 TEST_F(EpidMemberTest, DISABLED_CanSetHashAlgoToSHA512256) {
194   Prng my_prng;
195   MemberCtxObj member_ctx(&Prng::Generate, &my_prng);
196   EXPECT_EQ(kEpidNoErr, EpidMemberSetHashAlg(member_ctx, kSha512_256));
197 }
TEST_F(EpidMemberTest,SetHashAlgFailsForNonSupportedAlgorithm)198 TEST_F(EpidMemberTest, SetHashAlgFailsForNonSupportedAlgorithm) {
199   Prng my_prng;
200   MemberCtxObj member_ctx(&Prng::Generate, &my_prng);
201   EXPECT_EQ(kEpidBadArgErr, EpidMemberSetHashAlg(member_ctx, kSha3_256));
202   EXPECT_EQ(kEpidBadArgErr, EpidMemberSetHashAlg(member_ctx, kSha3_384));
203   EXPECT_EQ(kEpidBadArgErr, EpidMemberSetHashAlg(member_ctx, kSha3_512));
204   EXPECT_EQ(kEpidBadArgErr, EpidMemberSetHashAlg(member_ctx, (HashAlg)-1));
205 }
206 
TEST_F(EpidMemberTest,SetHashAlgRejectsSHA384)207 TEST_F(EpidMemberTest, SetHashAlgRejectsSHA384) {
208   Prng my_prng;
209   MemberCtxObj member_ctx(&Prng::Generate, &my_prng);
210   EXPECT_EQ(kEpidBadArgErr, EpidMemberSetHashAlg(member_ctx, kSha384));
211 }
212 
TEST_F(EpidMemberTest,SetHashAlgRejectsSHA512256)213 TEST_F(EpidMemberTest, SetHashAlgRejectsSHA512256) {
214   Prng my_prng;
215   MemberCtxObj member_ctx(&Prng::Generate, &my_prng);
216   EXPECT_EQ(kEpidBadArgErr, EpidMemberSetHashAlg(member_ctx, kSha512_256));
217 }
218 
219 //////////////////////////////////////////////////////////////////////////
220 // EpidMemberSetSigRl
TEST_F(EpidMemberTest,SetSigRlFailsGivenNullPointer)221 TEST_F(EpidMemberTest, SetSigRlFailsGivenNullPointer) {
222   Prng my_prng;
223   MemberCtxObj member_ctx(this->kGroupPublicKey, this->kMemberPrivateKey,
224                           &Prng::Generate, &my_prng);
225   SigRl srl = {{{0}}, {{0}}, {{0}}, {{{{0}, {0}}, {{0}, {0}}}}};
226   srl.gid = this->kGroupPublicKey.gid;
227   EXPECT_EQ(kEpidBadArgErr, EpidMemberSetSigRl(nullptr, &srl, sizeof(SigRl)));
228   EXPECT_EQ(kEpidBadArgErr,
229             EpidMemberSetSigRl(member_ctx, nullptr, sizeof(SigRl)));
230 }
TEST_F(EpidMemberTest,SetSigRlFailsGivenZeroSize)231 TEST_F(EpidMemberTest, SetSigRlFailsGivenZeroSize) {
232   Prng my_prng;
233   MemberCtxObj member_ctx(this->kGroupPublicKey, this->kMemberPrivateKey,
234                           &Prng::Generate, &my_prng);
235   SigRl srl = {{{0}}, {{0}}, {{0}}, {{{{0}, {0}}, {{0}, {0}}}}};
236   srl.gid = this->kGroupPublicKey.gid;
237   EXPECT_EQ(kEpidBadArgErr, EpidMemberSetSigRl(member_ctx, &srl, 0));
238 }
239 // Size parameter must be at least big enough for n2 == 0 case
TEST_F(EpidMemberTest,SetSigRlFailsGivenTooSmallSize)240 TEST_F(EpidMemberTest, SetSigRlFailsGivenTooSmallSize) {
241   Prng my_prng;
242   MemberCtxObj member_ctx(this->kGroupPublicKey, this->kMemberPrivateKey,
243                           &Prng::Generate, &my_prng);
244   SigRl srl = {{{0}}, {{0}}, {{0}}, {{{{0}, {0}}, {{0}, {0}}}}};
245   srl.gid = this->kGroupPublicKey.gid;
246   EXPECT_EQ(
247       kEpidBadArgErr,
248       EpidMemberSetSigRl(member_ctx, &srl, (sizeof(srl) - sizeof(srl.bk)) - 1));
249   srl.n2 = this->kOctStr32_1;
250   EXPECT_EQ(
251       kEpidBadArgErr,
252       EpidMemberSetSigRl(member_ctx, &srl, (sizeof(srl) - sizeof(srl.bk)) - 1));
253 }
TEST_F(EpidMemberTest,SetSigRlFailsGivenN2TooBigForSize)254 TEST_F(EpidMemberTest, SetSigRlFailsGivenN2TooBigForSize) {
255   Prng my_prng;
256   MemberCtxObj member_ctx(this->kGroupPublicKey, this->kMemberPrivateKey,
257                           &Prng::Generate, &my_prng);
258   SigRl srl = {{{0}}, {{0}}, {{0}}, {{{{0}, {0}}, {{0}, {0}}}}};
259   srl.gid = this->kGroupPublicKey.gid;
260   srl.n2 = this->kOctStr32_1;
261   EXPECT_EQ(kEpidBadArgErr,
262             EpidMemberSetSigRl(member_ctx, &srl, sizeof(srl) - sizeof(srl.bk)));
263 }
TEST_F(EpidMemberTest,SetSigRlFailsGivenN2TooSmallForSize)264 TEST_F(EpidMemberTest, SetSigRlFailsGivenN2TooSmallForSize) {
265   Prng my_prng;
266   MemberCtxObj member_ctx(this->kGroupPublicKey, this->kMemberPrivateKey,
267                           &Prng::Generate, &my_prng);
268   SigRl srl = {{{0}}, {{0}}, {{0}}, {{{{0}, {0}}, {{0}, {0}}}}};
269   srl.gid = this->kGroupPublicKey.gid;
270   EXPECT_EQ(kEpidBadArgErr, EpidMemberSetSigRl(member_ctx, &srl, sizeof(srl)));
271 }
TEST_F(EpidMemberTest,SetSigRlFailsGivenBadGroupId)272 TEST_F(EpidMemberTest, SetSigRlFailsGivenBadGroupId) {
273   Prng my_prng;
274   MemberCtxObj member_ctx(this->kGroupPublicKey, this->kMemberPrivateKey,
275                           &Prng::Generate, &my_prng);
276   SigRl srl = {{{0}}, {{0}}, {{0}}, {{{{0}, {0}}, {{0}, {0}}}}};
277   srl.gid = this->kGroupPublicKey.gid;
278   srl.gid.data[0] = ~srl.gid.data[0];
279   EXPECT_EQ(kEpidBadArgErr,
280             EpidMemberSetSigRl(member_ctx, &srl, sizeof(srl) - sizeof(srl.bk)));
281 }
TEST_F(EpidMemberTest,SetSigRlFailsGivenEmptySigRlFromDifferentGroup)282 TEST_F(EpidMemberTest, SetSigRlFailsGivenEmptySigRlFromDifferentGroup) {
283   Prng my_prng;
284   MemberCtxObj member_ctx(this->kGroupPublicKey, this->kMemberPrivateKey,
285                           &Prng::Generate, &my_prng);
286   SigRl const* sig_rl = reinterpret_cast<SigRl const*>(this->kGrpXSigRl.data());
287   size_t sig_rl_size = this->kGrpXSigRl.size();
288   EXPECT_EQ(kEpidBadArgErr,
289             EpidMemberSetSigRl(member_ctx, sig_rl, sig_rl_size));
290 }
TEST_F(EpidMemberTest,SetSigRlFailsGivenOldVersion)291 TEST_F(EpidMemberTest, SetSigRlFailsGivenOldVersion) {
292   Prng my_prng;
293   MemberCtxObj member_ctx(this->kGroupPublicKey, this->kMemberPrivateKey,
294                           &Prng::Generate, &my_prng);
295   SigRl srl = {{{0}}, {{0}}, {{0}}, {{{{0}, {0}}, {{0}, {0}}}}};
296   srl.gid = this->kGroupPublicKey.gid;
297   srl.version = this->kOctStr32_1;
298   EXPECT_EQ(kEpidNoErr,
299             EpidMemberSetSigRl(member_ctx, &srl, sizeof(srl) - sizeof(srl.bk)));
300   OctStr32 octstr32_0 = {0x00, 0x00, 0x00, 0x00};
301   srl.version = octstr32_0;
302   EXPECT_EQ(kEpidBadArgErr,
303             EpidMemberSetSigRl(member_ctx, &srl, sizeof(srl) - sizeof(srl.bk)));
304 }
TEST_F(EpidMemberTest,SetSigRlPreservesOldRlOnFailure)305 TEST_F(EpidMemberTest, SetSigRlPreservesOldRlOnFailure) {
306   Prng my_prng;
307   MemberCtxObj member_ctx(this->kGrpXKey, this->kGrpXSigrevokedMember0PrivKey,
308                           &Prng::Generate, &my_prng);
309   SigRl const* sig_rl = reinterpret_cast<SigRl const*>(this->kGrpXSigRl.data());
310   size_t sig_rl_size = this->kGrpXSigRl.size();
311   EXPECT_EQ(kEpidNoErr, EpidMemberSetSigRl(member_ctx, sig_rl, sig_rl_size));
312   // wrong sigrl contains revoked member0 and has lower version
313   SigRl const* wrong_sig_rl =
314       reinterpret_cast<SigRl const*>(this->kGrpXSigRlSingleEntry.data());
315   size_t wrong_sig_rl_size = this->kGrpXSigRlSingleEntry.size();
316   EXPECT_EQ(kEpidBadArgErr,
317             EpidMemberSetSigRl(member_ctx, wrong_sig_rl, wrong_sig_rl_size));
318   auto& msg = this->kMsg0;
319   std::vector<uint8_t> sig_data(EpidGetSigSize(sig_rl));
320   EpidSignature* sig = reinterpret_cast<EpidSignature*>(sig_data.data());
321   size_t sig_len = sig_data.size() * sizeof(uint8_t);
322   // Check that sigrevoked member is still in SigRl
323   EXPECT_EQ(kEpidSigRevokedInSigRl, EpidSign(member_ctx, msg.data(), msg.size(),
324                                              nullptr, 0, sig, sig_len));
325 }
TEST_F(EpidMemberTest,SetSigRlFailsIfNotProvisioned)326 TEST_F(EpidMemberTest, SetSigRlFailsIfNotProvisioned) {
327   Prng my_prng;
328   MemberCtxObj member_ctx(&Prng::Generate, &my_prng);
329   SigRl srl = {{{0}}, {{0}}, {{0}}, {{{{0}, {0}}, {{0}, {0}}}}};
330   SigRl const* sig_rl = &srl;
331   size_t sig_rl_size = sizeof(srl) - sizeof(srl.bk);
332   EXPECT_EQ(kEpidOutOfSequenceError,
333             EpidMemberSetSigRl(member_ctx, sig_rl, sig_rl_size));
334 }
TEST_F(EpidMemberTest,SetSigRlWorksGivenValidSigRl)335 TEST_F(EpidMemberTest, SetSigRlWorksGivenValidSigRl) {
336   Prng my_prng;
337   MemberCtxObj member_ctx(this->kGrpXKey, this->kGrpXMember0PrivKey,
338                           &Prng::Generate, &my_prng);
339   SigRl const* sig_rl = reinterpret_cast<SigRl const*>(this->kGrpXSigRl.data());
340   size_t sig_rl_size = this->kGrpXSigRl.size();
341   EXPECT_EQ(kEpidNoErr, EpidMemberSetSigRl(member_ctx, sig_rl, sig_rl_size));
342 }
TEST_F(EpidMemberTest,SetSigRlWorksGivenEmptySigRl)343 TEST_F(EpidMemberTest, SetSigRlWorksGivenEmptySigRl) {
344   Prng my_prng;
345   MemberCtxObj member_ctx(this->kGroupPublicKey, this->kMemberPrivateKey,
346                           &Prng::Generate, &my_prng);
347   uint8_t sig_rl_data_n2_zero[] = {
348       // gid
349       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
350       0x00, 0x00, 0x00, 0x01,
351       // version
352       0x00, 0x00, 0x00, 0x00,
353       // n2
354       0x0, 0x00, 0x00, 0x00,
355       // not bk's
356   };
357   SigRl* sig_rl = reinterpret_cast<SigRl*>(sig_rl_data_n2_zero);
358   size_t sig_rl_size = sizeof(sig_rl_data_n2_zero);
359   EXPECT_EQ(kEpidNoErr, EpidMemberSetSigRl(member_ctx, sig_rl, sig_rl_size));
360 }
TEST_F(EpidMemberTest,SetSigRlWorksGivenSigRlWithOneEntry)361 TEST_F(EpidMemberTest, SetSigRlWorksGivenSigRlWithOneEntry) {
362   Prng my_prng;
363   MemberCtxObj member_ctx(this->kGrpXKey, this->kGrpXMember0PrivKey,
364                           &Prng::Generate, &my_prng);
365   SigRl const* sig_rl =
366       reinterpret_cast<SigRl const*>(this->kGrpXSigRlSingleEntry.data());
367   size_t sig_rl_size = this->kGrpXSigRlSingleEntry.size();
368   EXPECT_EQ(kEpidNoErr, EpidMemberSetSigRl(member_ctx, sig_rl, sig_rl_size));
369 }
370 //////////////////////////////////////////////////////////////////////////
371 // EpidRegisterBasename
TEST_F(EpidMemberTest,RegisterBaseNameFailsGivenNullPtr)372 TEST_F(EpidMemberTest, RegisterBaseNameFailsGivenNullPtr) {
373   Prng my_prng;
374   MemberCtxObj member(this->kGroupPublicKey, this->kMemberPrivateKey,
375                       this->kMemberPrecomp, &Prng::Generate, &my_prng);
376   std::vector<uint8_t> basename = {'_', 'b', 'a', 's', 'e', 'n', 'a', 'm', 'e'};
377   EXPECT_EQ(kEpidBadArgErr,
378             EpidRegisterBasename(member, nullptr, basename.size()));
379   EXPECT_EQ(kEpidBadArgErr,
380             EpidRegisterBasename(nullptr, basename.data(), basename.size()));
381 }
TEST_F(EpidMemberTest,RegisterBaseNameFailsGivenDuplicateBaseName)382 TEST_F(EpidMemberTest, RegisterBaseNameFailsGivenDuplicateBaseName) {
383   Prng my_prng;
384   MemberCtxObj member(this->kGroupPublicKey, this->kMemberPrivateKey,
385                       this->kMemberPrecomp, &Prng::Generate, &my_prng);
386   std::vector<uint8_t> basename = {'d', 'b', 'a', 's', 'e', 'n', 'a', 'm', 'e'};
387   EXPECT_EQ(kEpidNoErr,
388             EpidRegisterBasename(member, basename.data(), basename.size()));
389   EXPECT_EQ(kEpidDuplicateErr,
390             EpidRegisterBasename(member, basename.data(), basename.size()));
391 }
TEST_F(EpidMemberTest,RegisterBaseNameFailsGivenInvalidBaseName)392 TEST_F(EpidMemberTest, RegisterBaseNameFailsGivenInvalidBaseName) {
393   Prng my_prng;
394   MemberCtxObj member(this->kGroupPublicKey, this->kMemberPrivateKey,
395                       this->kMemberPrecomp, &Prng::Generate, &my_prng);
396   std::vector<uint8_t> basename = {};
397   std::vector<uint8_t> basename2 = {'b', 's', 'n'};
398   EXPECT_EQ(kEpidBadArgErr,
399             EpidRegisterBasename(member, basename.data(), basename.size()));
400   EXPECT_EQ(kEpidBadArgErr, EpidRegisterBasename(member, basename2.data(), 0));
401 }
TEST_F(EpidMemberTest,RegisterBaseNameSucceedsGivenUniqueBaseName)402 TEST_F(EpidMemberTest, RegisterBaseNameSucceedsGivenUniqueBaseName) {
403   Prng my_prng;
404   MemberCtxObj member(this->kGroupPublicKey, this->kMemberPrivateKey,
405                       this->kMemberPrecomp, &Prng::Generate, &my_prng);
406   std::vector<uint8_t> basename = {'b', 's', 'n', '0', '1'};
407   EXPECT_EQ(kEpidNoErr,
408             EpidRegisterBasename(member, basename.data(), basename.size()));
409 }
TEST_F(EpidMemberTest,RegisterBaseNameSucceedsGivenMultipleUniqueBaseNames)410 TEST_F(EpidMemberTest, RegisterBaseNameSucceedsGivenMultipleUniqueBaseNames) {
411   Prng my_prng;
412   MemberCtxObj member(this->kGroupPublicKey, this->kMemberPrivateKey,
413                       this->kMemberPrecomp, &Prng::Generate, &my_prng);
414   std::vector<uint8_t> basename1 = {'b', 's', 'n', '0', '1'};
415   std::vector<uint8_t> basename2 = {'b', 's', 'n', '0', '2'};
416   std::vector<uint8_t> basename3 = {'b', 's', 'n', '0', '3'};
417   EXPECT_EQ(kEpidNoErr,
418             EpidRegisterBasename(member, basename1.data(), basename1.size()));
419   EXPECT_EQ(kEpidNoErr,
420             EpidRegisterBasename(member, basename2.data(), basename2.size()));
421   EXPECT_EQ(kEpidNoErr,
422             EpidRegisterBasename(member, basename3.data(), basename3.size()));
423   // Verify that basenames registered succesfully
424   EXPECT_EQ(kEpidDuplicateErr,
425             EpidRegisterBasename(member, basename1.data(), basename1.size()));
426   EXPECT_EQ(kEpidDuplicateErr,
427             EpidRegisterBasename(member, basename2.data(), basename2.size()));
428   EXPECT_EQ(kEpidDuplicateErr,
429             EpidRegisterBasename(member, basename3.data(), basename3.size()));
430 }
TEST_F(EpidMemberTest,RegisterBaseNameSucceedsGivenBsnContainingAllPossibleBytes)431 TEST_F(EpidMemberTest,
432        RegisterBaseNameSucceedsGivenBsnContainingAllPossibleBytes) {
433   Prng my_prng;
434   MemberCtxObj member(this->kGroupPublicKey, this->kMemberPrivateKey,
435                       this->kMemberPrecomp, &Prng::Generate, &my_prng);
436   EXPECT_EQ(kEpidNoErr, EpidRegisterBasename(member, this->kData_0_255.data(),
437                                              this->kData_0_255.size()));
438 }
439 //////////////////////////////////////////////////////////////////////////
440 // EpidClearRegisteredBasenames
TEST_F(EpidMemberTest,EpidClearRegisteredBasenamesFailsGivenNullPtr)441 TEST_F(EpidMemberTest, EpidClearRegisteredBasenamesFailsGivenNullPtr) {
442   EXPECT_EQ(kEpidBadArgErr, EpidClearRegisteredBasenames(nullptr));
443 }
TEST_F(EpidMemberTest,EpidClearRegisteredBasenamesClearsBasenames)444 TEST_F(EpidMemberTest, EpidClearRegisteredBasenamesClearsBasenames) {
445   Prng my_prng;
446   MemberCtxObj member(this->kGroupPublicKey, this->kMemberPrivateKey,
447                       this->kMemberPrecomp, &Prng::Generate, &my_prng);
448   THROW_ON_EPIDERR(EpidRegisterBasename(member, this->kData_0_255.data(),
449                                         this->kData_0_255.size()));
450   EXPECT_EQ(kEpidNoErr, EpidClearRegisteredBasenames(member));
451   // check, that after clearing EpidRegisterBasename works correctly
452   THROW_ON_EPIDERR(EpidRegisterBasename(member, this->kData_0_255.data(),
453                                         this->kData_0_255.size()));
454 }
TEST_F(EpidMemberTest,EpidClearRegisteredBasenamesClearsAllBasenames)455 TEST_F(EpidMemberTest, EpidClearRegisteredBasenamesClearsAllBasenames) {
456   Prng my_prng;
457   MemberCtxObj member(this->kGroupPublicKey, this->kMemberPrivateKey,
458                       this->kMemberPrecomp, &Prng::Generate, &my_prng);
459   for (int i = 0; i < 3; ++i) {
460     THROW_ON_EPIDERR(EpidRegisterBasename(member, &i, sizeof(i)));
461   }
462   EXPECT_EQ(kEpidNoErr, EpidClearRegisteredBasenames(member));
463   for (int i = 0; i < 3; ++i) {
464     THROW_ON_EPIDERR(EpidRegisterBasename(member, &i, sizeof(i)));
465   }
466 }
TEST_F(EpidMemberTest,EpidClearRegisteredBasenamesCausesSignWithBasenameAfterItToFail)467 TEST_F(EpidMemberTest,
468        EpidClearRegisteredBasenamesCausesSignWithBasenameAfterItToFail) {
469   Prng my_prng;
470   MemberCtxObj member(this->kGroupPublicKey, this->kMemberPrivateKey,
471                       this->kMemberPrecomp, &Prng::Generate, &my_prng);
472   auto& msg = this->kMsg0;
473   auto& bsn = this->kBsn0;
474   THROW_ON_EPIDERR(EpidRegisterBasename(member, bsn.data(), bsn.size()));
475   std::vector<uint8_t> sig_data(EpidGetSigSize(nullptr));
476   EpidSignature* sig = reinterpret_cast<EpidSignature*>(sig_data.data());
477   size_t sig_len = sig_data.size() * sizeof(uint8_t);
478   THROW_ON_EPIDERR(EpidSign(member, msg.data(), msg.size(), bsn.data(),
479                             bsn.size(), sig, sig_len));
480   THROW_ON_EPIDERR(EpidClearRegisteredBasenames(member));
481   ASSERT_EQ(kEpidBadArgErr, EpidSign(member, msg.data(), msg.size(), bsn.data(),
482                                      bsn.size(), sig, sig_len));
483 }
484 }  // namespace
485