1 // Copyright 2017 Google Inc.
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 "tink/binary_keyset_reader.h"
18
19 #include <ios>
20 #include <iostream>
21 #include <istream>
22 #include <memory>
23 #include <sstream>
24 #include <string>
25 #include <utility>
26
27 #include "gtest/gtest.h"
28 #include "tink/util/test_util.h"
29 #include "proto/tink.pb.h"
30
31 using crypto::tink::test::AddRawKey;
32 using crypto::tink::test::AddTinkKey;
33
34 using google::crypto::tink::EncryptedKeyset;
35 using google::crypto::tink::KeyData;
36 using google::crypto::tink::Keyset;
37 using google::crypto::tink::KeyStatusType;
38
39 namespace crypto {
40 namespace tink {
41 namespace {
42
43 class BinaryKeysetReaderTest : public ::testing::Test {
44 protected:
SetUp()45 void SetUp() override {
46 Keyset::Key key;
47 AddTinkKey("some key type", 42, key, KeyStatusType::ENABLED,
48 KeyData::SYMMETRIC, &keyset_);
49 AddRawKey("some other key type", 711, key, KeyStatusType::ENABLED,
50 KeyData::SYMMETRIC, &keyset_);
51 keyset_.set_primary_key_id(42);
52 good_serialized_keyset_ = keyset_.SerializeAsString();
53 bad_serialized_keyset_ = "some weird string";
54
55 encrypted_keyset_.set_encrypted_keyset("some ciphertext with keyset");
56 auto keyset_info = encrypted_keyset_.mutable_keyset_info();
57 keyset_info->set_primary_key_id(42);
58 auto key_info = keyset_info->add_key_info();
59 key_info->set_type_url("some type_url");
60 key_info->set_key_id(42);
61 good_serialized_encrypted_keyset_ = encrypted_keyset_.SerializeAsString();
62 }
63
64 EncryptedKeyset encrypted_keyset_;
65 Keyset keyset_;
66 std::string bad_serialized_keyset_;
67 std::string good_serialized_keyset_;
68 std::string good_serialized_encrypted_keyset_;
69 };
70
71
TEST_F(BinaryKeysetReaderTest,testReaderCreation)72 TEST_F(BinaryKeysetReaderTest, testReaderCreation) {
73 { // Input stream is null.
74 std::unique_ptr<std::istream> null_stream(nullptr);
75 auto reader_result = BinaryKeysetReader::New(std::move(null_stream));
76 EXPECT_FALSE(reader_result.ok());
77 EXPECT_EQ(absl::StatusCode::kInvalidArgument,
78 reader_result.status().code());
79 }
80
81 { // Good serialized keyset.
82 auto reader_result = BinaryKeysetReader::New(good_serialized_keyset_);
83 EXPECT_TRUE(reader_result.ok()) << reader_result.status();
84 }
85
86 { // Stream with good keyset.
87 std::unique_ptr<std::istream> good_keyset_stream(new std::stringstream(
88 std::string(good_serialized_keyset_), std::ios_base::in));
89 auto reader_result = BinaryKeysetReader::New(std::move(good_keyset_stream));
90 EXPECT_TRUE(reader_result.ok()) << reader_result.status();
91 }
92
93 { // Bad serialized keyset.
94 auto reader_result = BinaryKeysetReader::New(bad_serialized_keyset_);
95 EXPECT_TRUE(reader_result.ok()) << reader_result.status();
96 }
97
98 { // Stream with bad keyset.
99 std::unique_ptr<std::istream> bad_keyset_stream(new std::stringstream(
100 std::string(bad_serialized_keyset_), std::ios_base::in));
101 auto reader_result = BinaryKeysetReader::New(std::move(bad_keyset_stream));
102 EXPECT_TRUE(reader_result.ok()) << reader_result.status();
103 }
104 }
105
TEST_F(BinaryKeysetReaderTest,testReadFromString)106 TEST_F(BinaryKeysetReaderTest, testReadFromString) {
107 { // Good string.
108 auto reader_result = BinaryKeysetReader::New(good_serialized_keyset_);
109 EXPECT_TRUE(reader_result.ok()) << reader_result.status();
110 auto reader = std::move(reader_result.value());
111 auto read_result = reader->Read();
112 EXPECT_TRUE(read_result.ok()) << read_result.status();
113 auto keyset = std::move(read_result.value());
114 EXPECT_EQ(good_serialized_keyset_, keyset->SerializeAsString());
115 }
116
117 { // Bad string.
118 auto reader_result = BinaryKeysetReader::New(bad_serialized_keyset_);
119 EXPECT_TRUE(reader_result.ok()) << reader_result.status();
120 auto reader = std::move(reader_result.value());
121 auto read_result = reader->Read();
122 EXPECT_FALSE(read_result.ok());
123 EXPECT_EQ(absl::StatusCode::kInvalidArgument, read_result.status().code());
124 }
125 }
126
TEST_F(BinaryKeysetReaderTest,testReadFromStream)127 TEST_F(BinaryKeysetReaderTest, testReadFromStream) {
128 { // Good stream.
129 std::unique_ptr<std::istream> good_keyset_stream(new std::stringstream(
130 std::string(good_serialized_keyset_), std::ios_base::in));
131 auto reader_result = BinaryKeysetReader::New(std::move(good_keyset_stream));
132 EXPECT_TRUE(reader_result.ok()) << reader_result.status();
133 auto reader = std::move(reader_result.value());
134 auto read_result = reader->Read();
135 EXPECT_TRUE(read_result.ok()) << read_result.status();
136 auto keyset = std::move(read_result.value());
137 EXPECT_EQ(good_serialized_keyset_, keyset->SerializeAsString());
138 }
139
140 { // Bad stream.
141 std::unique_ptr<std::istream> bad_keyset_stream(new std::stringstream(
142 std::string(bad_serialized_keyset_), std::ios_base::in));
143 auto reader_result = BinaryKeysetReader::New(std::move(bad_keyset_stream));
144 EXPECT_TRUE(reader_result.ok()) << reader_result.status();
145 auto reader = std::move(reader_result.value());
146 auto read_result = reader->Read();
147 EXPECT_FALSE(read_result.ok());
148 EXPECT_EQ(absl::StatusCode::kInvalidArgument, read_result.status().code());
149 }
150 }
151
TEST_F(BinaryKeysetReaderTest,testReadEncryptedFromString)152 TEST_F(BinaryKeysetReaderTest, testReadEncryptedFromString) {
153 { // Good string.
154 auto reader_result =
155 BinaryKeysetReader::New(good_serialized_encrypted_keyset_);
156 EXPECT_TRUE(reader_result.ok()) << reader_result.status();
157 auto reader = std::move(reader_result.value());
158 auto read_encrypted_result = reader->ReadEncrypted();
159 EXPECT_TRUE(read_encrypted_result.ok()) << read_encrypted_result.status();
160 auto encrypted_keyset = std::move(read_encrypted_result.value());
161 EXPECT_EQ(good_serialized_encrypted_keyset_,
162 encrypted_keyset->SerializeAsString());
163 }
164
165 { // Bad string.
166 auto reader_result = BinaryKeysetReader::New(bad_serialized_keyset_);
167 EXPECT_TRUE(reader_result.ok()) << reader_result.status();
168 auto reader = std::move(reader_result.value());
169 auto read_encrypted_result = reader->ReadEncrypted();
170 EXPECT_FALSE(read_encrypted_result.ok());
171 EXPECT_EQ(absl::StatusCode::kInvalidArgument,
172 read_encrypted_result.status().code());
173 }
174 }
175
TEST_F(BinaryKeysetReaderTest,testReadEncryptedFromStream)176 TEST_F(BinaryKeysetReaderTest, testReadEncryptedFromStream) {
177 { // Good stream.
178 std::unique_ptr<std::istream> good_encrypted_keyset_stream(
179 new std::stringstream(std::string(good_serialized_encrypted_keyset_),
180 std::ios_base::in));
181 auto reader_result =
182 BinaryKeysetReader::New(std::move(good_encrypted_keyset_stream));
183 EXPECT_TRUE(reader_result.ok()) << reader_result.status();
184 auto reader = std::move(reader_result.value());
185 auto read_encrypted_result = reader->ReadEncrypted();
186 EXPECT_TRUE(read_encrypted_result.ok()) << read_encrypted_result.status();
187 auto encrypted_keyset = std::move(read_encrypted_result.value());
188 EXPECT_EQ(good_serialized_encrypted_keyset_,
189 encrypted_keyset->SerializeAsString());
190 }
191
192 { // Bad string.
193 std::unique_ptr<std::istream> bad_keyset_stream(new std::stringstream(
194 std::string(bad_serialized_keyset_), std::ios_base::in));
195 auto reader_result = BinaryKeysetReader::New(std::move(bad_keyset_stream));
196 EXPECT_TRUE(reader_result.ok()) << reader_result.status();
197 auto reader = std::move(reader_result.value());
198 auto read_encrypted_result = reader->ReadEncrypted();
199 EXPECT_FALSE(read_encrypted_result.ok());
200 EXPECT_EQ(absl::StatusCode::kInvalidArgument,
201 read_encrypted_result.status().code());
202 }
203 }
204
205 } // namespace
206 } // namespace tink
207 } // namespace crypto
208