[WARP] Automatically regenerate function GUIDs when rebasing or adding sections/segments

This should help with stale function GUIDs when opening a raw firmware with no setup image base and empty sections.

One issue is this causes us to spin up a background task to enumerate all functions and generate the LLIL this
is quite an involved process and as such can take a bit, unsure if there is really any way to improve this though.

Author: emesare

plugins/warp/src/plugin.rs

@@ -5,6 +5,7 @@ use crate::cache::container::add_cached_container;
 use crate::container::disk::DiskContainer;
 use crate::container::network::{NetworkClient, NetworkContainer};
 use crate::matcher::MatcherSettings;
+use crate::plugin::listener::register_view_listeners;
 use crate::plugin::render_layer::HighlightRenderLayer;
 use crate::plugin::settings::PluginSettings;
 use crate::{core_signature_dir, user_signature_dir};
@@ -127,6 +128,9 @@ fn plugin_init() -> bool {
     // Make sure caches are flushed when the views get destructed.
     register_cache_destructor();
 
+    // Make sure we will regenerate guids on certain binary view events.
+    register_view_listeners();
+
     // Register our highlight render layer.
     HighlightRenderLayer::register();
 

plugins/warp/src/plugin/listener.rs

@@ -0,0 +1,75 @@
+use crate::cache::{cached_function_guid, try_cached_function_guid};
+use binaryninja::background_task::BackgroundTask;
+use binaryninja::binary_view::{register_binary_view_event, BinaryView, BinaryViewExt};
+use binaryninja::data_notification::DataNotificationClosure;
+use binaryninja::section::Section;
+use binaryninja::segment::Segment;
+use binaryninja::worker_thread::execute_on_worker_thread;
+use binaryninjacore_sys::BNBinaryViewEventType::BinaryViewFinalizationEvent;
+use rayon::iter::ParallelIterator;
+use std::time::Instant;
+
+pub fn register_view_listeners() {
+    // When the view is finalized (constructed) we need to register some listeners so we can automatically
+    // regenerate the function GUIDs when necessary.
+    register_binary_view_event(BinaryViewFinalizationEvent, |view: &BinaryView| {
+        let _handle = DataNotificationClosure::default()
+            .rebased(|_old_view: &BinaryView, new_view: &BinaryView| {
+                spawn_regenerate_guids(&new_view)
+            })
+            .section_added(|view: &BinaryView, _section: &Section| spawn_regenerate_guids(&view))
+            .section_removed(|view: &BinaryView, _section: &Section| spawn_regenerate_guids(&view))
+            .segment_added(|view: &BinaryView, _segment: &Segment| spawn_regenerate_guids(&view))
+            .segment_removed(|view: &BinaryView, _segment: &Segment| spawn_regenerate_guids(&view))
+            .register_persisted(&view);
+    });
+}
+
+fn regenerate_guids(view: &BinaryView) {
+    if !view.has_initial_analysis() {
+        tracing::debug!(
+            "Skipping regenerating GUIDs for view {} (not analyzed)",
+            view.file()
+        );
+        return;
+    }
+    tracing::info!("Regenerating GUIDs for view {}", view.file());
+    for running_task in &BackgroundTask::running_tasks() {
+        if running_task
+            .progress_text()
+            .contains("Regenerating WARP Function GUIDs...")
+        {
+            tracing::debug!("Cancelling previous GUID regeneration task...");
+            running_task.cancel();
+        }
+    }
+
+    let task = BackgroundTask::new("Regenerating WARP Function GUIDs...", false).enter();
+    let time = Instant::now();
+    view.functions().par_iter().all(|function| {
+        let before = try_cached_function_guid(&function);
+        if before.is_some() {
+            function.remove_metadata("warp_function_guid");
+            cached_function_guid(&function, || function.lifted_il().ok());
+        }
+        // Short circuit if the task was terminated.
+        !task.is_cancelled()
+    });
+    tracing::debug!(
+        "Regenerated GUIDs for view {} in {}ms",
+        view.file(),
+        time.elapsed().as_millis()
+    );
+}
+
+/// Spawn a background task to regenerate the GUIDs for the given view.
+fn spawn_regenerate_guids(view: &BinaryView) {
+    // These events may be sent to us _before_ the view has finished analysis, we populate the guids
+    // as a part of the initial function analysis already (see 'analysis.warp.guid') so we can skip.
+    if !view.has_initial_analysis() {
+        return;
+    }
+    let view_owned = view.to_owned();
+    // Run in the background, we don't want to block the UI.
+    execute_on_worker_thread("WARP: Regenerate", move || regenerate_guids(&view_owned));
+}