Skip to content

Ghidrust provides a hyper fast, AI native reverse engineering platform built in Rust, inspired by Ghidra. Includes experimental GPU kernels to rapidly decompile large files, a decryption suite, and network monitor for packet to binary reverse engineering.

22.2 KB
Raw Blame
//! Ghidrust GUI · Register Manager pane.
//!
//! `` provider: hierarchical register tree on the left,
//! per-address-range value table on the right. The register lattice is a
//! honest approximation of 's `register` spec for x86-64
//! sub-registers are grouped under their parent (e.g. `RAX` contains `EAX`,
//! `AX`, `AH`, `AL`).
//!
//! Register values are session-only until
//! the register lattice lands in the backend. Editing / clearing
//! values here mutates the state passed in — the GUI decides how to
//! persist / drop on program change.
//!
//! Extracted per internal modularization notes — new UI panes land here
//! instead of piling into `main.rs`.

use crate::layout_tokens::FieldWidth;
use ghidrust_core::FibScale;
use ghidrust_core::ThemeDensity;
use eframe::egui::{self, Color32, Ui};
use ghidrust_core::process::RegisterSet;
use std::collections::BTreeMap;

/// One user-set register value covering an address range.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RegisterValueRow {
    pub register: String,
    pub start_va: u64,
    pub end_va: u64,
    pub value: String,
}

/// Pane state (session-only until backend register lattice lands).
#[derive(Debug, Clone, Default)]
pub struct RegisterManagerState {
    pub filter: String,
    pub selected: Option<String>,
    pub values: Vec<RegisterValueRow>,
    /// New-value input state.
    pub input_start: String,
    pub input_end: String,
    pub input_value: String,
    /// Last live snapshot pulled from debugger (`process_thread_context_get`).
    pub live_snapshot: Option<RegisterSet>,
}

impl RegisterManagerState {
    /// Refresh from an optional live `RegisterSet` (debugger session).
    pub fn apply_live_registers(&mut self, regs: Option<&RegisterSet>) {
        self.live_snapshot = regs.cloned();
    }
}

/// One node in the register lattice tree.
#[derive(Debug, Clone)]
pub struct RegisterNode {
    pub name: &'static str,
    pub bits: u16,
    pub kind: RegisterKind,
    pub children: &'static [RegisterNode],
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum RegisterKind {
    General,
    Vector,
    Segment,
    Control,
    Flag,
    Instruction,
    Context,
}

impl RegisterKind {
    pub const ALL: &'static [RegisterKind] = &[
        RegisterKind::General,
        RegisterKind::Vector,
        RegisterKind::Segment,
        RegisterKind::Control,
        RegisterKind::Flag,
        RegisterKind::Instruction,
        RegisterKind::Context,
    ];
    pub const fn label(self) -> &'static str {
        match self {
            RegisterKind::General => "General purpose",
            RegisterKind::Vector => "Vector (XMM / YMM / ZMM)",
            RegisterKind::Segment => "Segment",
            RegisterKind::Control => "Control / debug",
            RegisterKind::Flag => "Flags",
            RegisterKind::Instruction => "Instruction pointer",
            RegisterKind::Context => "Context",
        }
    }
}

