1 // Copyright 2020 Google LLC
2 //
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 // http://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
17 #include "prf_set_impl.h"
18
19 #include <string>
20
21 #include "gmock/gmock.h"
22 #include "gtest/gtest.h"
23 #include "tink/binary_keyset_writer.h"
24 #include "tink/cleartext_keyset_handle.h"
25 #include "tink/prf/prf_config.h"
26 #include "tink/prf/prf_key_templates.h"
27 #include "proto/testing_api.grpc.pb.h"
28
29 namespace crypto {
30 namespace tink {
31 namespace {
32
33 using ::crypto::tink::BinaryKeysetWriter;
34 using ::crypto::tink::CleartextKeysetHandle;
35 using ::crypto::tink::PrfKeyTemplates;
36
37 using ::testing::ElementsAre;
38 using ::testing::Eq;
39 using ::testing::IsEmpty;
40 using ::tink_testing_api::CreationRequest;
41 using ::tink_testing_api::CreationResponse;
42 using ::tink_testing_api::PrfSetComputeRequest;
43 using ::tink_testing_api::PrfSetComputeResponse;
44 using ::tink_testing_api::PrfSetKeyIdsRequest;
45 using ::tink_testing_api::PrfSetKeyIdsResponse;
46
47 using crypto::tink::KeysetHandle;
48 using google::crypto::tink::KeyTemplate;
49
ValidKeyset()50 std::string ValidKeyset() {
51 const KeyTemplate& key_template = PrfKeyTemplates::HmacSha256();
52 auto handle_result = KeysetHandle::GenerateNew(key_template);
53 EXPECT_TRUE(handle_result.ok());
54 std::stringbuf keyset;
55 auto writer_result =
56 BinaryKeysetWriter::New(absl::make_unique<std::ostream>(&keyset));
57 EXPECT_TRUE(writer_result.ok());
58
59 auto status = CleartextKeysetHandle::Write(writer_result.value().get(),
60 *handle_result.value());
61 EXPECT_TRUE(status.ok());
62 return keyset.str();
63 }
64
65 class PrfSetImplTest : public ::testing::Test {
66 protected:
SetUpTestSuite()67 static void SetUpTestSuite() { ASSERT_TRUE(PrfConfig::Register().ok()); }
68 };
69
TEST_F(PrfSetImplTest,CreateAeadSuccess)70 TEST_F(PrfSetImplTest, CreateAeadSuccess) {
71 tink_testing_api::PrfSetImpl prfset;
72 std::string keyset = ValidKeyset();
73 CreationRequest request;
74 request.mutable_annotated_keyset()->set_serialized_keyset(keyset);
75 CreationResponse response;
76
77 EXPECT_TRUE(prfset.Create(nullptr, &request, &response).ok());
78 EXPECT_THAT(response.err(), IsEmpty());
79 }
80
TEST_F(PrfSetImplTest,CreateAeadFails)81 TEST_F(PrfSetImplTest, CreateAeadFails) {
82 tink_testing_api::PrfSetImpl prfset;
83 CreationRequest request;
84 request.mutable_annotated_keyset()->set_serialized_keyset("bad keyset");
85 CreationResponse response;
86
87 EXPECT_TRUE(prfset.Create(nullptr, &request, &response).ok());
88 EXPECT_THAT(response.err(), Not(IsEmpty()));
89 }
90
TEST_F(PrfSetImplTest,KeyIdsComputeSuccess)91 TEST_F(PrfSetImplTest, KeyIdsComputeSuccess) {
92 tink_testing_api::PrfSetImpl prfset;
93 std::string keyset = ValidKeyset();
94
95 PrfSetKeyIdsRequest key_id_request;
96 key_id_request.mutable_annotated_keyset()->set_serialized_keyset(keyset);
97 PrfSetKeyIdsResponse key_id_response;
98
99 EXPECT_TRUE(prfset.KeyIds(nullptr, &key_id_request, &key_id_response).ok());
100 EXPECT_THAT(key_id_response.err(), IsEmpty());
101 EXPECT_THAT(key_id_response.output().key_id(),
102 ElementsAre(key_id_response.output().primary_key_id()));
103
104 PrfSetComputeRequest comp_request;
105 comp_request.mutable_annotated_keyset()->set_serialized_keyset(keyset);
106 comp_request.set_key_id(key_id_response.output().primary_key_id());
107 comp_request.set_input_data("some data");
108 comp_request.set_output_length(16);
109 PrfSetComputeResponse comp_response;
110
111 EXPECT_TRUE(prfset.Compute(nullptr, &comp_request, &comp_response).ok());
112 EXPECT_THAT(comp_response.err(), IsEmpty());
113 EXPECT_THAT(comp_response.output().size(), Eq(16));
114 }
115
TEST_F(PrfSetImplTest,KeyIdsBadKeysetFail)116 TEST_F(PrfSetImplTest, KeyIdsBadKeysetFail) {
117 tink_testing_api::PrfSetImpl prfset;
118 PrfSetKeyIdsRequest key_id_request;
119 key_id_request.mutable_annotated_keyset()->set_serialized_keyset(
120 "bad keyset");
121 PrfSetKeyIdsResponse key_id_response;
122
123 EXPECT_TRUE(prfset.KeyIds(nullptr, &key_id_request, &key_id_response).ok());
124 EXPECT_THAT(key_id_response.err(), Not(IsEmpty()));
125 }
126
TEST_F(PrfSetImplTest,ComputeBadKeysetFail)127 TEST_F(PrfSetImplTest, ComputeBadKeysetFail) {
128 tink_testing_api::PrfSetImpl prfset;
129 PrfSetComputeRequest comp_request;
130 comp_request.mutable_annotated_keyset()->set_serialized_keyset("bad keyset");
131 comp_request.set_key_id(1234);
132 comp_request.set_input_data("some data");
133 comp_request.set_output_length(16);
134 PrfSetComputeResponse comp_response;
135
136 EXPECT_TRUE(prfset.Compute(nullptr, &comp_request, &comp_response).ok());
137 EXPECT_THAT(comp_response.err(), Not(IsEmpty()));
138 }
139
TEST_F(PrfSetImplTest,ComputeBadOutputLengthFail)140 TEST_F(PrfSetImplTest, ComputeBadOutputLengthFail) {
141 tink_testing_api::PrfSetImpl prfset;
142 std::string keyset = ValidKeyset();
143 PrfSetKeyIdsRequest key_id_request;
144 key_id_request.mutable_annotated_keyset()->set_serialized_keyset(keyset);
145 PrfSetKeyIdsResponse key_id_response;
146 EXPECT_TRUE(prfset.KeyIds(nullptr, &key_id_request, &key_id_response).ok());
147 EXPECT_THAT(key_id_response.err(), IsEmpty());
148
149 PrfSetComputeRequest comp_request;
150 comp_request.mutable_annotated_keyset()->set_serialized_keyset(keyset);
151 comp_request.set_key_id(key_id_response.output().primary_key_id());
152 comp_request.set_input_data("some data");
153 comp_request.set_output_length(123456); // bad output length
154 PrfSetComputeResponse comp_response;
155 EXPECT_TRUE(prfset.Compute(nullptr, &comp_request, &comp_response).ok());
156 EXPECT_THAT(comp_response.err(), Not(IsEmpty()));
157 }
158
TEST_F(PrfSetImplTest,ComputeBadKeyIdFail)159 TEST_F(PrfSetImplTest, ComputeBadKeyIdFail) {
160 tink_testing_api::PrfSetImpl prfset;
161 std::string keyset = ValidKeyset();
162
163 PrfSetComputeRequest comp_request;
164 comp_request.mutable_annotated_keyset()->set_serialized_keyset(keyset);
165 comp_request.set_key_id(12345); // bad key id
166 comp_request.set_input_data("some data");
167 comp_request.set_output_length(16);
168 PrfSetComputeResponse comp_response;
169 EXPECT_TRUE(prfset.Compute(nullptr, &comp_request, &comp_response).ok());
170 EXPECT_THAT(comp_response.err(), Not(IsEmpty()));
171 }
172
173 } // namespace
174 } // namespace tink
175 } // namespace crypto
176