forked from Vector35/binaryninja-api
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathtestcommon.py
2306 lines (1986 loc) · 121 KB
/
testcommon.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
import tempfile
import os
import sys
import zipfile
import inspect
from platform import system
import binaryninja as binja
from binaryninja.binaryview import BinaryViewType, BinaryView
from binaryninja.filemetadata import FileMetadata
from binaryninja.datarender import DataRenderer
from binaryninja.function import InstructionTextToken, DisassemblyTextLine
from binaryninja.enums import InstructionTextTokenType, FindFlag,\
FunctionGraphType, NamedTypeReferenceClass, ReferenceType, SegmentFlag, SectionSemantics
from binaryninja.types import (Type, BoolWithConfidence, EnumerationBuilder, NamedTypeReferenceBuilder
EnumerationBuilder, NamedTypeReferenceBuilder)
import subprocess
import re
# Alright so this one is here for Binja functions that output <in set([blah, blah, blah])>
def fixSet(string):
# Apply regular expression
splitList = (re.split(r"((?<=<in set\(\[).*(?=\]\)>))", string))
if len(splitList) > 1:
return splitList[0] + ', '.join(sorted(splitList[1].split(', '))) + splitList[2]
else:
return string
def fixStrRepr(string):
# Python 2 and Python 3 represent Unicode character reprs differently
return string.replace(b"\xe2\x80\xa6".decode("utf8"), "\\xe2\\x80\\xa6")
def get_file_list(test_store_rel):
test_store = os.path.join(os.path.dirname(__file__), test_store_rel)
all_files = []
for root, _, files in os.walk(test_store):
for file in files:
all_files.append(os.path.join(root, file))
return all_files
def remove_low_confidence(type_string):
low_confidence_types = ["int32_t", "void"]
for lct in low_confidence_types:
type_string = type_string.replace(lct + " ", '') # done to resolve confidence ties
return type_string
class Builder(object):
def __init__(self, test_store):
self.test_store = test_store
# binja.log.log_to_stdout(binja.LogLevel.DebugLog) # Uncomment for more info
def methods(self):
methodnames = []
for methodname, _ in inspect.getmembers(self, predicate=inspect.ismethod):
if methodname.startswith("test_"):
methodnames.append(methodname)
return methodnames
def unpackage_file(self, filename):
path = os.path.join(os.path.dirname(__file__), self.test_store, filename)
if not os.path.exists(path):
with zipfile.ZipFile(path + ".zip", "r") as zf:
zf.extractall(path = os.path.dirname(__file__))
assert os.path.exists(path)
return os.path.relpath(path)
def delete_package(self, filename):
path = os.path.join(os.path.dirname(__file__), self.test_store, filename)
os.unlink(path)
class BinaryViewTestBuilder(Builder):
""" The BinaryViewTestBuilder is for test that are verified against a binary.
The tests are first run on your dev machine to base line then run again
on the build machine to verify they are correct.
- Function that are tests should start with 'test_'
- Function doc string used as 'on error' message
- Should return: list of strings
"""
def __init__(self, filename, options=None):
self.filename = os.path.join(os.path.dirname(__file__), filename)
_bv = binja.load(self.filename, options=options)
assert _bv is not None, f"{filename} is not an executable format"
self.bv = _bv
@classmethod
def get_root_directory(cls):
return os.path.dirname(__file__)
def test_available_types(self):
"""Available types don't match"""
bv = BinaryView(FileMetadata()).open(self.filename)
assert bv is not None
return ["Available Type: " + x.name for x in bv.available_view_types]
def test_function_starts(self):
"""Function starts list doesn't match"""
result = []
for x in self.bv.functions:
result.append("Function start: " + hex(x.start))
return result
def test_function_symbol_names(self):
"""Function.symbol.name list doesnt' match"""
result = []
for x in self.bv.functions:
result.append("Symbol: " + x.symbol.name + ' ' + str(x.symbol.type) + ' ' + hex(x.symbol.address) + ' ' + str(x.symbol.namespace))
return result
def test_function_can_return(self):
"""Function.can_return list doesn't match"""
result = []
for x in self.bv.functions:
result.append("function name: " + x.symbol.name + ' type: ' + str(x.symbol.type) + ' address: ' + hex(x.symbol.address) + ' can_return: ' + str(bool(x.can_return)))
return result
def test_function_basic_blocks(self):
"""Function basic_block list doesn't match (start, end, has_undetermined_outgoing_edges)"""
bblist = []
for func in self.bv.functions:
for bb in func.basic_blocks:
bblist.append(f"basic block {bb} start: {bb.start:#x} end: {bb.end:#x} undetermined outgoing edges: {bb.has_undetermined_outgoing_edges} incoming edges: {bb.incoming_edges} outgoing edges: {bb.outgoing_edges}")
for anno in func.get_block_annotations(bb.start):
bblist.append(f"basic block {bb} function annotation: {anno}")
bblist.append(f"basic block {bb} test get self: {func.get_basic_block_at(bb.start)}")
return bblist
def test_function_low_il_basic_blocks(self):
"""Function low_il_basic_block list doesn't match"""
ilbblist = []
for func in self.bv.functions:
for bb in func.low_level_il.basic_blocks:
ilbblist.append("LLIL basic block {} start: ".format(str(bb)) + hex(bb.start) + ' end: ' + hex(bb.end) + ' outgoing edges: ' + str(len(bb.outgoing_edges)))
return ilbblist
def test_function_med_il_basic_blocks(self):
"""Function med_il_basic_block list doesn't match"""
ilbblist = []
for func in self.bv.functions:
for bb in func.mlil.basic_blocks:
ilbblist.append("MLIL basic block {} start: ".format(str(bb)) + hex(bb.start) + ' end: ' + hex(bb.end) + ' outgoing_edges: ' + str(len(bb.outgoing_edges)))
return ilbblist
def test_symbols(self):
"""Symbols list doesn't match"""
return ["Symbol: " + str(i) for i in sorted(self.bv.symbols)]
def test_symbol_namespaces(self):
"""Symbol namespaces don't match"""
return self.bv.namespaces
def test_internal_external_namespaces(self):
"""Symbol namespaces don't match"""
return [BinaryView.internal_namespace(), BinaryView.external_namespace()]
def test_strings(self):
"""Strings list doesn't match"""
return ["String: " + str(x.value) + ' type: ' + str(x.type) + ' at: ' + hex(x.start) for x in self.bv.strings]
def test_low_il_instructions(self):
"""LLIL instructions produced different output"""
retinfo = []
for func in self.bv.functions:
for bb in func.low_level_il.basic_blocks:
for ins in bb:
retinfo.append("Function: {:x} Instruction: {:x} ADDR->LiftedILS: {}".format(func.start, ins.address, str(sorted(list(map(str, func.get_lifted_ils_at(ins.address)))))))
retinfo.append("Function: {:x} Instruction: {:x} ADDR->LLILS: {}".format(func.start, ins.address, str(sorted(list(map(str, func.get_llils_at(ins.address)))))))
retinfo.append("Function: {:x} Instruction: {:x} LLIL->MLIL: {}".format(func.start, ins.address, str(ins.mlil)))
retinfo.append("Function: {:x} Instruction: {:x} LLIL->MLILS: {}".format(func.start, ins.address, str(sorted(list(map(str, ins.mlils))))))
retinfo.append("Function: {:x} Instruction: {:x} LLIL->HLIL: {}".format(func.start, ins.address, str(ins.hlil)))
retinfo.append("Function: {:x} Instruction: {:x} LLIL->HLILS: {}".format(func.start, ins.address, str(sorted(list(map(str, ins.hlils))))))
retinfo.append("Function: {:x} Instruction: {:x} Mapped MLIL: {}".format(func.start, ins.address, str(ins.mapped_medium_level_il)))
retinfo.append("Function: {:x} Instruction: {:x} Value: {}".format(func.start, ins.address, str(ins.value)))
retinfo.append("Function: {:x} Instruction: {:x} Possible Values: {}".format(func.start, ins.address, str(ins.possible_values)))
prefixList = []
for i in ins.prefix_operands:
if isinstance(i, dict):
contents = []
for j in sorted(i.keys()):
contents.append((j, i[j]))
prefixList.append(str(contents))
else:
prefixList.append(i)
retinfo.append("Function: {:x} Instruction: {:x} Prefix operands: {}".format(func.start, ins.address, fixStrRepr(str(prefixList))))
postfixList = []
for i in ins.postfix_operands:
if isinstance(i, dict):
contents = []
for j in sorted(i.keys()):
contents.append((j, i[j]))
postfixList.append(str(contents))
else:
postfixList.append(i)
retinfo.append("Function: {:x} Instruction: {:x} Postfix operands: {}".format(func.start, ins.address, fixStrRepr(str(postfixList))))
retinfo.append("Function: {:x} Instruction: {:x} SSA form: {}".format(func.start, ins.address, str(ins.ssa_form)))
retinfo.append("Function: {:x} Instruction: {:x} Non-SSA form: {}".format(func.start, ins.address, str(ins.non_ssa_form)))
return retinfo
def test_low_il_ssa(self):
"""LLIL ssa produced different output"""
retinfo = []
for func in self.bv.functions:
func = func.low_level_il
arch = self.bv.arch
assert arch is not None, "Architecture is None"
source_function = func.source_function
assert source_function is not None, "source_function is None"
for reg_name in sorted(arch.regs):
reg = binja.SSARegister(reg_name, 1)
retinfo.append("Function: {:x} Reg {} SSA definition: {}".format(source_function.start, reg_name, str(getattr(func.get_ssa_reg_definition(reg), 'instr_index', None))))
retinfo.append("Function: {:x} Reg {} SSA uses: {}".format(source_function.start, reg_name, str(list(map(lambda instr: instr.instr_index, func.get_ssa_reg_uses(reg))))))
retinfo.append("Function: {:x} Reg {} SSA value: {}".format(source_function.start, reg_name, str(func.get_ssa_reg_value(reg))))
for flag_name in sorted(arch.flags):
flag = binja.SSAFlag(flag_name, 1)
retinfo.append("Function: {:x} Flag {} SSA uses: {}".format(source_function.start, flag_name, str(list(map(lambda instr: instr.instr_index, func.get_ssa_flag_uses(flag))))))
retinfo.append("Function: {:x} Flag {} SSA value: {}".format(source_function.start, flag_name, str(func.get_ssa_flag_value(flag))))
for bb in func.basic_blocks:
for ins in bb:
tempind = func.get_non_ssa_instruction_index(ins.instr_index)
retinfo.append("Function: {:x} Instruction: {:x} Non-SSA instruction index: {}".format(source_function.start, ins.address, str(tempind)))
retinfo.append("Function: {:x} Instruction: {:x} SSA instruction index: {}".format(source_function.start, ins.address, str(func.get_ssa_instruction_index(tempind))))
retinfo.append("Function: {:x} Instruction: {:x} MLIL instruction index: {}".format(source_function.start, ins.address, str(func.get_medium_level_il_instruction_index(ins.instr_index))))
retinfo.append("Function: {:x} Instruction: {:x} Mapped MLIL instruction index: {}".format(source_function.start, ins.address, str(func.get_mapped_medium_level_il_instruction_index(ins.instr_index))))
retinfo.append("Function: {:x} Instruction: {:x} LLIL_SSA->MLIL: {}".format(source_function.start, ins.address, str(ins.mlil)))
retinfo.append("Function: {:x} Instruction: {:x} LLIL_SSA->MLILS: {}".format(source_function.start, ins.address, str(sorted(list(map(str, ins.mlils))))))
retinfo.append("Function: {:x} Instruction: {:x} LLIL_SSA->HLIL: {}".format(source_function.start, ins.address, str(ins.hlil)))
retinfo.append("Function: {:x} Instruction: {:x} LLIL_SSA->HLILS: {}".format(source_function.start, ins.address, str(sorted(list(map(str, ins.hlils))))))
return retinfo
def test_med_il_instructions(self):
"""MLIL instructions produced different output"""
retinfo = []
for func in self.bv.functions:
for bb in func.mlil.basic_blocks:
for ins in bb:
retinfo.append("Function: {:x} Instruction: {:x} Expression type: {}".format(func.start, ins.address, str(ins.expr_type)))
retinfo.append("Function: {:x} Instruction: {:x} MLIL->LLIL: {}".format(func.start, ins.address, str(ins.llil)))
retinfo.append("Function: {:x} Instruction: {:x} MLIL->LLILS: {}".format(func.start, ins.address, str(sorted(list(map(str, ins.llils))))))
retinfo.append("Function: {:x} Instruction: {:x} MLIL->HLIL: {}".format(func.start, ins.address, str(ins.hlil)))
retinfo.append("Function: {:x} Instruction: {:x} MLIL->HLILS: {}".format(func.start, ins.address, str(sorted(list(map(str, ins.hlils))))))
retinfo.append("Function: {:x} Instruction: {:x} Value: {}".format(func.start, ins.address, str(ins.value)))
retinfo.append("Function: {:x} Instruction: {:x} Possible values: {}".format(func.start, ins.address, str(ins.possible_values)))
retinfo.append("Function: {:x} Instruction: {:x} Branch dependence: {}".format(func.start, ins.address, str(sorted(ins.branch_dependence.items()))))
prefixList = []
for i in ins.prefix_operands:
if isinstance(i, float) and 'e' in str(i):
prefixList.append(str(round(i, 21)))
elif isinstance(i, float):
prefixList.append(str(round(i, 11)))
elif isinstance(i, dict):
contents = []
for j in sorted(i.keys()):
contents.append((j, i[j]))
prefixList.append(str(contents))
else:
prefixList.append(str(i))
retinfo.append("Function: {:x} Instruction: {:x} Prefix operands: {}".format(func.start, ins.address, fixStrRepr(str(sorted(prefixList)))))
postfixList = []
for i in ins.postfix_operands:
if isinstance(i, float) and 'e' in str(i):
postfixList.append(str(round(i, 21)))
elif isinstance(i, float):
postfixList.append(str(round(i, 11)))
elif isinstance(i, dict):
contents = []
for j in sorted(i.keys()):
contents.append((j, i[j]))
postfixList.append(str(contents))
else:
postfixList.append(str(i))
retinfo.append("Function: {:x} Instruction: {:x} Postfix operands: {}".format(func.start, ins.address, fixStrRepr(str(sorted(postfixList)))))
retinfo.append("Function: {:x} Instruction: {:x} SSA form: {}".format(func.start, ins.address, str(ins.ssa_form)))
retinfo.append("Function: {:x} Instruction: {:x} Non-SSA form: {}".format(func.start, ins.address, str(ins.non_ssa_form)))
return retinfo
def test_med_il_vars(self):
"""Function med_il_vars doesn't match"""
varlist = []
for func in self.bv.functions:
func = func.mlil
for bb in func.basic_blocks:
for instruction in bb:
instruction = instruction.ssa_form
for var in (instruction.vars_read + instruction.vars_written):
if hasattr(var, "var"):
varlist.append(f"Function: {func.source_function.start:x} Instruction {instruction.address:x} SSA var definition: {getattr(func.get_ssa_var_definition(var), 'instr_index', None)}")
varlist.append(f"Function: {func.source_function.start:x} Instruction {instruction.address:x} SSA var uses: {list(map(lambda instr: instr.instr_index, func.get_ssa_var_uses(var)))}")
varlist.append(f"Function: {func.source_function.start:x} Instruction {instruction.address:x} SSA var value: {func.get_ssa_var_value(var)}")
varlist.append(f"Function: {func.source_function.start:x} Instruction {instruction.address:x} SSA var possible values: {fixSet(str(instruction.get_ssa_var_possible_values(var)))}")
varlist.append(f"Function: {func.source_function.start:x} Instruction {instruction.address:x} SSA var version: {instruction.get_ssa_var_version(var.var)}")
return varlist
def test_function_stack(self):
"""Function stack produced different output"""
funcinfo = []
for func in self.bv.functions:
for i, var in enumerate(func.stack_layout):
funcinfo.append(f"Function: {func.start:x} Stack position {i}: {var}")
funcinfo.append(f"Function: {func.start:x} Stack adjustment: {func.stack_adjustment.value}")
funcinfo.append(f"Function: {func.start:x} Register stack adjustment: {[v.value for v in func.reg_stack_adjustments.values()]}")
func.stack_adjustment = func.stack_adjustment
func.reg_stack_adjustments = func.reg_stack_adjustments
func.create_user_stack_var(0, binja.Type.int(4), "testuservar")
# The following test has been commented as it leads to non-deterministic test results
# This is likely due to an extra update coming along afterward and removing sometimes
# This test would need to be conducted in an analysis pass to be consistent and accurate
# func.create_auto_stack_var(4, binja.Type.int(4), "testautovar")
funcinfo.append(f"Function: {func.start:x} Stack content sample: {func.get_stack_contents_at(func.start + 0x10, 0, 0x10)}")
funcinfo.append(f"Function: {func.start:x} Stack content range sample: {func.get_stack_contents_after(func.start + 0x10, 0, 0x10)}")
funcinfo.append(f"Function: {func.start:x} Sample stack var: {func.get_stack_var_at_frame_offset(0, 0)}")
func.delete_user_stack_var(0)
func.delete_auto_stack_var(0)
return funcinfo
def test_function_llil(self):
"""Function LLIL produced different output"""
retinfo = []
for func in self.bv.functions:
for llil_bb in func.llil_basic_blocks:
retinfo.append(f"Function: {func.start:x} LLIL basic block: {llil_bb}")
for llil_ins in func.llil.instructions:
retinfo.append(f"Function: {func.start:x} Instruction: {llil_ins.address:x} LLIL instruction: {llil_ins}")
for mlil_bb in func.mlil_basic_blocks:
retinfo.append(f"Function: {func.start:x} MLIL basic block: {mlil_bb}")
for mlil_ins in func.mlil.instructions:
retinfo.append(f"Function: {func.start:x} Instruction: {mlil_ins.address:x} MLIL instruction: {mlil_ins}")
for hlil_ins in func.hlil.instructions:
retinfo.append(f"Function: {func.start:x} Instruction: {hlil_ins.address:x} HLIL instruction: {hlil_ins}")
for ins in func.instructions:
retinfo.append(f"Function: {func.start:x} Instruction: {ins[1]:#x}: {''.join([str(i) for i in ins[0]])}")
return retinfo
def test_function_hlil(self):
"""Function HLIL produced different output"""
retinfo = []
for func in self.bv.functions:
if func.hlil is None or func.hlil.root is None:
continue
for line in func.hlil.root.lines:
retinfo.append(f"Function: {func.start:x} HLIL line: {line}")
for hlilins in func.hlil.instructions:
retinfo.append(f"Function: {func.start:x} Instruction: {hlilins.address:x} HLIL->LLIL instruction: {str(hlilins.llil)}")
retinfo.append(f"Function: {func.start:x} Instruction: {hlilins.address:x} HLIL->MLIL instruction: {str(hlilins.mlil)}")
retinfo.append(f"Function: {func.start:x} Instruction: {hlilins.address:x} HLIL->MLILS instruction: {str(sorted(list(map(str, hlilins.mlils))))}")
return retinfo
def test_function_type(self):
"""Function types don't match"""
retinfo = []
for func in self.bv.functions:
if func.hlil is None or func.hlil.root is None:
continue
retinfo.append(f"Function: {func.start:x} Type: {func.function_type}")
return retinfo
def test_functions_attributes(self):
"""Function attributes don't match"""
funcinfo = []
for func in self.bv.functions:
func.comment = "testcomment " + func.name
func.name = func.name
func.can_return = func.can_return
func.function_type = func.function_type
func.return_type = func.return_type
func.return_regs = func.return_regs
func.calling_convention = func.calling_convention
func.parameter_vars = func.parameter_vars
func.has_variable_arguments = func.has_variable_arguments
func.analysis_skipped = func.analysis_skipped
func.clobbered_regs = func.clobbered_regs
func.set_user_instr_highlight(func.start, binja.highlight.HighlightColor(red=0xff, blue=0xff, green=0))
func.set_auto_instr_highlight(func.start, binja.highlight.HighlightColor(red=0xff, blue=0xfe, green=0))
for var in func.vars:
funcinfo.append("Function {} var: ".format(func.name) + str(var))
for (arch, addr, tag) in func.address_tags:
funcinfo.append("Function {} tag at ({}, {:x}): ".format(func.name, arch.name, addr) + str(tag))
for tag in func.function_tags:
funcinfo.append("Function {} tag: ".format(func.name) + str(tag))
for branch in func.indirect_branches:
funcinfo.append("Function {} indirect branch: ".format(func.name) + str(branch))
funcinfo.append("Function {} session data: ".format(func.name) + str(func.session_data))
funcinfo.append("Function {} analysis perf length: ".format(func.name) + str(len(func.analysis_performance_info)))
for cr in func.clobbered_regs:
funcinfo.append("Function {} clobbered reg: ".format(func.name) + str(cr))
funcinfo.append("Function {} explicitly defined type: ".format(func.name) + str(func.explicitly_defined_type))
funcinfo.append("Function {} needs update: ".format(func.name) + str(func.needs_update))
funcinfo.append("Function {} global pointer value: ".format(func.name) + str(func.global_pointer_value))
funcinfo.append("Function {} comment: ".format(func.name) + str(func.comment))
funcinfo.append("Function {} too large: ".format(func.name) + str(func.too_large))
funcinfo.append("Function {} analysis skipped: ".format(func.name) + str(func.analysis_skipped))
funcinfo.append("Function {} first ins LLIL: ".format(func.name) + str(func.get_low_level_il_at(func.start)))
funcinfo.append("Function {} LLIL exit test: ".format(func.name) + str(func.get_low_level_il_exits_at(func.start+0x100)))
funcinfo.append("Function {} regs read test: ".format(func.name) + str(func.get_regs_read_by(func.start)))
funcinfo.append("Function {} regs written test: ".format(func.name) + str(func.get_regs_written_by(func.start)))
funcinfo.append("Function {} stack var test: ".format(func.name) + str(func.get_stack_vars_referenced_by(func.start)))
funcinfo.append("Function {} constant reference test: ".format(func.name) + str(func.get_constants_referenced_by(func.start)))
funcinfo.append("Function {} first ins lifted IL: ".format(func.name) + str(func.get_lifted_il_at(func.start)))
funcinfo.append("Function {} flags read by lifted IL ins: ".format(func.name) + str(func.get_flags_read_by_lifted_il_instruction(0)))
funcinfo.append("Function {} flags written by lifted IL ins: ".format(func.name) + str(func.get_flags_written_by_lifted_il_instruction(0)))
funcinfo.append("Function {} create graph: ".format(func.name) + str(func.create_graph()))
funcinfo.append("Function {} indirect branches test: ".format(func.name) + str(func.get_indirect_branches_at(func.start+0x10)))
funcinfo.append("Function {} test instr highlight: ".format(func.name) + str(func.get_instr_highlight(func.start)))
for token in func.get_type_tokens():
token = str(token)
token = remove_low_confidence(token)
funcinfo.append("Function {} type token: ".format(func.name) + str(token))
return funcinfo
def test_BinaryView(self):
"""BinaryView produced different results"""
retinfo = []
for type in sorted([str(i) for i in self.bv.types.items()]):
retinfo.append(f"BV Type: {type}")
for segment in sorted([str(i) for i in self.bv.segments]):
retinfo.append(f"BV segment: {segment}")
for section in sorted(self.bv.sections):
retinfo.append(f"BV section: {section}")
for allrange in self.bv.allocated_ranges:
retinfo.append(f"BV allocated range: {allrange}")
retinfo.append(f"Session Data: {self.bv.session_data}")
for (addr, tag) in self.bv.data_tags:
retinfo.append(f"BV tag: {addr:x} {repr(tag)}")
for tag_type in self.bv.tag_types:
retinfo.append(f"BV tag type: {repr(tag_type)}")
vars = self.bv.data_vars
for addr in sorted(vars.keys()):
retinfo.append(f"BV data var: {vars[addr]}")
retinfo.append(f"BV Entry function: {repr(self.bv.entry_function)}")
for i in self.bv:
retinfo.append(f"BV function: {repr(i)}")
retinfo.append(f"BV entry point: {self.bv.entry_point:#x}")
retinfo.append(f"BV start: {self.bv.start:#x}")
retinfo.append(f"BV length: {len(self.bv):#x}")
return retinfo
def test_dominators(self):
"""Dominators don't match oracle"""
retinfo = []
for func in self.bv.functions:
for bb in func:
for dom in sorted(bb.dominators, key=lambda x: x.start):
retinfo.append("Dominator: %x of %x" % (dom.start, bb.start))
for pdom in sorted(bb.post_dominators, key=lambda x: x.start):
retinfo.append("PostDominator: %x of %x" % (pdom.start, bb.start))
return retinfo
def test_liveness(self):
"""Liveness results don't match oracle"""
retinfo1 = []
retinfo2 = []
for hlil in self.bv.hlil_functions():
vars = hlil.vars
hlil_ssa = hlil.ssa_form
ssa_vars = hlil_ssa.ssa_vars
name = hlil.source_function.name
for instr_index in range(0, len(hlil)):
for var in vars:
retinfo1.append(f"{name}-hlil@{instr_index}: {hlil.is_var_live_at(var, binja.highlevelil.InstructionIndex(instr_index))}")
for instr_index in range(0, len(hlil_ssa)):
for var in ssa_vars:
retinfo2.append(f"{name}-hlil-ssa@{instr_index}: {hlil_ssa.is_ssa_var_live_at(var, binja.highlevelil.InstructionIndex(instr_index))}")
return retinfo1 + retinfo2
class TestBuilder(Builder):
""" The TestBuilder is for tests that need to be checked against a
stored oracle data that isn't from a binary. These test are
generated on your local machine then run again on the build
machine to verify correctness.
- Function that are tests should start with 'test_'
- Function doc string used as 'on error' message
- Should return: list of strings
"""
def test_BinaryViewType_list(self):
"""BinaryViewType list doesn't match"""
return ["BinaryViewType: " + x.name for x in binja.BinaryViewType]
def test_deprecated_BinaryViewType(self):
"""deprecated BinaryViewType list doesn't match"""
file_name = self.unpackage_file("fat_macho_9arch.bndb")
if not os.path.exists(file_name):
return [""]
view_types = []
with binja.filemetadata.FileMetadata().open_existing_database(file_name, None) as bv:
for view_type in bv.available_view_types:
if view_type.is_deprecated:
view_types.append('BinaryViewType: %s (deprecated)' % view_type.name)
else:
view_types.append('BinaryViewType: %s' % view_type.name)
self.delete_package("fat_macho_9arch.bndb")
return view_types
def test_Architecture_list(self):
"""Architecture list doesn't match"""
return ["Arch name: " + arch.name for arch in binja.Architecture]
def test_Assemble(self):
"""unexpected assemble result"""
result = []
# success cases
result.append(f"x86 assembly: {binja.Architecture['x86'].assemble('xor eax, eax')}")
result.append(f"x86_64 assembly: {binja.Architecture['x86_64'].assemble('xor rax, rax')}")
result.append(f"mips32 assembly: {binja.Architecture['mips32'].assemble('move $ra, $zero')}")
result.append(f"armv7 assembly: {binja.Architecture['armv7'].assemble('str r2, [sp, #-0x4]!')}")
result.append(f"aarch64 assembly: {binja.Architecture['aarch64'].assemble('mov x0, x0')}")
result.append(f"thumb2 assembly: {binja.Architecture['thumb2'].assemble('ldr r4, [r4]')}")
result.append(f"thumb2eb assembly: {binja.Architecture['thumb2eb'].assemble('ldr r4, [r4]')}")
# fail cases
try:
strResult = binja.Architecture["x86"].assemble("thisisnotaninstruction")
except ValueError:
result.append("Assemble Failed As Expected; 'thisisnotaninstruction' is not an instruction on 'x86'")
try:
strResult = binja.Architecture["x86_64"].assemble("thisisnotaninstruction")
except ValueError:
result.append("Assemble Failed As Expected; 'thisisnotaninstruction' is not an instruction on 'x86_64'")
try:
strResult = binja.Architecture["mips32"].assemble("thisisnotaninstruction")
except ValueError:
result.append("Assemble Failed As Expected; 'thisisnotaninstruction' is not an instruction on 'mips32'")
try:
strResult = binja.Architecture["mipsel32"].assemble("thisisnotaninstruction")
except ValueError:
result.append("Assemble Failed As Expected; 'thisisnotaninstruction' is not an instruction on 'mipsel32'")
try:
strResult = binja.Architecture["armv7"].assemble("thisisnotaninstruction")
except ValueError:
result.append("Assemble Failed As Expected; 'thisisnotaninstruction' is not an instruction on 'armv7'")
try:
strResult = binja.Architecture["aarch64"].assemble("thisisnotaninstruction")
except ValueError:
result.append("Assemble Failed As Expected; 'thisisnotaninstruction' is not an instruction on 'aarch64'")
try:
strResult = binja.Architecture["thumb2"].assemble("thisisnotaninstruction")
except ValueError:
result.append("Assemble Failed As Expected; 'thisisnotaninstruction' is not an instruction on 'thumb2'")
try:
strResult = binja.Architecture["thumb2eb"].assemble("thisisnotaninstruction")
except ValueError:
result.append("Assemble Failed As Expected; 'thisisnotaninstruction' is not an instruction on 'thumb2eb'")
return result
def test_Architecture(self):
"""Architectures produced different results"""
retinfo = []
flag_reg0 = binja.FlagName("reg0")
reg_reg0 = binja.RegisterName("reg0")
reg_fwidthreg0 = binja.RegisterName("fwidth_reg0")
stack_reg0 = binja.RegisterStackName("reg0")
semgrp_flggrp0 = binja.SemanticGroupName("flggrp0")
semcls_cls0 = binja.SemanticClassName("cls0")
class ArchTest(binja.Architecture):
name = "ArchTest"
address_size = -1
default_int_size = -1
instr_alignment = -1
opcode_display_length = 1
max_instr_length = -1
regs = {
reg_reg0: binja.RegisterInfo(reg_reg0, 2)
}
stack_pointer = "reg0"
flags = [flag_reg0, binja.FlagName("reg0_flg")]
flag_write_types = [binja.FlagWriteTypeName("*")]
flag_roles = {
flag_reg0: binja.FlagRole.SpecialFlagRole,
"reg0_flg": "SpecialFlagRole"
}
flags_required_for_flag_condition = {
binja.LowLevelILFlagCondition.LLFC_UGE: [flag_reg0]
}
flags_written_by_flag_write_type = {
"*": ["reg0"]
}
full_width_regs = {
reg_fwidthreg0: binja.RegisterInfo(reg_fwidthreg0, 3)
}
reg_stacks = {
stack_reg0: binja.RegisterStackInfo([stack_reg0], [stack_reg0], stack_reg0, 0)
}
semantic_flag_groups = {
semgrp_flggrp0: 0
}
flags_required_by_semantic_flag_group = {
semgrp_flggrp0: [0]
}
flags_required_for_semantic_flag_group = {
semgrp_flggrp0: [flag_reg0]
}
semantic_flag_classes = {
semcls_cls0: 0
}
# flag_conditions_for_semantic_flag_group = {
# semgrp_flggrp0: semcls_cls0
# }
def get_instruction_text(self, data, addr):
return [binja.InstructionTextToken(binja.InstructionTextTokenType.TextToken, "not hooked")], 1
class EmptyArch(binja.Architecture):
pass
ArchTest.register()
try:
EmptyArch.register()
assert False # Registering an empty arch should fail (this code should not be reached)
except:
pass
at = binja.Architecture['ArchTest']
assert len(at.type_libraries) == 0
assert at.can_assemble == False
assert binja.Architecture['x86'].can_assemble == True
for arch in binja.Architecture:
retinfo.append(f"Arch calling convention: {arch.calling_conventions}")
retinfo.append(f"Arch regs: {arch.regs}")
retinfo.append(f"Arch full width regs: {arch.full_width_regs}")
retinfo.append(f"Arch standalone platform: {arch.standalone_platform}")
retinfo.append(f"Arch repr: {repr(arch)}")
retinfo.append(f"Arch endianness: {arch.endianness}")
retinfo.append(f"Arch address size: {arch.address_size}")
retinfo.append(f"Arch default int size: {arch.default_int_size}")
retinfo.append(f"Arch instr alignment: {arch.instr_alignment}")
retinfo.append(f"Arch max instr length: {arch.max_instr_length}")
retinfo.append(f"Arch opcode display length: {arch.opcode_display_length}")
retinfo.append(f"Arch stack pointer: {arch.stack_pointer}")
retinfo.append(f"Arch link reg: {arch.link_reg}")
retinfo.append(f"Arch & address: {arch.get_associated_arch_by_address(0)}")
assert binja.Architecture['x86'] == binja.Architecture['x86']
assert binja.Architecture['x86'] != binja.Architecture['x86_64']
return retinfo
def test_ArchitectureHook(self):
class ArchTestHook(binja.ArchitectureHook):
def get_instruction_text(self, data, addr):
return [binja.InstructionTextToken(binja.InstructionTextTokenType.TextToken, "hooked")], 1
class ArchTestHook2(binja.ArchitectureHook):
pass
at = binja.Architecture["ArchTest"]
instr_text = at.get_instruction_text(b'\x00', 1)
ArchTestHook(at).register()
instr_text_hooked = at.get_instruction_text(b'\x00', 1)
# Register empty hook
ArchTestHook2(at).register()
assert instr_text != instr_text_hooked
assert instr_text == instr_text
ath2 = ArchTestHook2(at)
assert ath2.base_arch == at
ath2.base_arch = binja.Architecture["x86"]
assert ath2.base_arch == binja.Architecture["x86"]
ath2.base_arch = at
assert ath2.base_arch == at
return [f"{at}"]
def test_Function(self):
"""Function produced different result"""
inttype = binja.Type.int(4)
testfunction = binja.Type.function(inttype, [inttype, inttype, inttype])
return ["Test_function params: " + str(testfunction.parameters), "Test_function pointer: " + str(testfunction.pointer(binja.Architecture["x86"], testfunction))]
def test_Simplifier(self):
"""Template Simplification"""
result = [binja.demangle.simplify_name_to_string(s) for s in [
# Minimal exhaustive examples of simplifier (these are replicated in testcommon)
"std::basic_string<T, std::char_traits<T>, std::allocator<T> >",
"std::vector<T, std::allocator<T> >",
"std::vector<T, std::allocator<T>, std::lessthan<T> >",
"std::deque<T, std::allocator<T> >",
"std::forward_list<T, std::allocator<T> >",
"std::list<T, std::allocator<T> >",
"std::stack<T, std::deque<T> >",
"std::queue<T, std::deque<T> >",
"std::set<T, std::less<T>, std::allocator<T> >",
"std::multiset<T, std::less<T>, std::allocator<T> >",
"std::map<T1, T2, std::less<T1>, std::allocator<std::pair<const T1, T2> > >",
"std::multimap<T1, T2, std::less<T1>, std::allocator<std::pair<const T1, T2> > >",
"std::unordered_set<T, std::hash<T>, std::equal_to<T>, std::allocator<T> >",
"std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, std::allocator<T> >",
"std::unordered_map<T1, T2, std::hash<T1>, std::equal_to<T1>, std::allocator<std::pair<const T1, T2> > >",
"std::unordered_multimap<T1, T2, std::hash<T1>, std::equal_to<T1>, std::allocator<std::pair<const T1, T2> > >",
"std::basic_stringbuf<char, std::char_traits<char>, std::allocator<char> >",
"std::basic_istringstream<char, std::char_traits<char>, std::allocator<char> >",
"std::basic_ostringstream<char, std::char_traits<char>, std::allocator<char> >",
"std::basic_stringstream<char, std::char_traits<char>, std::allocator<char> >",
"std::basic_stringbuf<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >",
"std::basic_istringstream<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >",
"std::basic_ostringstream<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >",
"std::basic_stringstream<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >",
"std::basic_stringbuf<T, std::char_traits<T>, std::allocator<T> >",
"std::basic_istringstream<T, std::char_traits<T>, std::allocator<T> >",
"std::basic_ostringstream<T, std::char_traits<T>, std::allocator<T> >",
"std::basic_stringstream<T, std::char_traits<T>, std::allocator<T> >",
"std::basic_ios<char, std::char_traits<char> >",
"std::basic_streambuf<char, std::char_traits<char> >",
"std::basic_istream<char, std::char_traits<char> >",
"std::basic_ostream<char, std::char_traits<char> >",
"std::basic_iostream<char, std::char_traits<char> >",
"std::basic_filebuf<char, std::char_traits<char> >",
"std::basic_ifstream<char, std::char_traits<char> >",
"std::basic_ofstream<char, std::char_traits<char> >",
"std::basic_fstream<char, std::char_traits<char> >",
"std::basic_ios<wchar_t, std::char_traits<wchar_t> >",
"std::basic_streambuf<wchar_t, std::char_traits<wchar_t> >",
"std::basic_istream<wchar_t, std::char_traits<wchar_t> >",
"std::basic_ostream<wchar_t, std::char_traits<wchar_t> >",
"std::basic_iostream<wchar_t, std::char_traits<wchar_t> >",
"std::basic_filebuf<wchar_t, std::char_traits<wchar_t> >",
"std::basic_ifstream<wchar_t, std::char_traits<wchar_t> >",
"std::basic_ofstream<wchar_t, std::char_traits<wchar_t> >",
"std::basic_fstream<wchar_t, std::char_traits<wchar_t> >",
"std::basic_ios<T, std::char_traits<T> >",
"std::basic_streambuf<T, std::char_traits<T> >",
"std::basic_istream<T, std::char_traits<T> >",
"std::basic_ostream<T, std::char_traits<T> >",
"std::basic_iostream<T, std::char_traits<T> >",
"std::basic_filebuf<T, std::char_traits<T> >",
"std::basic_ifstream<T, std::char_traits<T> >",
"std::basic_ofstream<T, std::char_traits<T> >",
"std::basic_fstream<T, std::char_traits<T> >",
# The following simplifiers should probably be done as typedefs some where as they can appear both
# as the simplified and unsimplified name in the type libraries and in mangled names
# "std::fpos<__mbstate_t>",
# "std::_Ios_Iostate",
# "std::_Ios_Seekdir",
# "std::_Ios_Openmode",
# "std::_Ios_Fmtflags",
# The following 5 entries are the simplified versions of the above so we don't have to re-generate
# unit test results.
"std::streampos",
"std::ios_base::iostate",
"std::ios_base::seekdir",
"std::ios_base::openmode",
"std::ios_base::fmtflags",
"std::foo<T, std::char_traits<T> >",
"std::bar<T, std::char_traits<T> >::bar",
"std::foo<T, std::char_traits<T> >::~foo",
"std::foo<T, std::char_traits<T> >::bar",
"std::foo<bleh::T, std::char_traits<bleh::T> >",
"std::bar<bleh::T, std::char_traits<bleh::T> >::bar",
"std::foo<bleh::T, std::char_traits<bleh::T> >::~foo",
"std::foo<bleh::T, std::char_traits<bleh::T> >::bar",
"std::foo<foo::bleh::T, std::char_traits<foo::bleh::T> >",
"std::bar<foo::bleh::T, std::char_traits<foo::bleh::T> >::bar",
"std::foo<foo::bleh::T, std::char_traits<foo::bleh::T> >::~foo",
"std::foo<foo::bleh::T, std::char_traits<foo::bleh::T> >::bar",
# More complex examples:
"AddRequiredUIPluginDependency(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)",
"std::vector<std::vector<BinaryNinja::InstructionTextToken, std::allocator<BinaryNinja::InstructionTextToken> >, std::allocator<std::vector<BinaryNinja::InstructionTextToken, std::allocator<BinaryNinja::InstructionTextToken> > > >::_M_check_len(uint64_t, char const*) const",
"std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::array<uint32_t, 5ul> >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::array<uint32_t, 5ul> > > >::_M_default_append(uint64_t)",
"std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string",
"std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::~basic_string",
]]
# Test all the APIs
qName = binja.types.QualifiedName(["std", "__cxx11", "basic_string<T, std::char_traits<T>, std::allocator<T> >"])
result.append(binja.demangle.simplify_name_to_string(qName))
result.append(str(binja.demangle.simplify_name_to_qualified_name(qName)))
result.append(str(binja.demangle.simplify_name_to_qualified_name(str(qName))))
result.append(str(binja.demangle.simplify_name_to_qualified_name(str(qName), False).name))
result.append("::".join(binja.demangle_gnu3(binja.Architecture['x86_64'], "_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm", False)[1]))
result.append("::".join(binja.demangle_gnu3(binja.Architecture['x86_64'], "_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm", True)[1]))
return result
def test_Struct(self):
"""Struct produced different result"""
retinfo = []
inttype = binja.Type.int(4)
struct = binja.TypeBuilder.structure()
struct.insert(0, inttype)
struct.append(inttype)
struct.replace(0, inttype)
struct.remove(1)
for i in struct.members:
retinfo.append("Struct member: " + str(i))
retinfo.append("Struct width: " + str(struct.width))
struct.width = 16
retinfo.append("Struct width after adjustment: " + str(struct.width))
retinfo.append("Struct alignment: " + str(struct.alignment))
struct.alignment = 8
retinfo.append("Struct alignment after adjustment: " + str(struct.alignment))
retinfo.append("Struct packed: " + str(struct.packed))
struct.packed = True
retinfo.append("Struct packed after adjustment: " + str(struct.packed))
retinfo.append("Struct type: " + str(struct.type))
assert struct == struct, "Structs are not equal"
assert not (struct != struct), "Structs are not not not equal"
retinfo.append("False") # TODO Remove when regenerating this
return retinfo
def test_Enumeration(self):
"""Enumeration produced different result"""
retinfo = []
enum = binja.TypeBuilder.enumeration()
enum.append("a", 1)
enum.append("b", 2)
enum.replace(0, "a", 2)
enum.remove(0)
retinfo.append(str(enum))
retinfo.append(str((enum == enum) and not (enum != enum)))
return retinfo
def test_Types(self):
"""Types produced different result"""
file_name = self.unpackage_file("helloworld")
try:
with binja.load(file_name) as bv:
preprocessed = binja.preprocess_source("""
#ifdef nonexistant
int foo = 1;
long long foo1 = 1;
#else
int bar = 2;
long long bar1 = 2;
#endif
""")
source = '\n'.join([i for i in preprocessed[0].split('\n') if not '#line' in i and len(i) > 0])
typelist = bv.platform.parse_types_from_source(source)
inttype = binja.Type.int(4)
namedtype = binja.NamedTypeReferenceBuilder.create()
tokens = inttype.get_tokens() + inttype.get_tokens_before_name() + inttype.get_tokens_after_name()
retinfo = []
for i in range(len(typelist.variables)):
for j in typelist.variables.popitem():
retinfo.append("Type: " + str(j))
retinfo.append("Named Type: " + str(namedtype))
retinfo.append("Type equality: " + str((inttype == inttype) and not (inttype != inttype)))
return retinfo
finally:
self.delete_package("helloworld")
def test_TypeBuilders_and_Types(self):
"""Test TypeBuilders"""
file_name = self.unpackage_file("helloworld")
try:
with binja.load(file_name) as bv:
with binja.StructureBuilder.builder(bv, 'Foo') as s:
s.packed = True
s.append(Type.int(2))
s.append(Type.int(4))
s.append(Type.void())
s.append(Type.bool())
s.append(Type.char())
s.append(Type.char("char_alt_name"))
s.append(Type.float(2, "half"))
s.append(Type.float(4) )
s.append(Type.float(8))
s.append(Type.float(16))
s.append(Type.wide_char(4, "wchar32_t"))
s.append(Type.structure_type(binja.StructureBuilder.create([Type.int(1)])))
s.append(Type.named_type(NamedTypeReferenceBuilder.create(NamedTypeReferenceClass.UnknownNamedTypeClass, "id", "name")))
s.append(Type.named_type_from_type_and_id("id2", ["qualified", "name"]))
s.append(Type.generate_named_type_reference("guid", [b"byte", b"name"]))
s.append(Type.enumeration_type(bv.arch, EnumerationBuilder.create([("Member1", 1)])))
try:
Type.pointer(None, None) # test the failure case
except ValueError:
pass
s.append(Type.pointer_of_width(8, Type.int(4), BoolWithConfidence(True, 255), BoolWithConfidence(False, 255), ReferenceType.RValueReferenceType))
s.append(Type.array(Type.int(4), 4))
s.append(Type.structure([(Type.int(4), "field1")]))
s.append(Type.enumeration(bv.arch, [binja.types.EnumerationMember("Mem-1", 1), binja.types.EnumerationMember("Mem-2")]))
s.append(Type.enumeration(bv.arch, [binja.types.EnumerationMember("Mem2-1", 1), binja.types.EnumerationMember("Mem2-2")], 2))
s.append(Type.enumeration(bv.arch, [binja.types.EnumerationMember("Mem3-1", 1), binja.types.EnumerationMember("Mem3-2")], 2, True))
s.append(Type.enumeration(bv.arch, None))
tid = Type.generate_auto_demangled_type_id("auto_demangled_tid")
tid_source = Type.get_auto_demangled_type_id_source()
s.append(Type.named_type_reference(NamedTypeReferenceClass.UnknownNamedTypeClass, "Someothername", tid, 4, 4, True, True))
try:
Type.int(4).name
assert False, "trying to access name of integer succeeded when it shouldn't have"
except NotImplementedError:
pass
members = s.members
const = s.const
volatile = s.volatile
s = bv.types['Foo']
assert members == s.members
assert const == s.const
assert volatile == s.volatile
return [str(s.members)]
finally:
self.delete_package("helloworld")
def test_Plugin_bin_info(self):
"""print_syscalls plugin produced different result"""
file_name = self.unpackage_file("helloworld")
try:
bin_info_path = os.path.join(os.path.dirname(__file__), '..', 'python', 'examples', 'bin_info.py')
if sys.platform == "win32":
python_bin = ["py", "-3"]
else:
python_bin = ["python3"]
result = subprocess.Popen(python_bin + [bin_info_path, file_name], stdout=subprocess.PIPE).communicate()[0]
# normalize line endings and path sep
return [line for line in result.replace(b"\\", b"/").replace(b"\r\n", b"\n").decode("charmap").split("\n")]
finally:
self.delete_package("helloworld")
def test_linear_disassembly(self):
"""linear_disassembly produced different result"""
file_name = self.unpackage_file("helloworld")
try:
bv = binja.BinaryViewType['ELF'].open(file_name)
disass = bv.linear_disassembly
retinfo = []
for i in disass:
i = str(i)
i = remove_low_confidence(i)
retinfo.append(i)
return retinfo
finally:
self.delete_package("helloworld")
def test_data_renderer(self):
"""data renderer produced different result"""
file_name = self.unpackage_file("helloworld")
class ElfHeaderDataRenderer(DataRenderer):
def __init__(self):
DataRenderer.__init__(self)
def perform_is_valid_for_data(self, ctxt, view, addr, type, context):
return DataRenderer.is_type_of_struct_name(type, "Elf64_Header", context)
def perform_get_lines_for_data(self, ctxt, view, addr, type, prefix, width, context):
prefix.append(InstructionTextToken(InstructionTextTokenType.TextToken, "I'm in ur Elf64_Header"))
return [DisassemblyTextLine(prefix, addr)]
def __del__(self):
pass
try:
bv = binja.BinaryViewType['ELF'].open(file_name)
ElfHeaderDataRenderer().register_type_specific()
disass = bv.linear_disassembly
retinfo = []
for i in disass:
i = str(i)
i = remove_low_confidence(i)
retinfo.append(i)
return retinfo
finally:
self.delete_package("helloworld")
# def test_partial_register_dataflow(self):
# """partial_register_dataflow produced different results"""
# file_name = self.unpackage_file("partial_register_dataflow")
# result = []
# reg_list = ['ch', 'cl', 'ah', 'edi', 'al', 'cx', 'ebp', 'ax', 'edx', 'ebx', 'esp', 'esi', 'dl', 'dh', 'di', 'bl', 'bh', 'eax', 'dx', 'bx', 'ecx', 'sp', 'si']
# bv = binja.load(file_name)
# for func in bv.functions:
# llil = func.low_level_il
# for i in range(0, llil.__len__()-1):
# for x in reg_list:
# result.append("LLIL:" + str(i).replace('L', '') + ":" + x + ":" + str(llil[i].get_reg_value(x)).replace('L', ''))