const RAX: RegisterNode = RegisterNode {
    name: "RAX",
    bits: 64,
    kind: RegisterKind::General,
    children: &[
        RegisterNode {
            name: "EAX",
            bits: 32,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "AX",
            bits: 16,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "AH",
            bits: 8,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "AL",
            bits: 8,
            kind: RegisterKind::General,
            children: &[],
        },
    ],
};
const RBX: RegisterNode = RegisterNode {
    name: "RBX",
    bits: 64,
    kind: RegisterKind::General,
    children: &[
        RegisterNode {
            name: "EBX",
            bits: 32,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "BX",
            bits: 16,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "BH",
            bits: 8,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "BL",
            bits: 8,
            kind: RegisterKind::General,
            children: &[],
        },
    ],
};
const RCX: RegisterNode = RegisterNode {
    name: "RCX",
    bits: 64,
    kind: RegisterKind::General,
    children: &[
        RegisterNode {
            name: "ECX",
            bits: 32,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "CX",
            bits: 16,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "CH",
            bits: 8,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "CL",
            bits: 8,
            kind: RegisterKind::General,
            children: &[],
        },
    ],
};
const RDX: RegisterNode = RegisterNode {
    name: "RDX",
    bits: 64,
    kind: RegisterKind::General,
    children: &[
        RegisterNode {
            name: "EDX",
            bits: 32,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "DX",
            bits: 16,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "DH",
            bits: 8,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "DL",
            bits: 8,
            kind: RegisterKind::General,
            children: &[],
        },
    ],
};
const RSI: RegisterNode = RegisterNode {
    name: "RSI",
    bits: 64,
    kind: RegisterKind::General,
    children: &[
        RegisterNode {
            name: "ESI",
            bits: 32,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "SI",
            bits: 16,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "SIL",
            bits: 8,
            kind: RegisterKind::General,
            children: &[],
        },
    ],
};
const RDI: RegisterNode = RegisterNode {
    name: "RDI",
    bits: 64,
    kind: RegisterKind::General,
    children: &[
        RegisterNode {
            name: "EDI",
            bits: 32,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "DI",
            bits: 16,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "DIL",
            bits: 8,
            kind: RegisterKind::General,
            children: &[],
        },
    ],
};
const RSP: RegisterNode = RegisterNode {
    name: "RSP",
    bits: 64,
    kind: RegisterKind::General,
    children: &[
        RegisterNode {
            name: "ESP",
            bits: 32,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "SP",
            bits: 16,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "SPL",
            bits: 8,
            kind: RegisterKind::General,
            children: &[],
        },
    ],
};
const RBP: RegisterNode = RegisterNode {
    name: "RBP",
    bits: 64,
    kind: RegisterKind::General,
    children: &[
        RegisterNode {
            name: "EBP",
            bits: 32,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "BP",
            bits: 16,
            kind: RegisterKind::General,
            children: &[],
        },
        RegisterNode {
            name: "BPL",
            bits: 8,
            kind: RegisterKind::General,
            children: &[],
        },
    ],
};

macro_rules! rN {
    ($name:literal, $sub:literal) => {
        RegisterNode {
            name: $name,
            bits: 64,
            kind: RegisterKind::General,
            children: &[RegisterNode {
                name: $sub,
                bits: 32,
                kind: RegisterKind::General,
                children: &[],
            }],
        }
    };
}

