Add highlight render layer to WARP

Highlights all variant instructions and blacklisted instructions

Variant instructions are highlighted red, blacklisted will be orange.

2 files changed, 64 insertions, 8 deletions

diff --git a/plugins/warp/src/plugin.rs b/plugins/warp/src/plugin.rs
index ec903f9c..4adab293 100644
--- a/plugins/warp/src/plugin.rs
+++ b/plugins/warp/src/plugin.rs
@@ -1,11 +1,7 @@
-use crate::cache::{
-    register_cache_destructor, ViewID, FUNCTION_CACHE, GUID_CACHE, MATCHED_FUNCTION_CACHE,
-};
-use crate::convert::{to_bn_symbol_at_address, to_bn_type};
-use crate::matcher::{
-    invalidate_function_matcher_cache, Matcher, MatcherSettings, PlatformID, PLAT_MATCHER_CACHE,
-};
-use crate::{build_function, cache};
+use crate::cache::register_cache_destructor;
+
+use crate::matcher::MatcherSettings;
+use crate::plugin::render_layer::HighlightRenderLayer;
 use binaryninja::binary_view::{BinaryView, BinaryViewExt};
 use binaryninja::command::{Command, FunctionCommand};
 use binaryninja::function::{Function, FunctionUpdateType};
@@ -22,6 +18,7 @@ mod copy;
 mod create;
 mod find;
 mod load;
+mod render_layer;
 mod types;
 mod workflow;
 
@@ -188,6 +185,9 @@ pub extern "C" fn CorePluginInit() -> bool {
     // Make sure caches are flushed when the views get destructed.
     register_cache_destructor();
 
+    // Register our highlight render layer.
+    HighlightRenderLayer::register();
+
     workflow::insert_workflow();
 
     binaryninja::command::register_command(
diff --git a/plugins/warp/src/plugin/render_layer.rs b/plugins/warp/src/plugin/render_layer.rs
new file mode 100644
index 00000000..cdac71f2
--- /dev/null
+++ b/plugins/warp/src/plugin/render_layer.rs
@@ -0,0 +1,56 @@
+use crate::{is_blacklisted_instruction, is_variant_instruction, relocatable_regions};
+use binaryninja::basic_block::BasicBlock;
+use binaryninja::disassembly::DisassemblyTextLine;
+use binaryninja::function::{HighlightColor, HighlightStandardColor, NativeBlock};
+use binaryninja::low_level_il::instruction::LowLevelInstructionIndex;
+use binaryninja::render_layer::{register_render_layer, RenderLayer};
+
+pub struct HighlightRenderLayer {}
+
+impl HighlightRenderLayer {
+    pub fn register() {
+        register_render_layer(
+            "WARP Highlight Layer",
+            HighlightRenderLayer {},
+            Default::default(),
+        );
+    }
+}
+
+impl RenderLayer for HighlightRenderLayer {
+    fn apply_to_llil_block(
+        &self,
+        block: &BasicBlock<NativeBlock>,
+        mut lines: Vec<DisassemblyTextLine>,
+    ) -> Vec<DisassemblyTextLine> {
+        // Highlight any LLIL instruction that will be masked by WARP.
+        let function = block.function();
+        // TODO: We might need to make relocatable regions configurable.
+        let relocatable_regions = relocatable_regions(&function.view());
+        let Ok(llil) = function.low_level_il() else {
+            // Don't even think this is possible but _shrug_.
+            return lines;
+        };
+
+        for line in &mut lines {
+            let llil_instr_idx = LowLevelInstructionIndex(line.instruction_index);
+            if let Some(llil_instr) = llil.instruction_from_index(llil_instr_idx) {
+                if is_blacklisted_instruction(&llil_instr) {
+                    // We have a blacklisted instruction, highlight it as orange!
+                    line.highlight = HighlightColor::StandardHighlightColor {
+                        color: HighlightStandardColor::OrangeHighlightColor,
+                        alpha: 155,
+                    };
+                } else if is_variant_instruction(&relocatable_regions, &llil_instr) {
+                    // We have a variant instruction, highlight it as red!
+                    line.highlight = HighlightColor::StandardHighlightColor {
+                        color: HighlightStandardColor::RedHighlightColor,
+                        alpha: 155,
+                    };
+                }
+            }
+        }
+
+        lines
+    }
+}