1 /*
2 * Copyright 2023 Google LLC.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * https://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "act/act_v0/parameters.h"
17
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20
21 #include <memory>
22 #include <string>
23 #include <utility>
24 #include <vector>
25
26 #include "act/act.h"
27 #include "act/act.pb.h"
28 #include "act/act_v0/act_v0.h"
29 #include "private_join_and_compute/util/status.inc"
30 #include "private_join_and_compute/util/status_testing.inc"
31
32 namespace private_join_and_compute {
33 namespace anonymous_counting_tokens {
34 namespace {
35
36
EndToEndTest(SchemeParameters scheme_parameters,int num_messages)37 Status EndToEndTest(SchemeParameters scheme_parameters, int num_messages) {
38 std::unique_ptr<AnonymousCountingTokens> act =
39 AnonymousCountingTokensV0::Create();
40
41 // Generate server parameters.
42 ASSIGN_OR_RETURN(ServerParameters server_parameters,
43 act->GenerateServerParameters(scheme_parameters));
44
45
46 // Generate client parameters and check them.
47 ASSIGN_OR_RETURN(
48 ClientParameters client_parameters,
49 act->GenerateClientParameters(scheme_parameters,
50 server_parameters.public_parameters()));
51
52 RETURN_IF_ERROR(act->CheckClientParameters(
53 scheme_parameters, client_parameters.public_parameters(),
54 server_parameters.public_parameters(),
55 server_parameters.private_parameters()));
56
57 // Generate messages.
58 std::vector<std::string> messages;
59 messages.reserve(num_messages);
60 for (int i = 0; i < num_messages; ++i) {
61 messages.push_back(absl::StrCat("message", i));
62 }
63
64 // Generate Tokens Request and check it.
65 std::vector<std::string> client_fingerprints;
66 TokensRequest tokens_request;
67 TokensRequestPrivateState tokens_request_private_state;
68 ASSIGN_OR_RETURN(
69 std::tie(client_fingerprints, tokens_request,
70 tokens_request_private_state),
71 act->GenerateTokensRequest(messages, scheme_parameters,
72 client_parameters.public_parameters(),
73 client_parameters.private_parameters(),
74 server_parameters.public_parameters()));
75
76 RETURN_IF_ERROR(act->CheckTokensRequest(
77 client_fingerprints, tokens_request, scheme_parameters,
78 client_parameters.public_parameters(),
79 server_parameters.public_parameters(),
80 server_parameters.private_parameters()));
81
82 // Generate Tokens Response and check it.
83 ASSIGN_OR_RETURN(
84 TokensResponse tokens_response,
85 act->GenerateTokensResponse(tokens_request, scheme_parameters,
86 client_parameters.public_parameters(),
87 server_parameters.public_parameters(),
88 server_parameters.private_parameters()));
89
90 RETURN_IF_ERROR(act->VerifyTokensResponse(
91 messages, tokens_request, tokens_request_private_state, tokens_response,
92 scheme_parameters, client_parameters.public_parameters(),
93 client_parameters.private_parameters(),
94 server_parameters.public_parameters()));
95
96 // Extract Tokens.
97 ASSIGN_OR_RETURN(
98 std::vector<Token> tokens,
99 act->RecoverTokens(messages, tokens_request, tokens_request_private_state,
100 tokens_response, scheme_parameters,
101 client_parameters.public_parameters(),
102 client_parameters.private_parameters(),
103 server_parameters.public_parameters()));
104
105 // Verify Tokens.
106 if (tokens.size() != num_messages) {
107 return absl::InvalidArgumentError("Wrong number of tokens produced");
108 }
109 for (int i = 0; i < num_messages; ++i) {
110 RETURN_IF_ERROR(act->VerifyToken(messages[i], tokens[i], scheme_parameters,
111 server_parameters.public_parameters(),
112 server_parameters.private_parameters()));
113 }
114 return absl::OkStatus();
115 }
116
TEST(ActV0ParametersTest,EndToEndWithTestParameters)117 TEST(ActV0ParametersTest, EndToEndWithTestParameters) {
118 EXPECT_OK(EndToEndTest(ActV0TestSchemeParameters(), 3));
119 }
120
TEST(ActV0ParametersTest,EndToEndWithBatch16Parameters)121 TEST(ActV0ParametersTest, EndToEndWithBatch16Parameters) {
122 EXPECT_OK(EndToEndTest(ActV0Batch16SchemeParameters(), 16));
123 }
124
TEST(ActV0ParametersTest,EndToEndWithBatch32Parameters)125 TEST(ActV0ParametersTest, EndToEndWithBatch32Parameters) {
126 EXPECT_OK(EndToEndTest(ActV0Batch32SchemeParameters(), 32));
127 }
128
TEST(ActV0ParametersTest,EndToEndWithBatch32Cs2Modulus2048Parameters)129 TEST(ActV0ParametersTest, EndToEndWithBatch32Cs2Modulus2048Parameters) {
130 EXPECT_OK(EndToEndTest(
131 ActV0SchemeParametersPedersen32Modulus2048CamenischShoupVector2(), 32));
132 }
133
TEST(ActV0ParametersTest,EndToEndWithCustomParameters)134 TEST(ActV0ParametersTest, EndToEndWithCustomParameters) {
135 int pedersen_batch_size = 32;
136 int modulus_length_bits = 1576;
137 int camenisch_shoup_vector_length = 2;
138 EXPECT_OK(EndToEndTest(
139 ActV0SchemeParameters(pedersen_batch_size, modulus_length_bits,
140 camenisch_shoup_vector_length),
141 32));
142 }
143
144 // More extensive tests are in act_v0_test.cc. These tests simply ensure that
145 // the parameters are functional.
146
147 } // namespace
148 } // namespace anonymous_counting_tokens
149 } // namespace private_join_and_compute
150