/// The x86-64 register lattice used by the pane.
///
/// This is a hand-authored subset covering the registers listed in
/// `/Processors/x86/data/languages/x86-64.sinc` plus a few common
/// convenience aliases. When multi-ISA lands the pane can pick a lattice
/// off the `Program::format`.
pub const X86_64_REGISTERS: &[RegisterNode] = &[
    RAX,
    RBX,
    RCX,
    RDX,
    RSI,
    RDI,
    RSP,
    RBP,
    rN!("R8", "R8D"),
    rN!("R9", "R9D"),
    rN!("R10", "R10D"),
    rN!("R11", "R11D"),
    rN!("R12", "R12D"),
    rN!("R13", "R13D"),
    rN!("R14", "R14D"),
    rN!("R15", "R15D"),
    RegisterNode {
        name: "RIP",
        bits: 64,
        kind: RegisterKind::Instruction,
        children: &[],
    },
    RegisterNode {
        name: "RFLAGS",
        bits: 64,
        kind: RegisterKind::Flag,
        children: &[
            RegisterNode {
                name: "CF",
                bits: 1,
                kind: RegisterKind::Flag,
                children: &[],
            },
            RegisterNode {
                name: "PF",
                bits: 1,
                kind: RegisterKind::Flag,
                children: &[],
            },
            RegisterNode {
                name: "AF",
                bits: 1,
                kind: RegisterKind::Flag,
                children: &[],
            },
            RegisterNode {
                name: "ZF",
                bits: 1,
                kind: RegisterKind::Flag,
                children: &[],
            },
            RegisterNode {
                name: "SF",
                bits: 1,
                kind: RegisterKind::Flag,
                children: &[],
            },
            RegisterNode {
                name: "OF",
                bits: 1,
                kind: RegisterKind::Flag,
                children: &[],
            },
            RegisterNode {
                name: "DF",
                bits: 1,
                kind: RegisterKind::Flag,
                children: &[],
            },
        ],
    },
    RegisterNode {
        name: "CS",
        bits: 16,
        kind: RegisterKind::Segment,
        children: &[],
    },
    RegisterNode {
        name: "DS",
        bits: 16,
        kind: RegisterKind::Segment,
        children: &[],
    },
    RegisterNode {
        name: "ES",
        bits: 16,
        kind: RegisterKind::Segment,
        children: &[],
    },
    RegisterNode {
        name: "FS",
        bits: 16,
        kind: RegisterKind::Segment,
        children: &[],
    },
    RegisterNode {
        name: "GS",
        bits: 16,
        kind: RegisterKind::Segment,
        children: &[],
    },
    RegisterNode {
        name: "SS",
        bits: 16,
        kind: RegisterKind::Segment,
        children: &[],
    },
    RegisterNode {
        name: "XMM0",
        bits: 128,
        kind: RegisterKind::Vector,
        children: &[],
    },
    RegisterNode {
        name: "XMM1",
        bits: 128,
        kind: RegisterKind::Vector,
        children: &[],
    },
    RegisterNode {
        name: "XMM2",
        bits: 128,
        kind: RegisterKind::Vector,
        children: &[],
    },
    RegisterNode {
        name: "XMM3",
        bits: 128,
        kind: RegisterKind::Vector,
        children: &[],
    },
    RegisterNode {
        name: "XMM4",
        bits: 128,
        kind: RegisterKind::Vector,
        children: &[],
    },
    RegisterNode {
        name: "XMM5",
        bits: 128,
        kind: RegisterKind::Vector,
        children: &[],
    },
    RegisterNode {
        name: "XMM6",
        bits: 128,
        kind: RegisterKind::Vector,
        children: &[],
    },
    RegisterNode {
        name: "XMM7",
        bits: 128,
        kind: RegisterKind::Vector,
        children: &[],
    },
    RegisterNode {
        name: "CR0",
        bits: 64,
        kind: RegisterKind::Control,
        children: &[],
    },
    RegisterNode {
        name: "CR2",
        bits: 64,
        kind: RegisterKind::Control,
        children: &[],
    },
    RegisterNode {
        name: "CR3",
        bits: 64,
        kind: RegisterKind::Control,
        children: &[],
    },
    RegisterNode {
        name: "CR4",
        bits: 64,
        kind: RegisterKind::Control,
        children: &[],
    },
];

/// Group registers by kind for the tree UI.
pub fn group_by_kind() -> BTreeMap<RegisterKind, Vec<&'static RegisterNode>> {
    let mut m: BTreeMap<RegisterKind, Vec<&'static RegisterNode>> = BTreeMap::new();
    for r in X86_64_REGISTERS {
        m.entry(r.kind).or_default().push(r);
    }
    m
}

