Enforce black code formatting

Author: patacca

bin/bindiffer

@@ -11,26 +11,39 @@ import sys
 from bindiff import BinDiff
 from binexport import ProgramBinExport
 
-BINARY_FORMAT = {'application/x-dosexec',
-                 'application/x-sharedlib',
-                 'application/x-mach-binary',
-                 'application/x-executable',
-                 'application/x-object',
-                 'application/x-pie-executable'}
+BINARY_FORMAT = {
+    "application/x-dosexec",
+    "application/x-sharedlib",
+    "application/x-mach-binary",
+    "application/x-executable",
+    "application/x-object",
+    "application/x-pie-executable",
+}
 
-EXTENSIONS_WHITELIST = {'application/octet-stream': ['.dex']}
+EXTENSIONS_WHITELIST = {"application/octet-stream": [".dex"]}
 
 
-CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'],
-                        max_content_width=300)
+CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"], max_content_width=300)
 
 
 @click.command(context_settings=CONTEXT_SETTINGS)
-@click.option('-i', '--ida-path', type=click.Path(exists=True), default=None, help="IDA Pro installation directory")
-@click.option('-b', '--bindiff-path', type=click.Path(exists=True), default=None, help="BinDiff differ directory")
-@click.option('-o', '--output', type=click.Path(), default=None, help="Output file matching")
+@click.option(
+    "-i",
+    "--ida-path",
+    type=click.Path(exists=True),
+    default=None,
+    help="IDA Pro installation directory",
+)
+@click.option(
+    "-b",
+    "--bindiff-path",
+    type=click.Path(exists=True),
+    default=None,
+    help="BinDiff differ directory",
+)
+@click.option("-o", "--output", type=click.Path(), default=None, help="Output file matching")
 @click.argument("primary", type=click.Path(exists=True), metavar="<primary file>")
-@click.argument('secondary', type=click.Path(exists=True), metavar="<secondary file>")
+@click.argument("secondary", type=click.Path(exists=True), metavar="<secondary file>")
 def main(ida_path: str, bindiff_path: str, output: str, primary: str, secondary: str) -> None:
     """
     bindiffer is a very simple utility to diff two binary files using BinDiff
@@ -44,20 +57,22 @@ def main(ida_path: str, bindiff_path: str, output: str, primary: str, secondary:
     :param secondary: Path to the secondary file
     """
 
-    logging.basicConfig(format='[%(levelname)s] %(message)s', level=logging.INFO)
+    logging.basicConfig(format="[%(levelname)s] %(message)s", level=logging.INFO)
 
     if ida_path:
-        os.environ['IDA_PATH'] = Path(ida_path).resolve().as_posix()
+        os.environ["IDA_PATH"] = Path(ida_path).resolve().as_posix()
 
     if bindiff_path:
-        os.environ['BINDIFF_PATH'] = Path(bindiff_path).resolve().as_posix()
+        os.environ["BINDIFF_PATH"] = Path(bindiff_path).resolve().as_posix()
 
     if not BinDiff.is_installation_ok():
-        logging.error("can't find bindiff executable (make sure its available in $PATH or via --bindiff-path")
+        logging.error(
+            "can't find bindiff executable (make sure its available in $PATH or via --bindiff-path"
+        )
         sys.exit(1)
 
     if output is None:
-        output = '{}_vs_{}.BinDiff'.format(Path(primary).stem, Path(secondary).stem)
+        output = "{}_vs_{}.BinDiff".format(Path(primary).stem, Path(secondary).stem)
 
     # Check that the output name is not too long
     if len(output) > 255:
@@ -70,14 +85,18 @@ def main(ida_path: str, bindiff_path: str, output: str, primary: str, secondary:
     if not (primary.suffix == ".BinExport" and secondary.suffix == ".BinExport"):
         for file in [primary, secondary]:
             mime_type = magic.from_file(file, mime=True)
-            if mime_type not in BINARY_FORMAT and Path(file).suffix not in EXTENSIONS_WHITELIST.get(mime_type, []):
-                logging.error(f"file {file} mimetype ({mime_type}) not supported (not an executable file)")
+            if mime_type not in BINARY_FORMAT and Path(file).suffix not in EXTENSIONS_WHITELIST.get(
+                mime_type, []
+            ):
+                logging.error(
+                    f"file {file} mimetype ({mime_type}) not supported (not an executable file)"
+                )
                 exit(1)
 
         # Export each binary separately (and then diff to be able to print it)
         logging.info(f"export primary: {primary}.BinExport")
         ProgramBinExport.from_binary_file(primary, open_export=False, override=True)
-        primary = Path(str(primary)+".BinExport")
+        primary = Path(str(primary) + ".BinExport")
 
         logging.info(f"export secondary: {secondary}.BinExport")
         ProgramBinExport.from_binary_file(secondary, open_export=False, override=True)
@@ -92,5 +111,5 @@ def main(ida_path: str, bindiff_path: str, output: str, primary: str, secondary:
         sys.exit(1)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

src/bindiff/bindiff.py

@@ -15,7 +15,7 @@
 
 BINDIFF_BINARY = None
 BINDIFF_PATH_ENV = "BINDIFF_PATH"
-BIN_NAMES = ['bindiff', 'bindiff.exe', 'differ']
+BIN_NAMES = ["bindiff", "bindiff.exe", "differ"]
 
 
 def _check_bin_names(path: Path) -> bool:
@@ -48,7 +48,7 @@ def _check_environ() -> bool:
 def _check_default_path() -> bool:
     """
     Check if BinDiff is installed at its default location
-    
+
     :return: bool
     """
     return _check_bin_names(Path("/opt/zynamics/BinDiff/bin"))
@@ -78,7 +78,12 @@ class BinDiff(BindiffFile):
                  additional attributes and method to the class.
     """
 
-    def __init__(self, primary: Union[ProgramBinExport, str], secondary: Union[ProgramBinExport, str], diff_file: str):
+    def __init__(
+        self,
+        primary: Union[ProgramBinExport, str],
+        secondary: Union[ProgramBinExport, str],
+        diff_file: str,
+    ):
         """
         :param primary: first program diffed
         :param secondary: second program diffed
@@ -94,7 +99,7 @@ def __init__(self, primary: Union[ProgramBinExport, str], secondary: Union[Progr
     def primary_unmatched_function(self) -> list[FunctionBinExport]:
         """
         Return a list of the unmatched functions in the primary program.
-        
+
         :return: list of unmatched functions in primary
         """
         funs = []
@@ -106,7 +111,7 @@ def primary_unmatched_function(self) -> list[FunctionBinExport]:
     def secondary_unmatched_function(self) -> list[FunctionBinExport]:
         """
         Return a list of the unmatched functions in the secondary program.
-        
+
         :return: list of unmatched functions in secondary
         """
         funs = []
@@ -115,7 +120,9 @@ def secondary_unmatched_function(self) -> list[FunctionBinExport]:
                 funs.append(fun)
         return funs
 
-    def iter_function_matches(self) -> list[tuple[FunctionBinExport, FunctionBinExport, FunctionMatch]]:
+    def iter_function_matches(
+        self,
+    ) -> list[tuple[FunctionBinExport, FunctionBinExport, FunctionMatch]]:
         """
         Return a list of all the matched functions. Each element of the list is a tuple containing
         the function in the primary program, the matched function in the secondary program and the
@@ -124,50 +131,58 @@ def iter_function_matches(self) -> list[tuple[FunctionBinExport, FunctionBinExpo
         :return: list of tuple, each containing the primary function, the secondary function and
                  the FunctionMatch object
         """
-        return [(self.primary[match.address1], self.secondary[match.address2], match) \
-                for match in self.primary_functions_match.values()]
+        return [
+            (self.primary[match.address1], self.secondary[match.address2], match)
+            for match in self.primary_functions_match.values()
+        ]
 
-    def _unmatched_bbs(self, function: FunctionBinExport, map: dict[int, dict[int, BasicBlockMatch]]) -> list[BasicBlockBinExport]:
+    def _unmatched_bbs(
+        self, function: FunctionBinExport, map: dict[int, dict[int, BasicBlockMatch]]
+    ) -> list[BasicBlockBinExport]:
         bbs = []
         for bb_addr, bb in function.items():
             if maps := map.get(bb_addr):
-                if function.addr not in maps:  # The block has been match but in another function thus unmatched here
+                # The block has been match but in another function thus unmatched here
+                if function.addr not in maps:
                     bbs.append(bb)
                 else:
                     bbs.append(bb)
         return bbs
 
-    def primary_unmatched_basic_block(self, function: FunctionBinExport) -> list[BasicBlockBinExport]:
+    def primary_unmatched_basic_block(
+        self, function: FunctionBinExport
+    ) -> list[BasicBlockBinExport]:
         """
         Return a list of the unmatched basic blocks in the provided function.
         The function must be part of the primary program.
-        
+
         :param function: A function of the primary program
         :return: list of unmatched basic blocks
         """
         return self._unmatched_bbs(function, self.primary_basicblock_match)
 
-    def secondary_unmatched_basic_block(self, function: FunctionBinExport) -> list[BasicBlockBinExport]:
+    def secondary_unmatched_basic_block(
+        self, function: FunctionBinExport
+    ) -> list[BasicBlockBinExport]:
         """
         Return a list of the unmatched basic blocks in the provided function.
         The function must be part of the secondary program.
-        
+
         :param function: A function of the secondary program
         :return: list of unmatched basic blocks
         """
         return self._unmatched_bbs(function, self.secondary_basicblock_match)
 
-    def iter_basicblock_matches(self,
-                           function1: FunctionBinExport,
-                           function2: FunctionBinExport
+    def iter_basicblock_matches(
+        self, function1: FunctionBinExport, function2: FunctionBinExport
     ) -> list[tuple[BasicBlockBinExport, BasicBlockBinExport, BasicBlockMatch]]:
         """
         Return a list of all the matched basic blocks between the two provided functions.
         Each element of the list is a tuple containing the basic blocks of the primary and secondary
         functions and the BasicBlockMatch object describing the match.
         The first function must be part of the primary program while the second function must be
         part of the secondary program.
-        
+
         :param function1: A function of the primary program
         :param function2: A function of the secondary program
         :return: list of tuple, each containing the primary basic block, the secondary basic block
@@ -180,7 +195,9 @@ def iter_basicblock_matches(self,
                     items.append((bb, function2[match.address2], match))
         return items
 
-    def _unmatched_instrs(self, bb: BasicBlockBinExport, map: dict[int, dict[int, int]]) -> list[InstructionBinExport]:
+    def _unmatched_instrs(
+        self, bb: BasicBlockBinExport, map: dict[int, dict[int, int]]
+    ) -> list[InstructionBinExport]:
         instrs = []
         for addr, instr in bb.instructions.items():
             if addr not in map:
@@ -191,31 +208,34 @@ def primary_unmatched_instruction(self, bb: BasicBlockBinExport) -> list[Instruc
         """
         Return a list of the unmatched instructions in the provided basic block.
         The basic block must be part of the primary program.
-        
+
         :param bb: A basic block belonging to the primary program
         :return: list of unmatched instructions
         """
         return self._unmatched_instrs(bb, self.primary_instruction_match)
 
-    def secondary_unmatched_instruction(self, bb: BasicBlockBinExport) -> list[InstructionBinExport]:
+    def secondary_unmatched_instruction(
+        self, bb: BasicBlockBinExport
+    ) -> list[InstructionBinExport]:
         """
         Return a list of the unmatched instructions in the provided basic block.
         The basic block must be part of the secondary program.
-        
+
         :param bb: A basic block belonging to the secondary program
         :return: list of unmatched instructions
         """
         return self._unmatched_instrs(bb, self.secondary_instruction_match)
 
-    def iter_instruction_matches(self, block1: BasicBlockBinExport,
-                                 block2: BasicBlockBinExport) -> list[tuple[InstructionBinExport, InstructionBinExport]]:
+    def iter_instruction_matches(
+        self, block1: BasicBlockBinExport, block2: BasicBlockBinExport
+    ) -> list[tuple[InstructionBinExport, InstructionBinExport]]:
         """
         Return a list of all the matched instructions between the two provided basic blocks.
         Each element of the list is a tuple containing the instructions of the primary and secondary
         basic blocks.
         The first basic block must belong to the primary program while the second one must be
         part of the secondary program.
-        
+
         :param block1: A basic block belonging to the primary program
         :param block2: A basic block belonging to the secondary program
         :return: list of tuple, each containing the primary instruction and the secondary instruction
@@ -226,10 +246,12 @@ def iter_instruction_matches(self, block1: BasicBlockBinExport,
                 insts.append((instr, block2.instructions[addr2]))
         return insts
 
-    def get_match(self, function: FunctionBinExport) -> tuple[FunctionBinExport, FunctionMatch] | None:
+    def get_match(
+        self, function: FunctionBinExport
+    ) -> tuple[FunctionBinExport, FunctionMatch] | None:
         """
         Get the function that matches the provided one.
-        
+
         :param function: A function that belongs either to primary or secondary
         :return: A tuple with the matched function and the match object if there is a match for
                  the provided function, otherwise None
@@ -268,10 +290,12 @@ def raw_diffing(p1_path: Union[Path, str], p2_path: Union[Path, str], out_diff:
         f1 = Path(p1_path)
         f2 = Path(p2_path)
 
-        cmd_line = [BINDIFF_BINARY.as_posix(),
-                    f"--primary={p1_path}",
-                    f"--secondary={p2_path}",
-                    f"--output_dir={tmp_dir.as_posix()}"]
+        cmd_line = [
+            BINDIFF_BINARY.as_posix(),
+            f"--primary={p1_path}",
+            f"--secondary={p2_path}",
+            f"--output_dir={tmp_dir.as_posix()}",
+        ]
 
         logging.debug(f"run diffing: {' '.join(cmd_line)}")
         process = subprocess.Popen(cmd_line, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
@@ -301,7 +325,7 @@ def raw_diffing(p1_path: Union[Path, str], p2_path: Union[Path, str], out_diff:
         return True
 
     @staticmethod
-    def from_binary_files(p1_path: str, p2_path: str, diff_out: str) -> Optional['BinDiff']:
+    def from_binary_files(p1_path: str, p2_path: str, diff_out: str) -> Optional["BinDiff"]:
         """
         Diff two executable files. Thus it export .BinExport files from IDA
         and then diff the two resulting files in BinDiff.
@@ -324,7 +348,9 @@ def from_binary_files(p1_path: str, p2_path: str, diff_out: str) -> Optional['Bi
             return None
 
     @staticmethod
-    def from_binexport_files(p1_binexport: str, p2_binexport: str, diff_out: str) -> Optional['BinDiff']:
+    def from_binexport_files(
+        p1_binexport: str, p2_binexport: str, diff_out: str
+    ) -> Optional["BinDiff"]:
         """
         Diff two binexport files. Diff the two binexport files with bindiff
         and then load a BinDiff instance.
@@ -346,8 +372,10 @@ def _configure_bindiff_path() -> None:
         if not _check_environ():
             if not _check_default_path():
                 if not _check_path():
-                    logging.warning(f"Can't find a valid bindiff executable. (should be available in PATH or"
-                                    f"as ${BINDIFF_PATH_ENV} env variable")
+                    logging.warning(
+                        f"Can't find a valid bindiff executable. (should be available in PATH or"
+                        f"as ${BINDIFF_PATH_ENV} env variable"
+                    )
 
     @staticmethod
     def assert_installation_ok() -> None: