• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //
2 // Copyright (C) 2015 The Android Open Source Project
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 #include <memory>
18 #include <string>
19 
20 #include <gmock/gmock.h>
21 #include <gtest/gtest.h>
22 
23 #include "attestation/common/mock_crypto_utility.h"
24 #include "attestation/server/database_impl.h"
25 
26 using testing::_;
27 using testing::Invoke;
28 using testing::NiceMock;
29 using testing::Return;
30 using testing::WithArgs;
31 
32 namespace {
33 
34 const char kFakeCredential[] = "1234";
35 
36 }  // namespace
37 
38 namespace attestation {
39 
40 class DatabaseImplTest : public testing::Test,
41                          public DatabaseIO {
42  public:
43   ~DatabaseImplTest() override = default;
SetUp()44   void SetUp() override {
45     database_.reset(new DatabaseImpl(&mock_crypto_utility_));
46     database_->set_io(this);
47     InitializeFakeData();
48     database_->Initialize();
49   }
50 
51   // Fake DatabaseIO::Read.
Read(std::string * data)52   bool Read(std::string* data) override {
53     if (fake_persistent_data_readable_) {
54       *data = fake_persistent_data_;
55     }
56     return fake_persistent_data_readable_;
57   }
58 
59   // Fake DatabaseIO::Write.
Write(const std::string & data)60   bool Write(const std::string& data) override {
61     if (fake_persistent_data_writable_) {
62       fake_persistent_data_ = data;
63     }
64     return fake_persistent_data_writable_;
65   }
66 
67   // Fake DatabaseIO::Watch.
Watch(const base::Closure & callback)68   void Watch(const base::Closure& callback) override {
69     fake_watch_callback_ = callback;
70   }
71 
72   // Initializes fake_persistent_data_ with a default value.
InitializeFakeData()73   void InitializeFakeData() {
74     AttestationDatabase proto;
75     proto.mutable_credentials()->set_conformance_credential(kFakeCredential);
76     proto.SerializeToString(&fake_persistent_data_);
77   }
78 
79  protected:
80   std::string fake_persistent_data_;
81   bool fake_persistent_data_readable_{true};
82   bool fake_persistent_data_writable_{true};
83   base::Closure fake_watch_callback_;
84   NiceMock<MockCryptoUtility> mock_crypto_utility_;
85   std::unique_ptr<DatabaseImpl> database_;
86 };
87 
TEST_F(DatabaseImplTest,ReadSuccess)88 TEST_F(DatabaseImplTest, ReadSuccess) {
89   database_->GetMutableProtobuf()->Clear();
90   EXPECT_TRUE(database_->Reload());
91   EXPECT_EQ(std::string(kFakeCredential),
92             database_->GetProtobuf().credentials().conformance_credential());
93 }
94 
TEST_F(DatabaseImplTest,ReadFailure)95 TEST_F(DatabaseImplTest, ReadFailure) {
96   fake_persistent_data_readable_ = false;
97   database_->GetMutableProtobuf()->Clear();
98   EXPECT_FALSE(database_->Reload());
99   EXPECT_FALSE(database_->GetProtobuf().has_credentials());
100 }
101 
TEST_F(DatabaseImplTest,DecryptFailure)102 TEST_F(DatabaseImplTest, DecryptFailure) {
103   EXPECT_CALL(mock_crypto_utility_, DecryptData(_, _, _))
104       .WillRepeatedly(Return(false));
105   database_->GetMutableProtobuf()->Clear();
106   EXPECT_FALSE(database_->Reload());
107   EXPECT_FALSE(database_->GetProtobuf().has_credentials());
108 }
109 
TEST_F(DatabaseImplTest,WriteSuccess)110 TEST_F(DatabaseImplTest, WriteSuccess) {
111   database_->GetMutableProtobuf()->mutable_credentials()->
112       set_platform_credential("test");
113   std::string expected_data;
114   database_->GetProtobuf().SerializeToString(&expected_data);
115   EXPECT_TRUE(database_->SaveChanges());
116   EXPECT_EQ(expected_data, fake_persistent_data_);
117 }
118 
TEST_F(DatabaseImplTest,WriteFailure)119 TEST_F(DatabaseImplTest, WriteFailure) {
120   fake_persistent_data_writable_ = false;
121   database_->GetMutableProtobuf()->mutable_credentials()->
122       set_platform_credential("test");
123   EXPECT_FALSE(database_->SaveChanges());
124 }
125 
TEST_F(DatabaseImplTest,EncryptFailure)126 TEST_F(DatabaseImplTest, EncryptFailure) {
127   EXPECT_CALL(mock_crypto_utility_, EncryptData(_, _, _, _))
128       .WillRepeatedly(Return(false));
129   database_->GetMutableProtobuf()->mutable_credentials()->
130       set_platform_credential("test");
131   EXPECT_FALSE(database_->SaveChanges());
132 }
133 
TEST_F(DatabaseImplTest,IgnoreLegacyEncryptJunk)134 TEST_F(DatabaseImplTest, IgnoreLegacyEncryptJunk) {
135   // Legacy encryption scheme appended a SHA-1 hash before encrypting.
136   fake_persistent_data_ += std::string(20, 'A');
137   EXPECT_EQ(std::string(kFakeCredential),
138             database_->GetProtobuf().credentials().conformance_credential());
139 }
140 
TEST_F(DatabaseImplTest,Reload)141 TEST_F(DatabaseImplTest, Reload) {
142   AttestationDatabase proto;
143   proto.mutable_credentials()->set_platform_credential(kFakeCredential);
144   proto.SerializeToString(&fake_persistent_data_);
145   EXPECT_EQ(std::string(),
146             database_->GetProtobuf().credentials().platform_credential());
147   EXPECT_TRUE(database_->Reload());
148   EXPECT_EQ(std::string(kFakeCredential),
149             database_->GetProtobuf().credentials().platform_credential());
150 }
151 
TEST_F(DatabaseImplTest,AutoReload)152 TEST_F(DatabaseImplTest, AutoReload) {
153   AttestationDatabase proto;
154   proto.mutable_credentials()->set_platform_credential(kFakeCredential);
155   proto.SerializeToString(&fake_persistent_data_);
156   EXPECT_EQ(std::string(),
157             database_->GetProtobuf().credentials().platform_credential());
158   fake_watch_callback_.Run();
159   EXPECT_EQ(std::string(kFakeCredential),
160             database_->GetProtobuf().credentials().platform_credential());
161 }
162 
163 }  // namespace attestation
164