/// Render the Register Manager pane.
///
/// `live_regs` — optional refresh from the Debugger host
/// (`process_thread_context_get` when attached in debug mode).
pub fn render(
    state: &mut RegisterManagerState,
    format: Option<&str>,
    live_regs: Option<&RegisterSet>,
    ui: &mut Ui,
    muted: Color32,
    primary: Color32,
) {
    if live_regs.is_some() {
        state.apply_live_registers(live_regs);
    }
    ui.heading("Register Manager");
    let arch = format.unwrap_or("(no program)");
    ui.small(
        egui::RichText::new(format!(
            "Register Manager · {arch} register lattice · session values + optional live debug sync"
        ))
        .color(muted),
    );
    ui.separator();

    if let Some(regs) = &state.live_snapshot {
        egui::CollapsingHeader::new("Live (debugger)")
            .default_open(true)
            .show(ui, |ui| {
                ui.small(
                    egui::RichText::new("Synced from process_thread_context_get when attached")
                        .color(muted),
                );
                egui::Grid::new("regmgr_live_grid")
                    .num_columns(2)
                    .striped(true)
                    .show(ui, |ui| {
                        for (n, v) in [
                            ("RAX", regs.rax),
                            ("RBX", regs.rbx),
                            ("RCX", regs.rcx),
                            ("RDX", regs.rdx),
                            ("RSI", regs.rsi),
                            ("RDI", regs.rdi),
                            ("RBP", regs.rbp),
                            ("RSP", regs.rsp),
                            ("R8", regs.r8),
                            ("R9", regs.r9),
                            ("R10", regs.r10),
                            ("R11", regs.r11),
                            ("R12", regs.r12),
                            ("R13", regs.r13),
                            ("R14", regs.r14),
                            ("R15", regs.r15),
                            ("RIP", regs.rip),
                            ("RFLAGS", regs.rflags),
                        ] {
                            ui.monospace(n);
                            ui.monospace(format!("{v:#x}"));
                            ui.end_row();
                        }
                    });
            });
        ui.separator();
    } else {
        ui.small(
            egui::RichText::new(
                "No live debugger registers — attach in debug mode to sync via process_thread_context_get.",
            )
            .color(muted)
            .italics(),
        );
    }

    ui.horizontal(|ui| {
        ui.label("Filter:");
        ui.add(
            egui::TextEdit::singleline(&mut state.filter)
                .desired_width(FieldWidth::Std.px(&ThemeDensity::FIB_DESKTOP))
                .hint_text("Register name…"),
        );
        if ui.button("Clear filter").clicked() {
            state.filter.clear();
        }
    });
    ui.add_space(FibScale::XS);

    let filt = state.filter.to_ascii_lowercase();
    let groups = group_by_kind();

    egui::ScrollArea::vertical()
        .id_salt("regmgr_scroll")
        .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
        .show(ui, |ui| {
            for kind in RegisterKind::ALL {
                let Some(rs) = groups.get(kind) else {
                    continue;
                };
                egui::CollapsingHeader::new(
                    egui::RichText::new(kind.label()).strong().color(primary),
                )
                .id_salt(("regmgr_group", *kind as u8))
                .default_open(matches!(
                    kind,
                    RegisterKind::General | RegisterKind::Instruction | RegisterKind::Flag
                ))
                .show(ui, |ui| {
                    for r in rs {
                        render_row(state, r, 0, &filt, ui, muted, primary);
                    }
                });
            }
        });

    ui.separator();
    ui.label(egui::RichText::new("Set Register Value").strong());
    ui.horizontal(|ui| {
        ui.label("Register:");
        ui.monospace(
            state
                .selected
                .clone()
                .unwrap_or_else(|| "(pick above)".into()),
        );
    });
    ui.horizontal(|ui| {
        ui.label("Start VA:");
        ui.add(
            egui::TextEdit::singleline(&mut state.input_start)
                .desired_width(FieldWidth::Compact.px(&ThemeDensity::FIB_DESKTOP))
                .hint_text("0x140001000"),
        );
        ui.label("End VA:");
        ui.add(
            egui::TextEdit::singleline(&mut state.input_end)
                .desired_width(FieldWidth::Compact.px(&ThemeDensity::FIB_DESKTOP))
                .hint_text("0x140001100"),
        );
        ui.label("Value:");
        ui.add(
            egui::TextEdit::singleline(&mut state.input_value)
                .desired_width(FieldWidth::Compact.px(&ThemeDensity::FIB_DESKTOP))
                .hint_text("0"),
        );
        let can_add = state.selected.is_some()
            && !state.input_start.is_empty()
            && !state.input_end.is_empty()
            && !state.input_value.is_empty();
        if ui
            .add_enabled(can_add, egui::Button::new("Set Value"))
            .clicked()
        {
            if let (Some(reg), Some(s), Some(e)) = (
                state.selected.clone(),
                parse_hex(&state.input_start),
                parse_hex(&state.input_end),
            ) {
                if e > s {
                    state.values.push(RegisterValueRow {
                        register: reg,
                        start_va: s,
                        end_va: e,
                        value: state.input_value.clone(),
                    });
                }
            }
        }
    });

    ui.add_space(FibScale::SM);
    ui.label(egui::RichText::new("Values").strong());
    if state.values.is_empty() {
        ui.weak("No user-set register values.");
        return;
    }
    let mut delete: Option<usize> = None;
    egui::Grid::new("regmgr_values_grid")
        .num_columns(5)
        .striped(true)
        .show(ui, |ui| {
            ui.strong("Register");
            ui.strong("Start");
            ui.strong("End");
            ui.strong("Value");
            ui.strong("");
            ui.end_row();
            for (i, row) in state.values.iter().enumerate() {
                ui.monospace(&row.register);
                ui.monospace(format!("{:#x}", row.start_va));
                ui.monospace(format!("{:#x}", row.end_va));
                ui.monospace(&row.value);
                if ui.small_button("Clear").clicked() {
                    delete = Some(i);
                }
                ui.end_row();
            }
        });
    if let Some(i) = delete {
        state.values.remove(i);
    }
}

