test_common_load.cpp
Go to the documentation of this file.
1 //
2 // Bareflank Hypervisor
3 //
4 // Copyright (C) 2015 Assured Information Security, Inc.
5 // Author: Rian Quinn <quinnr@ainfosec.com>
6 // Author: Brendan Kerrigan <kerriganb@ainfosec.com>
7 //
8 // This library is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU Lesser General Public
10 // License as published by the Free Software Foundation; either
11 // version 2.1 of the License, or (at your option) any later version.
12 //
13 // This library is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 // Lesser General Public License for more details.
17 //
18 // You should have received a copy of the GNU Lesser General Public
19 // License along with this library; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 
22 #include <gsl/gsl>
23 
24 #include <test.h>
25 
26 #include <memory.h>
27 #include <common.h>
28 #include <platform.h>
29 #include <driver_entry_interface.h>
30 
31 // -----------------------------------------------------------------------------
32 // Expose Private Functions
33 // -----------------------------------------------------------------------------
34 
35 extern "C"
36 {
37  struct module_t *get_module(uint64_t index);
38  int64_t resolve_symbol(const char *name, void **sym);
39  int64_t execute_symbol(const char *sym, uint64_t arg1, uint64_t arg2, uint64_t cpuid);
40  int64_t add_raw_md_to_memory_manager(uint64_t virt, uint64_t type);
41  int64_t add_md_to_memory_manager(struct module_t *module);
42 }
43 
44 extern uint64_t g_malloc_fails;
45 
46 // -----------------------------------------------------------------------------
47 // Tests
48 // -----------------------------------------------------------------------------
49 
50 void
51 driver_entry_ut::test_common_load_successful_load()
52 {
53  this->expect_true(common_add_module(m_dummy_start_vmm_success.get(), m_dummy_start_vmm_success_length) == BF_SUCCESS);
54  this->expect_true(common_add_module(m_dummy_stop_vmm_success.get(), m_dummy_stop_vmm_success_length) == BF_SUCCESS);
55  this->expect_true(common_add_module(m_dummy_add_md_success.get(), m_dummy_add_md_success_length) == BF_SUCCESS);
56  this->expect_true(common_add_module(m_dummy_misc.get(), m_dummy_misc_length) == BF_SUCCESS);
57  this->expect_true(common_load_vmm() == BF_SUCCESS);
58  this->expect_true(common_vmm_status() == VMM_LOADED);
59  this->expect_true(common_fini() == BF_SUCCESS);
60  this->expect_true(common_vmm_status() == VMM_UNLOADED);
61 }
62 
63 void
64 driver_entry_ut::test_common_load_load_when_already_loaded()
65 {
66  this->expect_true(common_add_module(m_dummy_start_vmm_success.get(), m_dummy_start_vmm_success_length) == BF_SUCCESS);
67  this->expect_true(common_add_module(m_dummy_stop_vmm_success.get(), m_dummy_stop_vmm_success_length) == BF_SUCCESS);
68  this->expect_true(common_add_module(m_dummy_add_md_success.get(), m_dummy_add_md_success_length) == BF_SUCCESS);
69  this->expect_true(common_add_module(m_dummy_misc.get(), m_dummy_misc_length) == BF_SUCCESS);
70  this->expect_true(common_load_vmm() == BF_SUCCESS);
71  this->expect_true(common_load_vmm() == BF_SUCCESS);
72  this->expect_true(common_vmm_status() == VMM_LOADED);
73  this->expect_true(common_fini() == BF_SUCCESS);
74  this->expect_true(common_vmm_status() == VMM_UNLOADED);
75 }
76 
77 void
78 driver_entry_ut::test_common_load_load_when_already_running()
79 {
80  this->expect_true(common_add_module(m_dummy_start_vmm_success.get(), m_dummy_start_vmm_success_length) == BF_SUCCESS);
81  this->expect_true(common_add_module(m_dummy_stop_vmm_success.get(), m_dummy_stop_vmm_success_length) == BF_SUCCESS);
82  this->expect_true(common_add_module(m_dummy_add_md_success.get(), m_dummy_add_md_success_length) == BF_SUCCESS);
83  this->expect_true(common_add_module(m_dummy_misc.get(), m_dummy_misc_length) == BF_SUCCESS);
84  this->expect_true(common_load_vmm() == BF_SUCCESS);
85  this->expect_true(common_start_vmm() == BF_SUCCESS);
86  this->expect_true(common_load_vmm() == BF_ERROR_VMM_INVALID_STATE);
87  this->expect_true(common_vmm_status() == VMM_RUNNING);
88  this->expect_true(common_fini() == BF_SUCCESS);
89  this->expect_true(common_vmm_status() == VMM_UNLOADED);
90 }
91 
92 void
93 driver_entry_ut::test_common_load_load_when_corrupt()
94 {
95  this->expect_true(common_add_module(m_dummy_start_vmm_success.get(), m_dummy_start_vmm_success_length) == BF_SUCCESS);
96  this->expect_true(common_add_module(m_dummy_stop_vmm_failure.get(), m_dummy_stop_vmm_failure_length) == BF_SUCCESS);
97  this->expect_true(common_add_module(m_dummy_add_md_success.get(), m_dummy_add_md_success_length) == BF_SUCCESS);
98  this->expect_true(common_add_module(m_dummy_misc.get(), m_dummy_misc_length) == BF_SUCCESS);
99  this->expect_true(common_load_vmm() == BF_SUCCESS);
100  this->expect_true(common_start_vmm() == BF_SUCCESS);
101  this->expect_true(common_fini() == BF_ERROR_VMM_CORRUPTED);
102  this->expect_true(common_vmm_status() == VMM_CORRUPT);
103  this->expect_true(common_load_vmm() == BF_ERROR_VMM_CORRUPTED);
104 
105  common_reset();
106 }
107 
108 void
109 driver_entry_ut::test_common_load_fail_due_to_relocation_error()
110 {
111  this->expect_true(common_add_module(m_dummy_start_vmm_success.get(), m_dummy_start_vmm_success_length) == BF_SUCCESS);
112  this->expect_true(common_add_module(m_dummy_stop_vmm_success.get(), m_dummy_stop_vmm_success_length) == BF_SUCCESS);
113  this->expect_true(common_load_vmm() == BFELF_ERROR_NO_SUCH_SYMBOL);
114  this->expect_true(common_vmm_status() == VMM_UNLOADED);
115  this->expect_true(common_fini() == BF_SUCCESS);
116  this->expect_true(common_vmm_status() == VMM_UNLOADED);
117 }
118 
119 void
120 driver_entry_ut::test_common_load_fail_due_to_no_modules_added()
121 {
122  this->expect_true(common_load_vmm() == BF_ERROR_NO_MODULES_ADDED);
123  this->expect_true(common_vmm_status() == VMM_UNLOADED);
124  this->expect_true(common_fini() == BF_SUCCESS);
125  this->expect_true(common_vmm_status() == VMM_UNLOADED);
126 }
127 
128 void
129 driver_entry_ut::test_common_load_add_md_failed()
130 {
131  this->expect_true(common_add_module(m_dummy_start_vmm_success.get(), m_dummy_start_vmm_success_length) == BF_SUCCESS);
132  this->expect_true(common_add_module(m_dummy_stop_vmm_success.get(), m_dummy_stop_vmm_success_length) == BF_SUCCESS);
133  this->expect_true(common_add_module(m_dummy_add_md_failure.get(), m_dummy_add_md_failure_length) == BF_SUCCESS);
134  this->expect_true(common_add_module(m_dummy_misc.get(), m_dummy_misc_length) == BF_SUCCESS);
135  this->expect_true(common_load_vmm() == MEMORY_MANAGER_FAILURE);
136  this->expect_true(common_fini() == BF_SUCCESS);
137 }
138 
139 void
140 driver_entry_ut::test_common_load_add_md_tls_failed()
141 {
142  this->expect_true(common_add_module(m_dummy_start_vmm_success.get(), m_dummy_start_vmm_success_length) == BF_SUCCESS);
143  this->expect_true(common_add_module(m_dummy_stop_vmm_success.get(), m_dummy_stop_vmm_success_length) == BF_SUCCESS);
144  this->expect_true(common_add_module(m_dummy_add_md_success.get(), m_dummy_add_md_success_length) == BF_SUCCESS);
145  this->expect_true(common_add_module(m_dummy_misc.get(), m_dummy_misc_length) == BF_SUCCESS);
146 
147  {
148  MockRepository mocks;
149  mocks.OnCallFunc(add_md_to_memory_manager).Return(0);
150  mocks.ExpectCallFunc(add_raw_md_to_memory_manager).Return(-1);
151 
152  RUN_UNITTEST_WITH_MOCKS(mocks, [&]
153  {
154  this->expect_true(common_load_vmm() == -1);
155  });
156  }
157 
158  this->expect_true(common_fini() == BF_SUCCESS);
159 }
160 
161 void
162 driver_entry_ut::test_common_load_tls_platform_alloc_failed()
163 {
164  g_malloc_fails = THREAD_LOCAL_STORAGE_SIZE;
165 
166  auto ___ = gsl::finally([&]
167  { g_malloc_fails = 0; });
168 
169  this->expect_true(common_add_module(m_dummy_start_vmm_success.get(), m_dummy_start_vmm_success_length) == BF_SUCCESS);
170  this->expect_true(common_add_module(m_dummy_stop_vmm_success.get(), m_dummy_stop_vmm_success_length) == BF_SUCCESS);
171  this->expect_true(common_add_module(m_dummy_add_md_success.get(), m_dummy_add_md_success_length) == BF_SUCCESS);
172  this->expect_true(common_add_module(m_dummy_misc.get(), m_dummy_misc_length) == BF_SUCCESS);
173  this->expect_true(common_load_vmm() == BF_ERROR_OUT_OF_MEMORY);
174  this->expect_true(common_fini() == BF_SUCCESS);
175 }
176 
177 void
178 driver_entry_ut::test_common_load_stack_platform_alloc_failed()
179 {
180  g_malloc_fails = STACK_SIZE * 2;
181 
182  auto ___ = gsl::finally([&]
183  { g_malloc_fails = 0; });
184 
185  this->expect_true(common_add_module(m_dummy_start_vmm_success.get(), m_dummy_start_vmm_success_length) == BF_SUCCESS);
186  this->expect_true(common_add_module(m_dummy_stop_vmm_success.get(), m_dummy_stop_vmm_success_length) == BF_SUCCESS);
187  this->expect_true(common_add_module(m_dummy_add_md_success.get(), m_dummy_add_md_success_length) == BF_SUCCESS);
188  this->expect_true(common_add_module(m_dummy_misc.get(), m_dummy_misc_length) == BF_SUCCESS);
189  this->expect_true(common_load_vmm() == BF_ERROR_OUT_OF_MEMORY);
190  this->expect_true(common_fini() == BF_SUCCESS);
191 }
192 
193 void
194 driver_entry_ut::test_common_load_loader_add_failed()
195 {
196  this->expect_true(common_add_module(m_dummy_start_vmm_success.get(), m_dummy_start_vmm_success_length) == BF_SUCCESS);
197  this->expect_true(common_add_module(m_dummy_stop_vmm_success.get(), m_dummy_stop_vmm_success_length) == BF_SUCCESS);
198  this->expect_true(common_add_module(m_dummy_add_md_success.get(), m_dummy_add_md_success_length) == BF_SUCCESS);
199  this->expect_true(common_add_module(m_dummy_misc.get(), m_dummy_misc_length) == BF_SUCCESS);
200 
201  auto module = get_module(0);
202  module->file.added = 1;
203 
204  this->expect_true(common_load_vmm() == BFELF_ERROR_INVALID_ARG);
205  this->expect_true(common_fini() == BF_SUCCESS);
206 }
207 
208 void
209 driver_entry_ut::test_common_load_resolve_symbol_failed()
210 {
211  this->expect_true(common_add_module(m_dummy_start_vmm_success.get(), m_dummy_start_vmm_success_length) == BF_SUCCESS);
212  this->expect_true(common_add_module(m_dummy_stop_vmm_success.get(), m_dummy_stop_vmm_success_length) == BF_SUCCESS);
213  this->expect_true(common_add_module(m_dummy_add_md_success.get(), m_dummy_add_md_success_length) == BF_SUCCESS);
214  this->expect_true(common_add_module(m_dummy_misc.get(), m_dummy_misc_length) == BF_SUCCESS);
215 
216  {
217  MockRepository mocks;
218  mocks.ExpectCallFunc(resolve_symbol).Return(-1);
219 
220  RUN_UNITTEST_WITH_MOCKS(mocks, [&]
221  {
222  this->expect_true(common_load_vmm() == -1);
223  });
224  }
225 
226  this->expect_true(common_fini() == BF_SUCCESS);
227 }
228 
229 void
230 driver_entry_ut::test_common_load_execute_symbol_failed()
231 {
232  this->expect_true(common_add_module(m_dummy_start_vmm_success.get(), m_dummy_start_vmm_success_length) == BF_SUCCESS);
233  this->expect_true(common_add_module(m_dummy_stop_vmm_success.get(), m_dummy_stop_vmm_success_length) == BF_SUCCESS);
234  this->expect_true(common_add_module(m_dummy_add_md_success.get(), m_dummy_add_md_success_length) == BF_SUCCESS);
235  this->expect_true(common_add_module(m_dummy_misc.get(), m_dummy_misc_length) == BF_SUCCESS);
236 
237  {
238  MockRepository mocks;
239  mocks.ExpectCallFunc(execute_symbol).Return(-1);
240 
241  RUN_UNITTEST_WITH_MOCKS(mocks, [&]
242  {
243  this->expect_true(common_load_vmm() == -1);
244  });
245  }
246 
247  this->expect_true(common_fini() == BF_SUCCESS);
248 }
BF_SUCCESS
#define BF_SUCCESS
Definition: error_codes.h:105
common_add_module
int64_t common_add_module(const char *file, uint64_t fsize)
Definition: common.c:305
VMM_LOADED
#define VMM_LOADED
Definition: driver_entry_interface.h:49
RUN_UNITTEST_WITH_MOCKS
#define RUN_UNITTEST_WITH_MOCKS(a, b)
Definition: unittest.h:229
BFELF_ERROR_INVALID_ARG
#define BFELF_ERROR_INVALID_ARG
Definition: error_codes.h:81
common_load_vmm
int64_t common_load_vmm(void)
Definition: common.c:357
common_fini
int64_t common_fini(void)
Definition: common.c:273
BFELF_ERROR_NO_SUCH_SYMBOL
#define BFELF_ERROR_NO_SUCH_SYMBOL
Definition: error_codes.h:89
execute_symbol
int64_t execute_symbol(const char *sym, uint64_t arg1, uint64_t arg2, uint64_t cpuid)
Definition: common.c:108
BF_ERROR_VMM_INVALID_STATE
#define BF_ERROR_VMM_INVALID_STATE
Definition: error_codes.h:110
module_t
Definition: common.h:53
MEMORY_MANAGER_FAILURE
#define MEMORY_MANAGER_FAILURE
Definition: error_codes.h:99
g_malloc_fails
uint64_t g_malloc_fails
Definition: platform.c:37
THREAD_LOCAL_STORAGE_SIZE
#define THREAD_LOCAL_STORAGE_SIZE
Definition: constants.h:241
x64::page_table::index
auto index(const T virt, const F from)
Definition: page_table_entry_x64.h:40
get_module
struct module_t * get_module(uint64_t index)
VMM_UNLOADED
#define VMM_UNLOADED
Definition: driver_entry_interface.h:48
virt
constexpr page_table_x64::integer_pointer virt
Definition: test_page_table_x64.cpp:29
common_start_vmm
int64_t common_start_vmm(void)
Definition: common.c:490
add_md_to_memory_manager
int64_t add_md_to_memory_manager(struct module_t *module)
Definition: common.c:152
driver_entry_interface.h
BF_ERROR_OUT_OF_MEMORY
#define BF_ERROR_OUT_OF_MEMORY
Definition: error_codes.h:113
BF_ERROR_NO_MODULES_ADDED
#define BF_ERROR_NO_MODULES_ADDED
Definition: error_codes.h:108
x64::cpuid::addr_size::name
constexpr const auto name
Definition: cpuid_x64.h:81
STACK_SIZE
#define STACK_SIZE
Definition: constants.h:225
resolve_symbol
int64_t resolve_symbol(const char *name, void **sym)
Definition: common.c:87
VMM_RUNNING
#define VMM_RUNNING
Definition: driver_entry_interface.h:50
VMM_CORRUPT
#define VMM_CORRUPT
Definition: driver_entry_interface.h:51
command_line_parser_command::type
type
Definition: command_line_parser.h:33
add_raw_md_to_memory_manager
int64_t add_raw_md_to_memory_manager(uint64_t virt, uint64_t type)
Definition: common.c:135
common_vmm_status
int64_t common_vmm_status(void)
Definition: common.c:227
BF_ERROR_VMM_CORRUPTED
#define BF_ERROR_VMM_CORRUPTED
Definition: error_codes.h:114
expect_true
#define expect_true(a)
Definition: exit_handler_intel_x64_unittests.h:38
common_reset
int64_t common_reset(void)
Definition: common.c:233
Generated on Fri Apr 28 2017 22:11:38 by   doxygen 1.8.14