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 "aead_impl.h"
18
19 #include <string>
20
21 #include "gmock/gmock.h"
22 #include "gtest/gtest.h"
23 #include "tink/aead/aead_config.h"
24 #include "tink/aead/aead_key_templates.h"
25 #include "tink/binary_keyset_writer.h"
26 #include "tink/cleartext_keyset_handle.h"
27 #include "proto/testing_api.grpc.pb.h"
28
29 namespace crypto {
30 namespace tink {
31 namespace {
32
33 using ::crypto::tink::AeadKeyTemplates;
34 using ::crypto::tink::BinaryKeysetWriter;
35 using ::crypto::tink::CleartextKeysetHandle;
36
37 using ::testing::Eq;
38 using ::testing::IsEmpty;
39 using ::tink_testing_api::AeadDecryptRequest;
40 using ::tink_testing_api::AeadEncryptRequest;
41 using ::tink_testing_api::AeadEncryptResponse;
42 using ::tink_testing_api::AeadDecryptResponse;
43
44 using crypto::tink::KeysetHandle;
45 using google::crypto::tink::KeyTemplate;
46 using tink_testing_api::CreationRequest;
47 using tink_testing_api::CreationResponse;
48
ValidKeyset()49 std::string ValidKeyset() {
50 const KeyTemplate& key_template = AeadKeyTemplates::Aes128Eax();
51 auto handle_result = KeysetHandle::GenerateNew(key_template);
52 EXPECT_TRUE(handle_result.ok());
53 std::stringbuf keyset;
54 auto writer_result =
55 BinaryKeysetWriter::New(absl::make_unique<std::ostream>(&keyset));
56 EXPECT_TRUE(writer_result.ok());
57
58 auto status = CleartextKeysetHandle::Write(writer_result.value().get(),
59 *handle_result.value());
60 EXPECT_TRUE(status.ok());
61 return keyset.str();
62 }
63
64 class AeadImplTest : public ::testing::Test {
65 protected:
SetUpTestSuite()66 static void SetUpTestSuite() { ASSERT_TRUE(AeadConfig::Register().ok()); }
67 };
68
TEST_F(AeadImplTest,CreateAeadSuccess)69 TEST_F(AeadImplTest, CreateAeadSuccess) {
70 tink_testing_api::AeadImpl aead;
71 std::string keyset = ValidKeyset();
72 CreationRequest request;
73 request.mutable_annotated_keyset()->set_serialized_keyset(keyset);
74 CreationResponse response;
75
76 EXPECT_TRUE(aead.Create(nullptr, &request, &response).ok());
77 EXPECT_THAT(response.err(), IsEmpty());
78 }
79
TEST_F(AeadImplTest,CreateAeadFails)80 TEST_F(AeadImplTest, CreateAeadFails) {
81 tink_testing_api::AeadImpl aead;
82 CreationRequest request;
83 request.mutable_annotated_keyset()->set_serialized_keyset("bad keyset");
84 CreationResponse response;
85
86 EXPECT_TRUE(aead.Create(nullptr, &request, &response).ok());
87 EXPECT_THAT(response.err(), Not(IsEmpty()));
88 }
89
TEST_F(AeadImplTest,EncryptDecryptSuccess)90 TEST_F(AeadImplTest, EncryptDecryptSuccess) {
91 tink_testing_api::AeadImpl aead;
92 std::string keyset = ValidKeyset();
93 AeadEncryptRequest enc_request;
94 enc_request.mutable_annotated_keyset()->set_serialized_keyset(keyset);
95 enc_request.set_plaintext("Plain text");
96 enc_request.set_associated_data("ad");
97 AeadEncryptResponse enc_response;
98
99 EXPECT_TRUE(aead.Encrypt(nullptr, &enc_request, &enc_response).ok());
100 EXPECT_THAT(enc_response.err(), IsEmpty());
101
102 AeadDecryptRequest dec_request;
103 dec_request.mutable_annotated_keyset()->set_serialized_keyset(keyset);
104 dec_request.set_ciphertext(enc_response.ciphertext());
105 dec_request.set_associated_data("ad");
106 AeadDecryptResponse dec_response;
107
108 EXPECT_TRUE(aead.Decrypt(nullptr, &dec_request, &dec_response).ok());
109 EXPECT_THAT(dec_response.err(), IsEmpty());
110 EXPECT_THAT(dec_response.plaintext(), Eq("Plain text"));
111 }
112
TEST_F(AeadImplTest,EncryptBadKeysetFail)113 TEST_F(AeadImplTest, EncryptBadKeysetFail) {
114 tink_testing_api::AeadImpl aead;
115 AeadEncryptRequest enc_request;
116 enc_request.mutable_annotated_keyset()->set_serialized_keyset("bad keyset");
117 enc_request.set_plaintext("Plain text");
118 enc_request.set_associated_data("ad");
119 AeadEncryptResponse enc_response;
120
121 EXPECT_FALSE(aead.Encrypt(nullptr, &enc_request, &enc_response).ok());
122 }
123
TEST_F(AeadImplTest,DecryptBadCiphertextFail)124 TEST_F(AeadImplTest, DecryptBadCiphertextFail) {
125 tink_testing_api::AeadImpl aead;
126 std::string keyset = ValidKeyset();
127 AeadDecryptRequest dec_request;
128 dec_request.mutable_annotated_keyset()->set_serialized_keyset(keyset);
129 dec_request.set_ciphertext("bad ciphertext");
130 dec_request.set_associated_data("ad");
131 AeadDecryptResponse dec_response;
132
133 EXPECT_TRUE(aead.Decrypt(nullptr, &dec_request, &dec_response).ok());
134 EXPECT_THAT(dec_response.err(), Not(IsEmpty()));
135 }
136
137 } // namespace
138 } // namespace tink
139 } // namespace crypto
140