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 Epid11VerifierCreate unit tests.
20 */
21
22 #include <cstring>
23
24 #include "epid/common-testhelper/epid_gtest-testhelper.h"
25 #include "gtest/gtest.h"
26
27 extern "C" {
28 #include "epid/verifier/1.1/api.h"
29 #include "epid/verifier/1.1/src/context.h"
30 }
31
32 #include "epid/common-testhelper/1.1/verifier_wrapper-testhelper.h"
33 #include "epid/common-testhelper/errors-testhelper.h"
34 #include "epid/verifier/1.1/unittests/verifier-testhelper.h"
operator ==(Epid11VerifierPrecomp const & lhs,Epid11VerifierPrecomp const & rhs)35 bool operator==(Epid11VerifierPrecomp const& lhs,
36 Epid11VerifierPrecomp const& rhs) {
37 return 0 == std::memcmp(&lhs, &rhs, sizeof(lhs));
38 }
39 namespace {
40 //////////////////////////////////////////////////////////////////////////
41 // Epid11VerifierCreate Tests
TEST_F(Epid11VerifierTest,CreateFailsGivenNullPointer)42 TEST_F(Epid11VerifierTest, CreateFailsGivenNullPointer) {
43 Epid11VerifierCtx* ctx = nullptr;
44 EXPECT_EQ(kEpidBadArgErr,
45 Epid11VerifierCreate(&this->kPubKeyStr, &this->kVerifierPrecompStr,
46 nullptr));
47 Epid11VerifierDelete(&ctx);
48 EXPECT_EQ(kEpidBadArgErr,
49 Epid11VerifierCreate(nullptr, &this->kVerifierPrecompStr, &ctx));
50 Epid11VerifierDelete(&ctx);
51 }
TEST_F(Epid11VerifierTest,CreateSucceedsGivenNullPrecomp)52 TEST_F(Epid11VerifierTest, CreateSucceedsGivenNullPrecomp) {
53 Epid11VerifierCtx* ctx = nullptr;
54 EXPECT_EQ(kEpidNoErr, Epid11VerifierCreate(&this->kPubKeyStr, nullptr, &ctx));
55 Epid11VerifierDelete(&ctx);
56 }
TEST_F(Epid11VerifierTest,CreateSucceedsGivenValidPrecomp)57 TEST_F(Epid11VerifierTest, CreateSucceedsGivenValidPrecomp) {
58 Epid11VerifierCtx* ctx = nullptr;
59 EXPECT_EQ(kEpidNoErr, Epid11VerifierCreate(&this->kPubKeyStr,
60 &this->kVerifierPrecompStr, &ctx));
61 Epid11VerifierDelete(&ctx);
62 }
TEST_F(Epid11VerifierTest,CreateFailsGivenInvalidPubkey)63 TEST_F(Epid11VerifierTest, CreateFailsGivenInvalidPubkey) {
64 Epid11VerifierCtx* ctx = nullptr;
65 Epid11GroupPubKey pubkey_with_bad_h1 = this->kPubKeyStr;
66 pubkey_with_bad_h1.h1.x.data.data[31]++; // munge h1 so not in G1
67 EXPECT_EQ(kEpidBadArgErr,
68 Epid11VerifierCreate(&pubkey_with_bad_h1, nullptr, &ctx));
69 Epid11VerifierDelete(&ctx);
70 Epid11GroupPubKey pubkey_with_bad_h2 = this->kPubKeyStr;
71 pubkey_with_bad_h2.h2.x.data.data[31]++; // munge h2 so not in G1
72 EXPECT_EQ(kEpidBadArgErr,
73 Epid11VerifierCreate(&pubkey_with_bad_h2, nullptr, &ctx));
74 Epid11VerifierDelete(&ctx);
75 Epid11GroupPubKey pubkey_with_bad_w = this->kPubKeyStr;
76 pubkey_with_bad_w.w.x[0].data.data[31]++; // munge w so not in G2
77 EXPECT_EQ(kEpidBadArgErr,
78 Epid11VerifierCreate(&pubkey_with_bad_w, nullptr, &ctx));
79 Epid11VerifierDelete(&ctx);
80 }
TEST_F(Epid11VerifierTest,CreateFailsGivenBadGroupIdInPrecomp)81 TEST_F(Epid11VerifierTest, CreateFailsGivenBadGroupIdInPrecomp) {
82 Epid11VerifierCtx* ctx = nullptr;
83 // tweak GID
84 auto verifier_precomp = this->kVerifierPrecompStr;
85 verifier_precomp.gid.data[0] = ~verifier_precomp.gid.data[0];
86 EXPECT_EQ(kEpidBadArgErr,
87 Epid11VerifierCreate(&this->kPubKeyStr, &verifier_precomp, &ctx));
88 }
89 //////////////////////////////////////////////////////////////////////////
90 // Epid11VerifierDelete Tests
TEST_F(Epid11VerifierTest,DeleteNullsVerifierCtx)91 TEST_F(Epid11VerifierTest, DeleteNullsVerifierCtx) {
92 Epid11VerifierCtx* ctx = nullptr;
93 THROW_ON_EPIDERR(Epid11VerifierCreate(&this->kPubKeyStr, nullptr, &ctx));
94 Epid11VerifierDelete(&ctx);
95 EXPECT_EQ(nullptr, ctx);
96 }
TEST_F(Epid11VerifierTest,DeleteWorksGivenNullVerifierCtx)97 TEST_F(Epid11VerifierTest, DeleteWorksGivenNullVerifierCtx) {
98 Epid11VerifierDelete(nullptr);
99 Epid11VerifierCtx* ctx = nullptr;
100 Epid11VerifierDelete(&ctx);
101 }
102
103 //////////////////////////////////////////////////////////////////////////
104 // Epid11VerifierWritePrecomp
TEST_F(Epid11VerifierTest,WritePrecompFailsGivenNullPointer)105 TEST_F(Epid11VerifierTest, WritePrecompFailsGivenNullPointer) {
106 Epid11VerifierPrecomp precomp;
107 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
108 Epid11VerifierCtx* ctx = verifier;
109 EXPECT_EQ(kEpidBadArgErr, Epid11VerifierWritePrecomp(nullptr, &precomp));
110 EXPECT_EQ(kEpidBadArgErr, Epid11VerifierWritePrecomp(ctx, nullptr));
111 }
TEST_F(Epid11VerifierTest,WritePrecompSucceedGivenValidArgument)112 TEST_F(Epid11VerifierTest, WritePrecompSucceedGivenValidArgument) {
113 Epid11VerifierPrecomp precomp;
114 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
115 Epid11VerifierCtx* ctx = verifier;
116 EXPECT_EQ(kEpidNoErr, Epid11VerifierWritePrecomp(ctx, &precomp));
117 Epid11VerifierPrecomp expected_precomp = this->kVerifierPrecompStr;
118 EXPECT_EQ(expected_precomp, precomp);
119
120 Epid11VerifierCtxObj verifier2(this->kPubKeyStr);
121 Epid11VerifierCtx* ctx2 = verifier2;
122 EXPECT_EQ(kEpidNoErr, Epid11VerifierWritePrecomp(ctx2, &precomp));
123 EXPECT_EQ(expected_precomp, precomp);
124 }
125
126 //////////////////////////////////////////////////////////////////////////
127 // Epid11VerifierSetPrivRl
TEST_F(Epid11VerifierTest,SetPrivRlFailsGivenNullPointer)128 TEST_F(Epid11VerifierTest, SetPrivRlFailsGivenNullPointer) {
129 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
130 Epid11PrivRl prl = {0};
131 prl.gid = this->kPubKeyStr.gid;
132 EXPECT_EQ(kEpidBadArgErr,
133 Epid11VerifierSetPrivRl(nullptr, &prl, sizeof(prl)));
134 EXPECT_EQ(kEpidBadArgErr,
135 Epid11VerifierSetPrivRl(verifier, nullptr, sizeof(prl)));
136 }
137
TEST_F(Epid11VerifierTest,SetPrivRlFailsGivenZeroSize)138 TEST_F(Epid11VerifierTest, SetPrivRlFailsGivenZeroSize) {
139 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
140 Epid11PrivRl prl = {0};
141 prl.gid = this->kPubKeyStr.gid;
142 EXPECT_EQ(kEpidBadArgErr, Epid11VerifierSetPrivRl(verifier, &prl, 0));
143 }
144
145 // Size parameter must be at least big enough for n1 == 0 case
TEST_F(Epid11VerifierTest,SetPrivRlFailsGivenTooSmallSize)146 TEST_F(Epid11VerifierTest, SetPrivRlFailsGivenTooSmallSize) {
147 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
148 Epid11PrivRl prl = {0};
149 prl.gid = this->kPubKeyStr.gid;
150 EXPECT_EQ(kEpidBadArgErr,
151 Epid11VerifierSetPrivRl(verifier, &prl,
152 (sizeof(prl) - sizeof(prl.f)) - 1));
153 prl.n1 = this->kOctStr32_1;
154 EXPECT_EQ(kEpidBadArgErr,
155 Epid11VerifierSetPrivRl(verifier, &prl,
156 (sizeof(prl) - sizeof(prl.f)) - 1));
157 }
158
159 // Size parameter must be cross-checked with n1 value in priv_rl
TEST_F(Epid11VerifierTest,SetPrivRlFailsGivenN1TooBigForSize)160 TEST_F(Epid11VerifierTest, SetPrivRlFailsGivenN1TooBigForSize) {
161 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
162 Epid11PrivRl prl = {0};
163 prl.gid = this->kPubKeyStr.gid;
164 prl.n1 = this->kOctStr32_1;
165 EXPECT_EQ(kEpidBadArgErr, Epid11VerifierSetPrivRl(
166 verifier, &prl, sizeof(prl) - sizeof(prl.f)));
167 }
168
TEST_F(Epid11VerifierTest,SetPrivRlFailsGivenN1TooSmallForSize)169 TEST_F(Epid11VerifierTest, SetPrivRlFailsGivenN1TooSmallForSize) {
170 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
171 Epid11PrivRl prl = {0};
172 prl.gid = this->kPubKeyStr.gid;
173 EXPECT_EQ(kEpidBadArgErr,
174 Epid11VerifierSetPrivRl(verifier, &prl, sizeof(prl)));
175 }
176
TEST_F(Epid11VerifierTest,SetPrivRlPassesGivenDefaultPrivRl)177 TEST_F(Epid11VerifierTest, SetPrivRlPassesGivenDefaultPrivRl) {
178 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
179 Epid11PrivRl prl = {0};
180 prl.gid = this->kPubKeyStr.gid;
181 EXPECT_EQ(kEpidNoErr, Epid11VerifierSetPrivRl(verifier, &prl,
182 sizeof(prl) - sizeof(prl.f)));
183 }
184
TEST_F(Epid11VerifierTest,SetPrivRlPassesGivenPrivRlWithSingleElement)185 TEST_F(Epid11VerifierTest, SetPrivRlPassesGivenPrivRlWithSingleElement) {
186 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
187 Epid11PrivRl prl = {0};
188 prl.gid = this->kPubKeyStr.gid;
189 prl.n1 = this->kOctStr32_1;
190 EXPECT_EQ(kEpidNoErr, Epid11VerifierSetPrivRl(verifier, &prl, sizeof(prl)));
191 }
192
TEST_F(Epid11VerifierTest,SetPrivRlFailsGivenBadGroupId)193 TEST_F(Epid11VerifierTest, SetPrivRlFailsGivenBadGroupId) {
194 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
195 Epid11PrivRl prl = {0};
196 prl.gid = this->kPubKeyStr.gid;
197 prl.gid.data[0] = ~prl.gid.data[0];
198 prl.n1 = this->kOctStr32_1;
199 EXPECT_EQ(kEpidBadArgErr,
200 Epid11VerifierSetPrivRl(verifier, &prl, sizeof(prl)));
201 }
202
TEST_F(Epid11VerifierTest,SetPrivRlFailsGivenOldVersion)203 TEST_F(Epid11VerifierTest, SetPrivRlFailsGivenOldVersion) {
204 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
205 Epid11PrivRl prl = {0};
206 prl.gid = this->kPubKeyStr.gid;
207 prl.version = this->kOctStr32_1;
208 EXPECT_EQ(kEpidNoErr, Epid11VerifierSetPrivRl(verifier, &prl,
209 sizeof(prl) - sizeof(prl.f)));
210 OctStr32 octstr32_0 = {0x00, 0x00, 0x00, 0x00};
211 prl.version = octstr32_0;
212 EXPECT_EQ(kEpidBadArgErr, Epid11VerifierSetPrivRl(
213 verifier, &prl, sizeof(prl) - sizeof(prl.f)));
214 }
215
216 //////////////////////////////////////////////////////////////////////////
217 // Epid11VerifierSetSigRl
TEST_F(Epid11VerifierTest,SetSigRlFailsGivenNullPointer)218 TEST_F(Epid11VerifierTest, SetSigRlFailsGivenNullPointer) {
219 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
220 Epid11SigRl* empty_sig_rl = (Epid11SigRl*)this->kEmptySigRl.data();
221 EXPECT_EQ(kEpidBadArgErr,
222 Epid11VerifierSetSigRl(nullptr, empty_sig_rl, sizeof(Epid11SigRl)));
223 EXPECT_EQ(kEpidBadArgErr,
224 Epid11VerifierSetSigRl(verifier, nullptr, sizeof(Epid11SigRl)));
225 }
226
TEST_F(Epid11VerifierTest,SetSigRlFailsGivenZeroSize)227 TEST_F(Epid11VerifierTest, SetSigRlFailsGivenZeroSize) {
228 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
229 Epid11SigRl* empty_sig_rl = (Epid11SigRl*)this->kEmptySigRl.data();
230 EXPECT_EQ(kEpidBadArgErr, Epid11VerifierSetSigRl(verifier, empty_sig_rl, 0));
231 }
232
233 // Size parameter must be at least big enough for n2 == 0 case
TEST_F(Epid11VerifierTest,SetSigRlFailsGivenTooSmallSize)234 TEST_F(Epid11VerifierTest, SetSigRlFailsGivenTooSmallSize) {
235 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
236 std::vector<uint8_t> empty_sig_rl_buf(this->kEmptySigRl);
237 Epid11SigRl* empty_sig_rl = (Epid11SigRl*)empty_sig_rl_buf.data();
238 EXPECT_EQ(kEpidBadArgErr,
239 Epid11VerifierSetSigRl(
240 verifier, empty_sig_rl,
241 (sizeof(*empty_sig_rl) - sizeof(empty_sig_rl->bk)) - 1));
242 empty_sig_rl->n2 = this->kOctStr32_1;
243 EXPECT_EQ(kEpidBadArgErr,
244 Epid11VerifierSetSigRl(
245 verifier, empty_sig_rl,
246 (sizeof(*empty_sig_rl) - sizeof(empty_sig_rl->bk)) - 1));
247 }
248
TEST_F(Epid11VerifierTest,SetSigRlFailsGivenN2TooBigForSize)249 TEST_F(Epid11VerifierTest, SetSigRlFailsGivenN2TooBigForSize) {
250 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
251 std::vector<uint8_t> empty_sig_rl_buf(this->kEmptySigRl);
252 Epid11SigRl* empty_sig_rl = (Epid11SigRl*)empty_sig_rl_buf.data();
253 empty_sig_rl->n2 = this->kOctStr32_1;
254 EXPECT_EQ(
255 kEpidBadArgErr,
256 Epid11VerifierSetSigRl(verifier, empty_sig_rl,
257 sizeof(*empty_sig_rl) - sizeof(empty_sig_rl->bk)));
258 }
259
TEST_F(Epid11VerifierTest,SetSigRlFailsGivenN2TooSmallForSize)260 TEST_F(Epid11VerifierTest, SetSigRlFailsGivenN2TooSmallForSize) {
261 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
262 std::vector<uint8_t> empty_sig_rl_buf(this->kEmptySigRl);
263 Epid11SigRl* empty_sig_rl = (Epid11SigRl*)empty_sig_rl_buf.data();
264 EXPECT_EQ(kEpidBadArgErr, Epid11VerifierSetSigRl(verifier, empty_sig_rl,
265 sizeof(*empty_sig_rl)));
266 }
267
TEST_F(Epid11VerifierTest,SetSigRlWorksGivenSigRlWithNoElements)268 TEST_F(Epid11VerifierTest, SetSigRlWorksGivenSigRlWithNoElements) {
269 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
270 std::vector<uint8_t> empty_sig_rl_buf(this->kEmptySigRl);
271 Epid11SigRl* empty_sig_rl = (Epid11SigRl*)empty_sig_rl_buf.data();
272 size_t sig_rl_size = empty_sig_rl_buf.size() * sizeof(uint8_t);
273 EXPECT_EQ(kEpidNoErr,
274 Epid11VerifierSetSigRl(verifier, empty_sig_rl, sig_rl_size));
275 }
276
TEST_F(Epid11VerifierTest,SetSigRlWorksGivenSigRlWithOneElement)277 TEST_F(Epid11VerifierTest, SetSigRlWorksGivenSigRlWithOneElement) {
278 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
279
280 uint8_t sig_rl_data_n2_one[] = {
281 // gid
282 0x00, 0x00, 0x00, 0x7b,
283 // rev
284 0x00, 0x00, 0x00, 0x7b,
285 // n2
286 0x00, 0x00, 0x00, 0x01,
287 // bks
288 // bk1
289 0x67, 0x58, 0xb2, 0x9c, 0xad, 0x61, 0x1f, 0xfb, 0x74, 0x23, 0xea, 0x40,
290 0xe9, 0x66, 0x26, 0xb0, 0x43, 0xdc, 0x7e, 0xc7, 0x48, 0x88, 0x56, 0x59,
291 0xf3, 0x35, 0x9f, 0xdb, 0xfa, 0xa2, 0x49, 0x51, 0x85, 0x35, 0x42, 0x50,
292 0x8e, 0x79, 0x79, 0xc0, 0x6c, 0xcc, 0x39, 0x0b, 0xad, 0x3b, 0x39, 0x33,
293 0xae, 0xb2, 0xa1, 0xc5, 0x28, 0x6f, 0x48, 0x3a, 0xd2, 0x63, 0x5d, 0xfb,
294 0x1b, 0x1f, 0x8a, 0x63, 0x84, 0xdc, 0x2d, 0xad, 0x3b, 0x98, 0x3f, 0xc3,
295 0x8e, 0x18, 0xd7, 0xea, 0x18, 0x50, 0x0c, 0x50, 0x42, 0x77, 0xb2, 0x59,
296 0xf5, 0xd5, 0x38, 0xc3, 0x8d, 0x57, 0xf4, 0xe7, 0xb8, 0x74, 0x5a, 0x9e,
297 0x32, 0x75, 0xd1, 0xb4, 0xb3, 0x64, 0xbc, 0x23, 0xcd, 0x98, 0x29, 0x7a,
298 0x77, 0x51, 0xfc, 0x26, 0x81, 0x41, 0x9b, 0xf6, 0x21, 0xad, 0xc1, 0xd9,
299 0xab, 0x30, 0x25, 0x8d, 0x0c, 0x3b, 0x62, 0xe2};
300 Epid11SigRl* sig_rl = reinterpret_cast<Epid11SigRl*>(sig_rl_data_n2_one);
301 EXPECT_EQ(kEpidNoErr,
302 Epid11VerifierSetSigRl(verifier, sig_rl, sizeof(*sig_rl)));
303 }
304
TEST_F(Epid11VerifierTest,SetSigRlWorksGivenSigRlWithTwoElement)305 TEST_F(Epid11VerifierTest, SetSigRlWorksGivenSigRlWithTwoElement) {
306 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
307 Epid11VerifierCtx* ctx = verifier;
308 Epid11SigRl const* sig_rl =
309 reinterpret_cast<Epid11SigRl const*>(this->kSigRl.data());
310 size_t sig_rl_size = this->kSigRl.size() * sizeof(uint8_t);
311 EXPECT_EQ(kEpidNoErr, Epid11VerifierSetSigRl(ctx, sig_rl, sig_rl_size));
312 }
313
TEST_F(Epid11VerifierTest,SetSigRlFailsGivenBadGroupId)314 TEST_F(Epid11VerifierTest, SetSigRlFailsGivenBadGroupId) {
315 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
316 std::vector<uint8_t> empty_sig_rl_buf(this->kEmptySigRl);
317 Epid11SigRl* empty_sig_rl = (Epid11SigRl*)empty_sig_rl_buf.data();
318 empty_sig_rl->gid.data[0] = ~empty_sig_rl->gid.data[0];
319 EXPECT_EQ(
320 kEpidBadArgErr,
321 Epid11VerifierSetSigRl(verifier, empty_sig_rl,
322 sizeof(*empty_sig_rl) - sizeof(empty_sig_rl->bk)));
323 }
324
TEST_F(Epid11VerifierTest,SetSigRlFailsGivenOldVersion)325 TEST_F(Epid11VerifierTest, SetSigRlFailsGivenOldVersion) {
326 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
327 std::vector<uint8_t> empty_sig_rl_buf(this->kEmptySigRl);
328 Epid11SigRl* empty_sig_rl = (Epid11SigRl*)empty_sig_rl_buf.data();
329 empty_sig_rl->version = this->kOctStr32_1;
330 EXPECT_EQ(kEpidNoErr, Epid11VerifierSetSigRl(
331 verifier, empty_sig_rl,
332 sizeof(*empty_sig_rl) - sizeof(empty_sig_rl->bk)));
333 OctStr32 octstr32_0 = {0x00, 0x00, 0x00, 0x00};
334 empty_sig_rl->version = octstr32_0;
335 EXPECT_EQ(
336 kEpidBadArgErr,
337 Epid11VerifierSetSigRl(verifier, empty_sig_rl,
338 sizeof(*empty_sig_rl) - sizeof(empty_sig_rl->bk)));
339 }
340
341 //////////////////////////////////////////////////////////////////////////
342 // Epid11VerifierSetGroupRl
TEST_F(Epid11VerifierTest,SetGroupRlFailsGivenNullPointer)343 TEST_F(Epid11VerifierTest, SetGroupRlFailsGivenNullPointer) {
344 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
345 std::vector<uint8_t> group_rl(this->kGroupRl3GidBuf);
346 Epid11GroupRl* grl = (Epid11GroupRl*)group_rl.data();
347 EXPECT_EQ(kEpidBadArgErr,
348 Epid11VerifierSetGroupRl(nullptr, grl, group_rl.size()));
349 EXPECT_EQ(kEpidBadArgErr,
350 Epid11VerifierSetGroupRl(verifier, nullptr, group_rl.size()));
351 }
352
TEST_F(Epid11VerifierTest,SetGroupRlFailsGivenSizeZero)353 TEST_F(Epid11VerifierTest, SetGroupRlFailsGivenSizeZero) {
354 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
355 std::vector<uint8_t> group_rl(this->kGroupRl3GidBuf);
356 Epid11GroupRl* grl = (Epid11GroupRl*)group_rl.data();
357 EXPECT_EQ(kEpidBadArgErr, Epid11VerifierSetGroupRl(verifier, grl, 0));
358 }
359
TEST_F(Epid11VerifierTest,SetGroupRlFailsGivenSizeTooSmall)360 TEST_F(Epid11VerifierTest, SetGroupRlFailsGivenSizeTooSmall) {
361 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
362 std::vector<uint8_t> group_rl(this->kGroupRl3GidBuf);
363 Epid11GroupRl* grl = (Epid11GroupRl*)group_rl.data();
364 size_t grl_size = group_rl.size() - sizeof(grl->gid[0]);
365 EXPECT_EQ(kEpidBadArgErr,
366 Epid11VerifierSetGroupRl(verifier, grl, grl_size - 1));
367 }
368
TEST_F(Epid11VerifierTest,SetGroupRlFailsGivenSizeTooLarge)369 TEST_F(Epid11VerifierTest, SetGroupRlFailsGivenSizeTooLarge) {
370 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
371 std::vector<uint8_t> group_rl(this->kGroupRl3GidBuf);
372 Epid11GroupRl* grl = (Epid11GroupRl*)group_rl.data();
373 size_t grl_size = group_rl.size() - sizeof(grl->gid[0]);
374 EXPECT_EQ(kEpidBadArgErr,
375 Epid11VerifierSetGroupRl(verifier, grl, grl_size + 1));
376 }
377
TEST_F(Epid11VerifierTest,SetGroupRlFailsGivenN3ZeroAndGroupRLSizeTooBig)378 TEST_F(Epid11VerifierTest, SetGroupRlFailsGivenN3ZeroAndGroupRLSizeTooBig) {
379 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
380 std::vector<uint8_t> group_rl_3gid_n0_buf(this->kGroupRl3GidBuf);
381 group_rl_3gid_n0_buf[7] = 0x00;
382 Epid11GroupRl* group_rl = (Epid11GroupRl*)group_rl_3gid_n0_buf.data();
383 EXPECT_EQ(kEpidBadArgErr,
384 Epid11VerifierSetGroupRl(verifier, group_rl,
385 group_rl_3gid_n0_buf.size()));
386 }
387
TEST_F(Epid11VerifierTest,SetGroupRlFailsGivenN3TooSmall)388 TEST_F(Epid11VerifierTest, SetGroupRlFailsGivenN3TooSmall) {
389 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
390 std::vector<uint8_t> group_rl_3gid_n2_buf(this->kGroupRl3GidBuf);
391 group_rl_3gid_n2_buf[7] = 0x02;
392 Epid11GroupRl* group_rl = (Epid11GroupRl*)group_rl_3gid_n2_buf.data();
393 EXPECT_EQ(kEpidBadArgErr,
394 Epid11VerifierSetGroupRl(verifier, group_rl,
395 group_rl_3gid_n2_buf.size()));
396 }
397
TEST_F(Epid11VerifierTest,SetGroupRlFailsGivenN3TooLarge)398 TEST_F(Epid11VerifierTest, SetGroupRlFailsGivenN3TooLarge) {
399 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
400 std::vector<uint8_t> group_rl_3gid_n4_buf(this->kGroupRl3GidBuf);
401 group_rl_3gid_n4_buf[7] = 0x04;
402 Epid11GroupRl* group_rl = (Epid11GroupRl*)group_rl_3gid_n4_buf.data();
403 EXPECT_EQ(kEpidBadArgErr,
404 Epid11VerifierSetGroupRl(verifier, group_rl,
405 group_rl_3gid_n4_buf.size()));
406 }
407
TEST_F(Epid11VerifierTest,SetGroupRlSucceedsGivenEmptyRL)408 TEST_F(Epid11VerifierTest, SetGroupRlSucceedsGivenEmptyRL) {
409 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
410 Epid11GroupRl* empty_grl = (Epid11GroupRl*)this->kGroupRlEmptyBuf.data();
411 size_t grl_size = this->kGroupRlEmptyBuf.size();
412 EXPECT_EQ(kEpidNoErr,
413 Epid11VerifierSetGroupRl(verifier, empty_grl, grl_size));
414 }
TEST_F(Epid11VerifierTest,SetGroupRlSucceedsGivenRLWith3gid)415 TEST_F(Epid11VerifierTest, SetGroupRlSucceedsGivenRLWith3gid) {
416 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
417 Epid11GroupRl* group_rl = (Epid11GroupRl*)this->kGroupRl3GidBuf.data();
418 EXPECT_EQ(kEpidNoErr, Epid11VerifierSetGroupRl(verifier, group_rl,
419 this->kGroupRl3GidBuf.size()));
420 }
421
TEST_F(Epid11VerifierTest,SetGroupRlFailsGivenOldVersion)422 TEST_F(Epid11VerifierTest, SetGroupRlFailsGivenOldVersion) {
423 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
424 Epid11GroupRl* group_rl = (Epid11GroupRl*)this->kGroupRl3GidBuf.data();
425 EXPECT_EQ(kEpidNoErr, Epid11VerifierSetGroupRl(verifier, group_rl,
426 this->kGroupRl3GidBuf.size()));
427 Epid11GroupRl* empty_grl = (Epid11GroupRl*)this->kGroupRlEmptyBuf.data();
428 EXPECT_EQ(kEpidBadArgErr,
429 Epid11VerifierSetGroupRl(verifier, empty_grl,
430 this->kGroupRlEmptyBuf.size()));
431 }
432
433 //////////////////////////////////////////////////////////////////////////
434 // Epid11VerifierSetBasename
TEST_F(Epid11VerifierTest,DefaultBasenameIsNull)435 TEST_F(Epid11VerifierTest, DefaultBasenameIsNull) {
436 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
437 Epid11VerifierCtx* ctx = verifier;
438 EXPECT_EQ(nullptr, ctx->basename);
439 }
TEST_F(Epid11VerifierTest,SetBasenameFailsGivenNullContext)440 TEST_F(Epid11VerifierTest, SetBasenameFailsGivenNullContext) {
441 auto& basename = this->kBsn0;
442 EXPECT_EQ(kEpidBadArgErr, Epid11VerifierSetBasename(nullptr, basename.data(),
443 basename.size()));
444 }
TEST_F(Epid11VerifierTest,SetBasenameFailsGivenNullBasenameAndNonzeroLength)445 TEST_F(Epid11VerifierTest, SetBasenameFailsGivenNullBasenameAndNonzeroLength) {
446 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
447 Epid11VerifierCtx* ctx = verifier;
448 auto& basename = this->kBsn0;
449 EXPECT_EQ(kEpidBadArgErr,
450 Epid11VerifierSetBasename(ctx, nullptr, basename.size()));
451 }
TEST_F(Epid11VerifierTest,SetBasenameSucceedsGivenValidParameters)452 TEST_F(Epid11VerifierTest, SetBasenameSucceedsGivenValidParameters) {
453 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
454 Epid11VerifierCtx* ctx = verifier;
455 auto& basename = this->kBsn0;
456 EXPECT_EQ(kEpidNoErr,
457 Epid11VerifierSetBasename(ctx, basename.data(), basename.size()));
458 EXPECT_EQ(basename.size(), ctx->basename_len);
459 EXPECT_EQ(0, memcmp(basename.data(), ctx->basename, ctx->basename_len));
460 EXPECT_NE(nullptr, ctx->basename_hash);
461 }
TEST_F(Epid11VerifierTest,SetBasenameAcceptsZeroLengthBasename)462 TEST_F(Epid11VerifierTest, SetBasenameAcceptsZeroLengthBasename) {
463 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
464 Epid11VerifierCtx* ctx = verifier;
465 EXPECT_EQ(kEpidNoErr, Epid11VerifierSetBasename(ctx, "", 0));
466 EXPECT_EQ((size_t)0, ctx->basename_len);
467 EXPECT_NE(nullptr, ctx->basename_hash);
468 }
TEST_F(Epid11VerifierTest,SetBasenameResetsBasenameGivenNullBasename)469 TEST_F(Epid11VerifierTest, SetBasenameResetsBasenameGivenNullBasename) {
470 Epid11VerifierCtxObj verifier(this->kPubKeyStr, this->kVerifierPrecompStr);
471 Epid11VerifierCtx* ctx = verifier;
472 auto& basename = this->kBsn0;
473 THROW_ON_EPIDERR(
474 Epid11VerifierSetBasename(ctx, basename.data(), basename.size()));
475 THROW_ON_EPIDERR(Epid11VerifierSetBasename(ctx, nullptr, 0));
476 EXPECT_EQ(nullptr, ctx->basename_hash);
477 }
TEST_F(Epid11VerifierTest,SetBasenameAcceptsBsnContainingAllPossibleBytes)478 TEST_F(Epid11VerifierTest, SetBasenameAcceptsBsnContainingAllPossibleBytes) {
479 Epid11VerifierCtxObj verifier(this->kPubKeyStrForMsg0_255,
480 this->kVerifierPrecompStr);
481 Epid11VerifierCtx* ctx = verifier;
482 auto& basename = this->kData_0_255;
483 EXPECT_EQ(kEpidNoErr,
484 Epid11VerifierSetBasename(ctx, basename.data(), basename.size()));
485 EXPECT_EQ(basename.size(), ctx->basename_len);
486 EXPECT_EQ(0, memcmp(basename.data(), ctx->basename, ctx->basename_len));
487 EXPECT_NE(nullptr, ctx->basename_hash);
488 }
489 } // namespace
490