Add BNTL utility plugin

Allow users to easily create, diff, dump and validate type libraries

Supports the following formats:
- C header files (via core type parsers)
- Binary files (collects exported and imported functions)
- WinMD files (via `windows-metadata` crate)
- Existing type library files (for easy fixups)
- Apiset files (to resolve through forwarded windows dlls)

Can be invoked as a regular plugin via UI commands or via CLI.

Processing of type libraries inherently requires external linking, processing will automatically merge and deduplicate colliding type libraries so prefer to use inside a project or a directory and process all information (for a given platform) at once, rather than smaller invocations.

1 files changed, 52 insertions, 0 deletions

diff --git a/plugins/bntl_utils/src/command/dump.rs b/plugins/bntl_utils/src/command/dump.rs
new file mode 100644
index 00000000..4b68cd79
--- /dev/null
+++ b/plugins/bntl_utils/src/command/dump.rs
@@ -0,0 +1,52 @@
+use crate::command::{InputFileField, OutputDirectoryField};
+use crate::dump::TILDump;
+use crate::helper::path_to_type_libraries;
+use binaryninja::binary_view::BinaryView;
+use binaryninja::command::Command;
+use binaryninja::interaction::Form;
+use binaryninja::types::TypeLibrary;
+
+pub struct Dump;
+
+impl Command for Dump {
+    // TODO: We need a command type that does not require a binary view.
+    fn action(&self, _view: &BinaryView) {
+        let mut form = Form::new("Dump to C Header");
+        // TODO: The choice to select what to include?
+        form.add_field(InputFileField::field());
+        form.add_field(OutputDirectoryField::field());
+        if !form.prompt() {
+            return;
+        }
+        let output_dir = OutputDirectoryField::from_form(&form).unwrap();
+        let input_path = InputFileField::from_form(&form).unwrap();
+
+        let type_lib = match TypeLibrary::load_from_file(&input_path) {
+            Some(type_lib) => type_lib,
+            None => {
+                tracing::error!("Failed to load type library from {}", input_path.display());
+                return;
+            }
+        };
+
+        // TODO: Currently we collect input path dependencies from the platform and the parent directory.
+        let dependencies = path_to_type_libraries(input_path.parent().unwrap());
+        let dump = match TILDump::new().with_type_libs(dependencies).dump(&type_lib) {
+            Ok(dump) => dump,
+            Err(err) => {
+                tracing::error!("Failed to dump type library: {}", err);
+                return;
+            }
+        };
+
+        let output_path = output_dir.join(format!("{}.h", type_lib.name()));
+        if let Err(e) = std::fs::write(&output_path, dump) {
+            tracing::error!("Failed to write dump to {}: {}", output_path.display(), e);
+        }
+        tracing::info!("Dump written to {}", output_path.display());
+    }
+
+    fn valid(&self, _view: &BinaryView) -> bool {
+        true
+    }
+}