Ein einfacher Terminal-Hex-Editor in Rust mit Basisnavigation, dynamischer Anzeige und nicht blockierender Tastatureingabe für Binärdateien.
use anyhow::Result;
use crossterm::event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEvent};
use crossterm::execute;
use crossterm::terminal::{disable_raw_mode, enable_raw_mode, Clear, ClearType};
use crossterm::{cursor, style};
use std::env;
use std::fs;
use std::io::{self, stdout, Write};
/// Minimaler Hex-Editor mit Navigation und Bearbeitung im Terminal
struct HexEditor {
buffer: Vec<u8>, // Geladener Datenpuffer
cursor_pos: usize, // Aktuelle Cursorposition im Puffer
high_nibble: bool, // Wenn true, wird das hohe Nibble des Bytes bearbeitet, sonst das niedrige
}
impl HexEditor {
/// Erstellt einen neuen Editor mit Anfangsdaten
fn new(data: Vec<u8>) -> Self {
HexEditor {
buffer: data,
cursor_pos: 0,
high_nibble: true,
}
}
/// Zeichnet den Pufferinhalt im Terminal
fn draw(&self) -> Result<()> {
let mut stdout = stdout();
execute!(stdout, cursor::MoveTo(0, 0), Clear(ClearType::All))?;
let bytes_per_line = 16;
let lines = (self.buffer.len() + bytes_per_line - 1) / bytes_per_line;
for line in 0..lines {
let start = line * bytes_per_line;
let end = usize::min(start + bytes_per_line, self.buffer.len());
// Offset-Adresse
write!(stdout, "{:08X}: ", start)?;
// Hex-Teil
for i in start..end {
if i == self.cursor_pos {
// Hebt das aktuelle Byte hervor
if self.high_nibble {
// Hebt das hohe Nibble hervor
let byte = self.buffer[i];
let high = byte >> 4;
let low = byte & 0x0F;
write!(stdout, "{}", style::SetAttribute(style::Attribute::Reverse))?;
write!(stdout, "{:X}", high)?;
write!(stdout, "{}", style::SetAttribute(style::Attribute::NoReverse))?;
write!(stdout, "{:X} ", low)?;
} else {
// Hebt das niedrige Nibble hervor
let byte = self.buffer[i];
let high = byte >> 4;
let low = byte & 0x0F;
write!(stdout, "{:X}", high)?;
write!(stdout, "{}", style::SetAttribute(style::Attribute::Reverse))?;
write!(stdout, "{:X}", low)?;
write!(stdout, "{} ", style::SetAttribute(style::Attribute::NoReverse))?;
}
} else {
write!(stdout, "{:02X} ", self.buffer[i])?;
}
}
// Auffüllung für unvollständige Zeilen
for _ in end..start + bytes_per_line {
write!(stdout, " ")?;
}
// ASCII-Teil
write!(stdout, "|")?;
for i in start..end {
let c = self.buffer[i];
let ch = if c.is_ascii_graphic() || c == b' ' { c as char } else { '.' };
if i == self.cursor_pos {
write!(stdout, "{}{}{}", style::SetAttribute(style::Attribute::Reverse), ch, style::SetAttribute(style::Attribute::NoReverse))?;
} else {
write!(stdout, "{}", ch)?;
}
}
writeln!(stdout, "|")?;
}
writeln!(stdout, "\nBefehle: Pfeile zum Bewegen des Cursors, 0-9 a-f zum Bearbeiten, q zum Beenden")?;
stdout.flush()?;
Ok(())
}
/// Verarbeitet ein Tastatureingabe-Ereignis
fn handle_event(&mut self, event: Event) -> bool {
if let Event::Key(KeyEvent { code, .. }) = event {
match code {
KeyCode::Char('q') => return false, // Beenden
KeyCode::Left => {
if self.cursor_pos > 0 {
self.cursor_pos -= 1;
self.high_nibble = true;
}
}
KeyCode::Right => {
if self.cursor_pos + 1 < self.buffer.len() {
self.cursor_pos += 1;
self.high_nibble = true;
}
}
KeyCode::Up => {
let bytes_per_line = 16;
if self.cursor_pos >= bytes_per_line {
self.cursor_pos -= bytes_per_line;
self.high_nibble = true;
}
}
KeyCode::Down => {
let bytes_per_line = 16;
if self.cursor_pos + bytes_per_line < self.buffer.len() {
self.cursor_pos += bytes_per_line;
self.high_nibble = true;
}
}
KeyCode::Char(c) => {
// Ändert das aktuelle Nibble, wenn hexadezimale Zeichen
if let Some(val) = c.to_digit(16) {
let byte = self.buffer[self.cursor_pos];
let new_byte = if self.high_nibble {
((val as u8) << 4) | (byte & 0x0F)
} else {
(byte & 0xF0) | (val as u8)
};
self.buffer[self.cursor_pos] = new_byte;
// Nach Änderung zum niedrigen Nibble oder zum nächsten Byte wechseln
if self.high_nibble {
self.high_nibble = false;
} else {
self.high_nibble = true;
if self.cursor_pos + 1 < self.buffer.len() {
self.cursor_pos += 1;
}
}
}
}
_ => {}
}
}
true
}
}
fn main() -> Result<()> {
// Liest Dateinamen aus Argument
let args: Vec<String> = env::args().collect();
if args.len() != 2 {
eprintln!("Verwendung: {} <binärdatei>", args[0]);
std::process::exit(1);
}
let filename = &args[1];
let data = fs::read(filename)?;
let mut editor = HexEditor::new(data);
enable_raw_mode()?;
let mut stdout = stdout();
execute!(stdout, EnableMouseCapture, cursor::Hide)?;
editor.draw()?;
// Haupt-Eingabeschleife
loop {
if event::poll(std::time::Duration::from_millis(500))? {
let ev = event::read()?;
if !editor.handle_event(ev) {
break;
}
editor.draw()?;
}
}
// Terminal wiederherstellen
disable_raw_mode()?;
execute!(stdout, DisableMouseCapture, cursor::Show, cursor::MoveTo(0, 0), Clear(ClearType::All))?;
Ok(())
}