1 /*
2 * Library metadata_header type test program
3 *
4 * Copyright (C) 2011-2021, Joachim Metz <joachim.metz@gmail.com>
5 *
6 * Refer to AUTHORS for acknowledgements.
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program 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
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this program. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <common.h>
23 #include <byte_stream.h>
24 #include <file_stream.h>
25 #include <types.h>
26
27 #if defined( HAVE_STDLIB_H ) || defined( WINAPI )
28 #include <stdlib.h>
29 #endif
30
31 #include "bde_test_functions.h"
32 #include "bde_test_libbde.h"
33 #include "bde_test_libcerror.h"
34 #include "bde_test_macros.h"
35 #include "bde_test_memory.h"
36 #include "bde_test_unused.h"
37
38 #include "../libbde/libbde_metadata_header.h"
39
40 uint8_t bde_test_metadata_header_data1[ 48 ] = {
41 0xa8, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0xa8, 0x02, 0x00, 0x00,
42 0x03, 0x0d, 0x59, 0x3a, 0x5e, 0x5c, 0xe1, 0x4b, 0x90, 0xb0, 0x37, 0xaf, 0x00, 0x83, 0x2e, 0xcf,
43 0x08, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0xd7, 0x98, 0xc0, 0x54, 0x5b, 0x53, 0xcc, 0x01 };
44
45 #if defined( __GNUC__ ) && !defined( LIBBDE_DLL_IMPORT )
46
47 /* Tests the libbde_metadata_header_initialize function
48 * Returns 1 if successful or 0 if not
49 */
bde_test_metadata_header_initialize(void)50 int bde_test_metadata_header_initialize(
51 void )
52 {
53 libbde_metadata_header_t *metadata_header = NULL;
54 libcerror_error_t *error = NULL;
55 int result = 0;
56
57 #if defined( HAVE_BDE_TEST_MEMORY )
58 int number_of_malloc_fail_tests = 1;
59 int number_of_memset_fail_tests = 1;
60 int test_number = 0;
61 #endif
62
63 /* Test regular cases
64 */
65 result = libbde_metadata_header_initialize(
66 &metadata_header,
67 &error );
68
69 BDE_TEST_ASSERT_EQUAL_INT(
70 "result",
71 result,
72 1 );
73
74 BDE_TEST_ASSERT_IS_NOT_NULL(
75 "metadata_header",
76 metadata_header );
77
78 BDE_TEST_ASSERT_IS_NULL(
79 "error",
80 error );
81
82 result = libbde_metadata_header_free(
83 &metadata_header,
84 &error );
85
86 BDE_TEST_ASSERT_EQUAL_INT(
87 "result",
88 result,
89 1 );
90
91 BDE_TEST_ASSERT_IS_NULL(
92 "metadata_header",
93 metadata_header );
94
95 BDE_TEST_ASSERT_IS_NULL(
96 "error",
97 error );
98
99 /* Test error cases
100 */
101 result = libbde_metadata_header_initialize(
102 NULL,
103 &error );
104
105 BDE_TEST_ASSERT_EQUAL_INT(
106 "result",
107 result,
108 -1 );
109
110 BDE_TEST_ASSERT_IS_NOT_NULL(
111 "error",
112 error );
113
114 libcerror_error_free(
115 &error );
116
117 metadata_header = (libbde_metadata_header_t *) 0x12345678UL;
118
119 result = libbde_metadata_header_initialize(
120 &metadata_header,
121 &error );
122
123 metadata_header = NULL;
124
125 BDE_TEST_ASSERT_EQUAL_INT(
126 "result",
127 result,
128 -1 );
129
130 BDE_TEST_ASSERT_IS_NOT_NULL(
131 "error",
132 error );
133
134 libcerror_error_free(
135 &error );
136
137 #if defined( HAVE_BDE_TEST_MEMORY )
138
139 for( test_number = 0;
140 test_number < number_of_malloc_fail_tests;
141 test_number++ )
142 {
143 /* Test libbde_metadata_header_initialize with malloc failing
144 */
145 bde_test_malloc_attempts_before_fail = test_number;
146
147 result = libbde_metadata_header_initialize(
148 &metadata_header,
149 &error );
150
151 if( bde_test_malloc_attempts_before_fail != -1 )
152 {
153 bde_test_malloc_attempts_before_fail = -1;
154
155 if( metadata_header != NULL )
156 {
157 libbde_metadata_header_free(
158 &metadata_header,
159 NULL );
160 }
161 }
162 else
163 {
164 BDE_TEST_ASSERT_EQUAL_INT(
165 "result",
166 result,
167 -1 );
168
169 BDE_TEST_ASSERT_IS_NULL(
170 "metadata_header",
171 metadata_header );
172
173 BDE_TEST_ASSERT_IS_NOT_NULL(
174 "error",
175 error );
176
177 libcerror_error_free(
178 &error );
179 }
180 }
181 for( test_number = 0;
182 test_number < number_of_memset_fail_tests;
183 test_number++ )
184 {
185 /* Test libbde_metadata_header_initialize with memset failing
186 */
187 bde_test_memset_attempts_before_fail = test_number;
188
189 result = libbde_metadata_header_initialize(
190 &metadata_header,
191 &error );
192
193 if( bde_test_memset_attempts_before_fail != -1 )
194 {
195 bde_test_memset_attempts_before_fail = -1;
196
197 if( metadata_header != NULL )
198 {
199 libbde_metadata_header_free(
200 &metadata_header,
201 NULL );
202 }
203 }
204 else
205 {
206 BDE_TEST_ASSERT_EQUAL_INT(
207 "result",
208 result,
209 -1 );
210
211 BDE_TEST_ASSERT_IS_NULL(
212 "metadata_header",
213 metadata_header );
214
215 BDE_TEST_ASSERT_IS_NOT_NULL(
216 "error",
217 error );
218
219 libcerror_error_free(
220 &error );
221 }
222 }
223 #endif /* defined( HAVE_BDE_TEST_MEMORY ) */
224
225 return( 1 );
226
227 on_error:
228 if( error != NULL )
229 {
230 libcerror_error_free(
231 &error );
232 }
233 if( metadata_header != NULL )
234 {
235 libbde_metadata_header_free(
236 &metadata_header,
237 NULL );
238 }
239 return( 0 );
240 }
241
242 /* Tests the libbde_metadata_header_free function
243 * Returns 1 if successful or 0 if not
244 */
bde_test_metadata_header_free(void)245 int bde_test_metadata_header_free(
246 void )
247 {
248 libcerror_error_t *error = NULL;
249 int result = 0;
250
251 /* Test error cases
252 */
253 result = libbde_metadata_header_free(
254 NULL,
255 &error );
256
257 BDE_TEST_ASSERT_EQUAL_INT(
258 "result",
259 result,
260 -1 );
261
262 BDE_TEST_ASSERT_IS_NOT_NULL(
263 "error",
264 error );
265
266 libcerror_error_free(
267 &error );
268
269 return( 1 );
270
271 on_error:
272 if( error != NULL )
273 {
274 libcerror_error_free(
275 &error );
276 }
277 return( 0 );
278 }
279
280 /* Tests the libbde_metadata_header_read_file_io_handle function
281 * Returns 1 if successful or 0 if not
282 */
bde_test_metadata_header_read_file_io_handle(void)283 int bde_test_metadata_header_read_file_io_handle(
284 void )
285 {
286 libbde_metadata_header_t *metadata_header = NULL;
287 libbfio_handle_t *file_io_handle = NULL;
288 libcerror_error_t *error = NULL;
289 int result = 0;
290
291 /* Initialize test
292 */
293 result = libbde_metadata_header_initialize(
294 &metadata_header,
295 &error );
296
297 BDE_TEST_ASSERT_EQUAL_INT(
298 "result",
299 result,
300 1 );
301
302 BDE_TEST_ASSERT_IS_NOT_NULL(
303 "metadata_header",
304 metadata_header );
305
306 BDE_TEST_ASSERT_IS_NULL(
307 "error",
308 error );
309
310 /* Initialize file IO handle
311 */
312 result = bde_test_open_file_io_handle(
313 &file_io_handle,
314 bde_test_metadata_header_data1,
315 48,
316 &error );
317
318 BDE_TEST_ASSERT_EQUAL_INT(
319 "result",
320 result,
321 1 );
322
323 BDE_TEST_ASSERT_IS_NOT_NULL(
324 "file_io_handle",
325 file_io_handle );
326
327 BDE_TEST_ASSERT_IS_NULL(
328 "error",
329 error );
330
331 /* Test regular cases
332 */
333 result = libbde_metadata_header_read_file_io_handle(
334 metadata_header,
335 file_io_handle,
336 0,
337 &error );
338
339 BDE_TEST_ASSERT_EQUAL_INT(
340 "result",
341 result,
342 1 );
343
344 BDE_TEST_ASSERT_IS_NULL(
345 "error",
346 error );
347
348 /* Test error cases
349 */
350 result = libbde_metadata_header_read_file_io_handle(
351 NULL,
352 file_io_handle,
353 0,
354 &error );
355
356 BDE_TEST_ASSERT_EQUAL_INT(
357 "result",
358 result,
359 -1 );
360
361 BDE_TEST_ASSERT_IS_NOT_NULL(
362 "error",
363 error );
364
365 libcerror_error_free(
366 &error );
367
368 result = libbde_metadata_header_read_file_io_handle(
369 metadata_header,
370 NULL,
371 0,
372 &error );
373
374 BDE_TEST_ASSERT_EQUAL_INT(
375 "result",
376 result,
377 -1 );
378
379 BDE_TEST_ASSERT_IS_NOT_NULL(
380 "error",
381 error );
382
383 libcerror_error_free(
384 &error );
385
386 /* Clean up file IO handle
387 */
388 result = bde_test_close_file_io_handle(
389 &file_io_handle,
390 &error );
391
392 BDE_TEST_ASSERT_EQUAL_INT(
393 "result",
394 result,
395 0 );
396
397 BDE_TEST_ASSERT_IS_NULL(
398 "error",
399 error );
400
401 /* Test data too small
402 */
403 result = bde_test_open_file_io_handle(
404 &file_io_handle,
405 bde_test_metadata_header_data1,
406 8,
407 &error );
408
409 BDE_TEST_ASSERT_EQUAL_INT(
410 "result",
411 result,
412 1 );
413
414 BDE_TEST_ASSERT_IS_NOT_NULL(
415 "file_io_handle",
416 file_io_handle );
417
418 BDE_TEST_ASSERT_IS_NULL(
419 "error",
420 error );
421
422 result = libbde_metadata_header_read_file_io_handle(
423 metadata_header,
424 file_io_handle,
425 0,
426 &error );
427
428 BDE_TEST_ASSERT_EQUAL_INT(
429 "result",
430 result,
431 -1 );
432
433 BDE_TEST_ASSERT_IS_NOT_NULL(
434 "error",
435 error );
436
437 libcerror_error_free(
438 &error );
439
440 result = bde_test_close_file_io_handle(
441 &file_io_handle,
442 &error );
443
444 BDE_TEST_ASSERT_EQUAL_INT(
445 "result",
446 result,
447 0 );
448
449 BDE_TEST_ASSERT_IS_NULL(
450 "error",
451 error );
452
453 /* Test invalid format version
454 */
455 result = bde_test_open_file_io_handle(
456 &file_io_handle,
457 bde_test_metadata_header_data1,
458 48,
459 &error );
460
461 BDE_TEST_ASSERT_EQUAL_INT(
462 "result",
463 result,
464 1 );
465
466 BDE_TEST_ASSERT_IS_NOT_NULL(
467 "file_io_handle",
468 file_io_handle );
469
470 BDE_TEST_ASSERT_IS_NULL(
471 "error",
472 error );
473
474 byte_stream_copy_from_uint32_little_endian(
475 &( bde_test_metadata_header_data1[ 4 ] ),
476 0xffffffffUL );
477
478 result = libbde_metadata_header_read_file_io_handle(
479 metadata_header,
480 file_io_handle,
481 0,
482 &error );
483
484 byte_stream_copy_from_uint32_little_endian(
485 &( bde_test_metadata_header_data1[ 4 ] ),
486 0x00000001UL );
487
488 BDE_TEST_ASSERT_EQUAL_INT(
489 "result",
490 result,
491 -1 );
492
493 BDE_TEST_ASSERT_IS_NOT_NULL(
494 "error",
495 error );
496
497 libcerror_error_free(
498 &error );
499
500 result = bde_test_close_file_io_handle(
501 &file_io_handle,
502 &error );
503
504 BDE_TEST_ASSERT_EQUAL_INT(
505 "result",
506 result,
507 0 );
508
509 BDE_TEST_ASSERT_IS_NULL(
510 "error",
511 error );
512
513 /* Clean up
514 */
515 result = libbde_metadata_header_free(
516 &metadata_header,
517 &error );
518
519 BDE_TEST_ASSERT_EQUAL_INT(
520 "result",
521 result,
522 1 );
523
524 BDE_TEST_ASSERT_IS_NULL(
525 "metadata_header",
526 metadata_header );
527
528 BDE_TEST_ASSERT_IS_NULL(
529 "error",
530 error );
531
532 return( 1 );
533
534 on_error:
535 if( error != NULL )
536 {
537 libcerror_error_free(
538 &error );
539 }
540 if( file_io_handle != NULL )
541 {
542 libbfio_handle_free(
543 &file_io_handle,
544 NULL );
545 }
546 if( metadata_header != NULL )
547 {
548 libbde_metadata_header_free(
549 &metadata_header,
550 NULL );
551 }
552 return( 0 );
553 }
554
555 /* Tests the libbde_metadata_header_read_data function
556 * Returns 1 if successful or 0 if not
557 */
bde_test_metadata_header_read_data(void)558 int bde_test_metadata_header_read_data(
559 void )
560 {
561 libbde_metadata_header_t *metadata_header = NULL;
562 libcerror_error_t *error = NULL;
563 int result = 0;
564
565 /* Initialize test
566 */
567 result = libbde_metadata_header_initialize(
568 &metadata_header,
569 &error );
570
571 BDE_TEST_ASSERT_EQUAL_INT(
572 "result",
573 result,
574 1 );
575
576 BDE_TEST_ASSERT_IS_NOT_NULL(
577 "metadata_header",
578 metadata_header );
579
580 BDE_TEST_ASSERT_IS_NULL(
581 "error",
582 error );
583
584 /* Test regular cases
585 */
586 result = libbde_metadata_header_read_data(
587 metadata_header,
588 bde_test_metadata_header_data1,
589 48,
590 &error );
591
592 BDE_TEST_ASSERT_EQUAL_INT(
593 "result",
594 result,
595 1 );
596
597 BDE_TEST_ASSERT_IS_NULL(
598 "error",
599 error );
600
601 /* Test error cases
602 */
603 result = libbde_metadata_header_read_data(
604 NULL,
605 bde_test_metadata_header_data1,
606 48,
607 &error );
608
609 BDE_TEST_ASSERT_EQUAL_INT(
610 "result",
611 result,
612 -1 );
613
614 BDE_TEST_ASSERT_IS_NOT_NULL(
615 "error",
616 error );
617
618 libcerror_error_free(
619 &error );
620
621 result = libbde_metadata_header_read_data(
622 metadata_header,
623 NULL,
624 48,
625 &error );
626
627 BDE_TEST_ASSERT_EQUAL_INT(
628 "result",
629 result,
630 -1 );
631
632 BDE_TEST_ASSERT_IS_NOT_NULL(
633 "error",
634 error );
635
636 libcerror_error_free(
637 &error );
638
639 result = libbde_metadata_header_read_data(
640 metadata_header,
641 bde_test_metadata_header_data1,
642 0,
643 &error );
644
645 BDE_TEST_ASSERT_EQUAL_INT(
646 "result",
647 result,
648 -1 );
649
650 BDE_TEST_ASSERT_IS_NOT_NULL(
651 "error",
652 error );
653
654 libcerror_error_free(
655 &error );
656
657 result = libbde_metadata_header_read_data(
658 metadata_header,
659 bde_test_metadata_header_data1,
660 (size_t) SSIZE_MAX + 1,
661 &error );
662
663 BDE_TEST_ASSERT_EQUAL_INT(
664 "result",
665 result,
666 -1 );
667
668 BDE_TEST_ASSERT_IS_NOT_NULL(
669 "error",
670 error );
671
672 libcerror_error_free(
673 &error );
674
675 #if defined( HAVE_BDE_TEST_MEMORY )
676
677 /* Test bde_test_metadata_header_read_data with memcpy failing
678 */
679 bde_test_memcpy_attempts_before_fail = 0;
680
681 result = libbde_metadata_header_read_data(
682 metadata_header,
683 bde_test_metadata_header_data1,
684 48,
685 &error );
686
687 if( bde_test_memcpy_attempts_before_fail != -1 )
688 {
689 bde_test_memcpy_attempts_before_fail = -1;
690 }
691 else
692 {
693 BDE_TEST_ASSERT_EQUAL_INT(
694 "result",
695 result,
696 -1 );
697
698 BDE_TEST_ASSERT_IS_NOT_NULL(
699 "error",
700 error );
701
702 libcerror_error_free(
703 &error );
704 }
705 #endif /* defined( HAVE_BDE_TEST_MEMORY ) */
706
707 /* Test invalid format version
708 */
709 byte_stream_copy_from_uint32_little_endian(
710 &( bde_test_metadata_header_data1[ 4 ] ),
711 0xffffffffUL );
712
713 result = libbde_metadata_header_read_data(
714 metadata_header,
715 bde_test_metadata_header_data1,
716 48,
717 &error );
718
719 byte_stream_copy_from_uint32_little_endian(
720 &( bde_test_metadata_header_data1[ 4 ] ),
721 0x00000001UL );
722
723 BDE_TEST_ASSERT_EQUAL_INT(
724 "result",
725 result,
726 -1 );
727
728 BDE_TEST_ASSERT_IS_NOT_NULL(
729 "error",
730 error );
731
732 libcerror_error_free(
733 &error );
734
735 /* Test invalid header size
736 */
737 byte_stream_copy_from_uint32_little_endian(
738 &( bde_test_metadata_header_data1[ 8 ] ),
739 0xffffffffUL );
740
741 result = libbde_metadata_header_read_data(
742 metadata_header,
743 bde_test_metadata_header_data1,
744 48,
745 &error );
746
747 byte_stream_copy_from_uint32_little_endian(
748 &( bde_test_metadata_header_data1[ 8 ] ),
749 0x00000030UL );
750
751 BDE_TEST_ASSERT_EQUAL_INT(
752 "result",
753 result,
754 -1 );
755
756 BDE_TEST_ASSERT_IS_NOT_NULL(
757 "error",
758 error );
759
760 libcerror_error_free(
761 &error );
762
763 /* Test metadata size and copy mismatch
764 */
765 byte_stream_copy_from_uint32_little_endian(
766 &( bde_test_metadata_header_data1[ 12 ] ),
767 0xffffffffUL );
768
769 result = libbde_metadata_header_read_data(
770 metadata_header,
771 bde_test_metadata_header_data1,
772 48,
773 &error );
774
775 byte_stream_copy_from_uint32_little_endian(
776 &( bde_test_metadata_header_data1[ 12 ] ),
777 0x000002a8UL );
778
779 BDE_TEST_ASSERT_EQUAL_INT(
780 "result",
781 result,
782 -1 );
783
784 BDE_TEST_ASSERT_IS_NOT_NULL(
785 "error",
786 error );
787
788 libcerror_error_free(
789 &error );
790
791 /* Clean up
792 */
793 result = libbde_metadata_header_free(
794 &metadata_header,
795 &error );
796
797 BDE_TEST_ASSERT_EQUAL_INT(
798 "result",
799 result,
800 1 );
801
802 BDE_TEST_ASSERT_IS_NULL(
803 "metadata_header",
804 metadata_header );
805
806 BDE_TEST_ASSERT_IS_NULL(
807 "error",
808 error );
809
810 return( 1 );
811
812 on_error:
813 if( error != NULL )
814 {
815 libcerror_error_free(
816 &error );
817 }
818 if( metadata_header != NULL )
819 {
820 libbde_metadata_header_free(
821 &metadata_header,
822 NULL );
823 }
824 return( 0 );
825 }
826
827 #endif /* defined( __GNUC__ ) && !defined( LIBBDE_DLL_IMPORT ) */
828
829 /* The main program
830 */
831 #if defined( HAVE_WIDE_SYSTEM_CHARACTER )
wmain(int argc BDE_TEST_ATTRIBUTE_UNUSED,wchar_t * const argv[]BDE_TEST_ATTRIBUTE_UNUSED)832 int wmain(
833 int argc BDE_TEST_ATTRIBUTE_UNUSED,
834 wchar_t * const argv[] BDE_TEST_ATTRIBUTE_UNUSED )
835 #else
836 int main(
837 int argc BDE_TEST_ATTRIBUTE_UNUSED,
838 char * const argv[] BDE_TEST_ATTRIBUTE_UNUSED )
839 #endif
840 {
841 BDE_TEST_UNREFERENCED_PARAMETER( argc )
842 BDE_TEST_UNREFERENCED_PARAMETER( argv )
843
844 #if defined( __GNUC__ ) && !defined( LIBBDE_DLL_IMPORT )
845
846 BDE_TEST_RUN(
847 "libbde_metadata_header_initialize",
848 bde_test_metadata_header_initialize );
849
850 BDE_TEST_RUN(
851 "libbde_metadata_header_free",
852 bde_test_metadata_header_free );
853
854 BDE_TEST_RUN(
855 "libbde_metadata_header_read_file_io_handle",
856 bde_test_metadata_header_read_file_io_handle );
857
858 BDE_TEST_RUN(
859 "libbde_metadata_header_read_data",
860 bde_test_metadata_header_read_data );
861
862 #endif /* defined( __GNUC__ ) && !defined( LIBBDE_DLL_IMPORT ) */
863
864 return( EXIT_SUCCESS );
865
866 #if defined( __GNUC__ ) && !defined( LIBBDE_DLL_IMPORT )
867
868 on_error:
869 return( EXIT_FAILURE );
870
871 #endif /* defined( __GNUC__ ) && !defined( LIBBDE_DLL_IMPORT ) */
872 }
873
874