fn render_row(
    state: &mut RegisterManagerState,
    node: &'static RegisterNode,
    depth: usize,
    filt: &str,
    ui: &mut Ui,
    _muted: Color32,
    primary: Color32,
) {
    let matches_filter = filt.is_empty() || node.name.to_ascii_lowercase().contains(filt);
    let has_matching_child = node
        .children
        .iter()
        .any(|c| filt.is_empty() || c.name.to_ascii_lowercase().contains(filt));

    if !matches_filter && !has_matching_child {
        return;
    }

    let indent = 12.0 * depth as f32;
    ui.horizontal(|ui| {
        ui.add_space(indent);
        let is_sel = state.selected.as_deref() == Some(node.name);
        let text = egui::RichText::new(format!("{}  {}b", node.name, node.bits)).monospace();
        let text = if is_sel {
            text.color(primary).strong()
        } else {
            text
        };
        if ui.selectable_label(is_sel, text).clicked() {
            state.selected = Some(node.name.to_string());
        }
    });
    for child in node.children {
        render_row(state, child, depth + 1, filt, ui, _muted, primary);
    }
}

fn parse_hex(s: &str) -> Option<u64> {
    let s = s.trim();
    let s = s
        .strip_prefix("0x")
        .or_else(|| s.strip_prefix("0X"))
        .unwrap_or(s);
    u64::from_str_radix(s, 16).ok()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn register_lattice_contains_expected_registers() {
        let names: Vec<&'static str> = X86_64_REGISTERS.iter().map(|r| r.name).collect();
        for expected in [
            "RAX", "RBX", "RCX", "RDX", "RSP", "RBP", "RIP", "RFLAGS", "XMM0", "CR0",
        ] {
            assert!(names.contains(&expected), "missing register {expected}");
        }
    }

    #[test]
    fn subregisters_reachable_from_rax() {
        let rax = X86_64_REGISTERS.iter().find(|r| r.name == "RAX").unwrap();
        let sub: Vec<&'static str> = rax.children.iter().map(|c| c.name).collect();
        for expected in ["EAX", "AX", "AH", "AL"] {
            assert!(
                sub.contains(&expected),
                "RAX missing subregister {expected}"
            );
        }
    }

    #[test]
    fn set_and_clear_register_value_flow() {
        let mut st = RegisterManagerState::default();
        st.selected = Some("RAX".into());
        st.values.push(RegisterValueRow {
            register: "RAX".into(),
            start_va: 0x1000,
            end_va: 0x1010,
            value: "0x2a".into(),
        });
        assert_eq!(st.values.len(), 1);
        st.values.remove(0);
        assert!(st.values.is_empty());
    }
}