HEX-MASTER

1) Overview

HEX-MASTER is a fast desktop hex editor built for EEPROM dumps and ECU binary workflows. It shows: address offsets, hex bytes, and ASCII together, and gives you practical editing tools:

• Quick navigation through large dumps (scroll + page jumps)
• Selection-based operations (swap bytes / XOR / fill / copy)
• Inspector to read/write values in normal and reverse byte order (big-endian / little-endian)
• Markers/colors to map regions and stay organized
• Multi-tab compare to highlight differences between dumps
• Simple checksums (SUM / XOR / SUM16) and expression calculator (EXPR)

2) Screen layout

3) Quick Start

1. Click Open and choose your .bin / dump file.
2. Scroll with the mouse wheel. Click a byte to place the cursor.
3. Click + drag to select a region.
4. Read the selection in the Inspector (normal and reverse order).
5. Edit bytes by typing in HEX mode (0–9/A–F) or ASCII mode (printable chars).
6. Right‑click for actions like Swap bytes, XOR, Fill, Copy, Paste.
7. Click Save to write the modified file.

4) Navigation & Editing

Mouse

• Left click: set cursor
• Drag: select a range
• Mouse wheel: scroll a few rows
• Right click: open menu (Swap bytes / XOR / Fill / Copy / Paste / Select All)

Keyboard (movement)

• ↑/↓: move by one row (8 or 16 bytes)
• ←/→: move by one byte
• PageUp/PageDown: jump by one screen

Keyboard (editing)

• HEX mode: type two hex digits to write one byte (first digit = high nibble, second = low nibble)
• ASCII mode: type printable characters to write bytes directly

5) Selection (why it matters)

Many tools operate on the selection. If nothing is selected, some operations apply to the current byte (coloring) or the whole file (XOR/FILL scripts and some menu actions).

• Inspector reads/writes the selection (or current byte if no selection)
• Checksum values are computed from the selection
• Markers/colors apply to the selection range
• Right‑click tools apply to the selection (or entire file if no selection)
• Scripts typically operate on the selection

6) Buttons & Features

7) Tabs, Compare, Master buffer

Tabs

• Each opened file becomes a tab. Click tab to activate.
• Click x on a tab to close it.

Tab right‑click menu

• Compare to…: compare this tab to another open tab; differences are highlighted.
• Set as master: marks this tab as the “master buffer” (used by Apply in the color bar).

Compare highlighting

After compare, differing bytes are highlighted (often shown with strong color, e.g. red text).

8) Colors / Markers + Apply

What markers are for

• Mark map/table areas
• Label checksum blocks
• Highlight “do not touch” areas
• Keep place while exploring big EEPROM files

How to apply a color

1. Select a range (drag) or place cursor on a byte.
2. Click a color square in the color bar.
3. If a range is selected: the whole range is marked and the selection is cleared.
4. If no selection: the current byte is marked and cursor advances by 1 byte.

Apply checkbox (master vs current)

• Apply ON: markers are written into the master buffer (set via tab right‑click → Set as master).
• Apply OFF: markers are written only into the current active buffer.

Clear markers

Right‑click in the hex view → Clear markers removes all marker colors from the target buffer.

9) Right‑Click Menu (Swap bytes, XOR, Fill…)

Right‑click inside the hex view to open the context menu.

10) Inspector

Inspector reads the selection (or current byte) and shows numeric representations in two ways: Normal order (file order) and Reverse order (byte-reversed for little-endian).

Editing using Inspector

• Type into HEX or DEC fields to overwrite the selected bytes.
• Input is padded to match selection size.
• If invalid/out-of-range, the field becomes highlighted (error color) until corrected.

11) Checksum box

The checksum panel shows quick integrity values for your selection:

• SUM: 8-bit sum of bytes (mod 0x100)
• XOR: 8-bit XOR of bytes
• SUM16: 16-bit sum of bytes (mod 0x10000)

12) Expression (EXPR)

EXPR is a mini calculator. It evaluates your expression using variables created from the selection.

Variables

hex, dec        # selection interpreted as an integer (normal order)
hex_inv         # selection bytes inverted (per-byte XOR FF), as integer
dec_inv         # complement inside selection bit-width

rhex, rdec      # selection interpreted as integer in reverse order (little-endian)
rhex_inv        # inverted + reversed, as integer
rdec_inv        # complement of reversed integer

sel             # list of selected byte values, e.g. [0x12, 0x34, 0x56]

Examples

# 2-byte selection interpreted as little-endian decimal:
rdec

# Sum of bytes:
sum(sel) & 0xFFFF

# Add offset:
hex + 16

# XOR with a constant:
hex ^ 0x55

13) Scripts panel

Scripts are built-in helpers (left panel) that operate on your selection. Use Read scripts to calculate values and Write scripts to modify bytes.

How to use

1. Select a range (or leave no selection if you want the “whole file” behavior in some scripts).
2. Press Scripts to open the panel.
3. Choose a script name.
4. Press Read (outputs info) or Write (applies changes).

Included scripts

14) Clipboard formats

• Copy selection: right-click → Copy (or Ctrl+C)
• Paste: right-click → Paste… (or Ctrl+V)

Paste rules

• If clipboard looks like HEX, separators are ignored and bytes are parsed (ex: DE AD BE EF, DE,AD,BE,EF).
• Otherwise, text is pasted as raw bytes (ASCII/Latin-1 style).

15) Performance Mode + Autosave

Performance Mode

Designed for very large binaries. When enabled, HEX-MASTER reduces live refresh work to keep scrolling and editing fast.

Autosave

HEX-MASTER periodically writes an autosave file (for crash recovery) when changes exist. You can document the autosave name/location here if you want users to recover it manually.

How to Use (full workflow)

New tools: use Auto‑Find XOR checksum byte to locate checksum bytes fast, and use the Checksum Status Badge to confirm blocks validate (XOR OK) after edits.

1. Open your dump file.
2. Inspect: select bytes and read values in Inspector (normal and reverse).
3. Mark: color regions (maps, checksum blocks, “don’t touch” areas).
4. Edit: type in hex/ASCII, or overwrite through Inspector DEC/HEX fields.
5. Transform: right-click tools (Swap bytes, XOR, Fill) for region operations.
6. Validate: look at checksum box and compare tabs to confirm what changed.
7. Save the new file.

16) Showcase / examples

Example A — Mark a known region (map/table)

1. Navigate to the region.
2. Drag to select the region.
3. Click a color in the marker bar (blue for maps, yellow for checksum area, gray for “do not edit”, etc.).

Example B — Edit a 16-bit little-endian value

1. Select exactly 2 bytes.
2. Use Reverse order → DEC to read the little-endian number.
3. Type a new value in that field to overwrite the two bytes.

Example C — Compare original vs modified

1. Open original, open modified.
2. Right-click original tab → Set as master.
3. Right-click modified tab → Compare to… → choose original.
4. Differences are highlighted; add markers to label each changed area.

Example D — XOR a selected block

1. Select a block.
2. Right‑click → XOR… → enter FF to invert all bits in that region.
3. Check Inspector/checksums to confirm effect.

16A) Auto‑Find XOR Checksum Byte

16B) Checksum Status Badge

17) Tips & safety

• Keep backups of the original file. Work on copies.
• Change small regions and validate with compare + checksum box.
• Be careful with XOR/FILL when nothing is selected (whole-file operation).
• For real ECU flashing workflows, confirm required checksum/CRC correction with your specialized tools.

16C) Checksum Finder (XOR / SUM8 / SUM16 / CRC16)

Purpose: Many dumps are protected by different checksum styles. This tool helps you locate where a checksum byte/word is, by scanning around your selection and testing common rules.

Where to find it

• Right‑click inside the hex area → Checksum Finder...

What it can search

Profiles & safety levels

• Generic (Manual): You choose an algorithm and offsets. Fix is available because you are explicitly defining the rule.
• Bosch EDC16 ST95320 4KB EEPROM: “Verified” mode in HEX‑MASTER. Fix is enabled only when the opened file is exactly 0x1000 bytes (4KB EEPROM dump). If size does not match, HEX‑MASTER switches to read‑only / Find only.
• Bosch EDC16CP ST95320 4KB EEPROM: Same verified EEPROM checksum family as the EDC16 ST95320 profile (SUM16 → XOR with 0xFFFF → subtract block number). Fix is enabled only when the file size is exactly 0x1000 (4KB).
• ME7 / MED17 / EDC17 / other flashes: shown as Verify‑only unless you provide a known checksum map. Use Checksum Map Runner… with a validated map for that ECU/software.

• XOR8 (inclusive): finds an end (or start) position where XOR(block) equals your target (default 00).
• SUM8 (inclusive): finds a position where SUM(block) mod 256 equals your target (default 00).
• SUM16 (inclusive): finds a position where SUM(block) mod 65536 equals your target (default 0000).
• CRC16 (stored): checks common CRC16 variants where the last 2 bytes (or first 2 bytes when searching backward) are the stored CRC of the protected data.
• Bosch EDC16 ST95320 EEPROM (SUM16^FFFF - block#): Bosch-style 16-bit checksum used in some EEPROM layouts (sum bytes, invert with 0xFFFF, then subtract the block number). Stored as a 2-byte value at the end of the protected block.

How it works (simple)

1. Select the suspected protected data block (usually without the checksum bytes).
2. Open Checksum Finder...
3. Choose algorithm (XOR/SUM/CRC), target (if applicable), endianness (for 16‑bit), direction, search window, and checksum length.
4. Click Find. HEX‑MASTER will extend your selection to the matching boundary and outline the found checksum bytes in green.

Recommended settings (real automotive use)

• Clusters / EEPROM blocks: start with XOR8 target 00, window 64–256 bytes.
• Simple additive protected blocks: try SUM8 target 00 (or SUM16 target 0000) and set checksum length 1 or 2.
• ECU areas: try CRC16/CCITT‑FALSE and CRC16/MODBUS first (checksum length 2). Use both endianness if unsure.
• Bosch EDC16 ST95320 4KB EEPROM: choose profile Bosch EDC16 ST95320 4KB EEPROM (or algorithm Bosch EDC16 ST95320 EEPROM (SUM16^FFFF - block#)). Select the protected data bytes only, set Block number (commonly 4 in many blocks), and set Endian to match how the two checksum bytes are stored in your dump.

Important note (avoid false matches)

This is a pattern finder. Large windows can produce accidental matches. For best results:

• Use a small, correct block (don’t scan the whole file).
• If you find a match, verify by changing 1 byte in the block and confirming the checksum rule breaks, then fixing checksum and confirming it becomes valid again.

New in v4: “stored elsewhere”, “Fix”, custom CRC params, and checksum maps

• Stored elsewhere: Some ECUs store the checksum in a different address (not directly at the end/start of the block). Choose an algorithm like CRC16 (stored elsewhere) or XOR8 (stored elsewhere), then choose a Search scope:
  • near selection: scans forward/backward within the window
  • entire file: scans the whole dump
  • custom range: scans only between your start/end offsets
  When a match is found, HEX-MASTER keeps your data selection and highlights the checksum bytes wherever they are stored.
• Fix button: Use Fix to write the correct checksum value.
  • For (checksum at end) algorithms, HEX-MASTER writes right after your selection.
  • For (checksum at start) algorithms, HEX-MASTER writes right before your selection.
  • For (stored elsewhere), set Fix checksum at offset (hex) to the target address.
  This is useful after you edit bytes and want to restore a valid checksum quickly.
• Custom CRC parameters: Some OEMs use CRCs with different polynomials / init / xorout / reflection. Choose CRC16 (custom params, stored at end) or CRC32 (custom params, stored at end) and fill: poly, init, xorout, and refin/refout. (If you are not sure, start with a known CRC preset first.)
• Checksum Map Runner (multi-segment ECU flash workflows): Many ECU flashes have multiple checksum regions. Use Right click → Checksum Map Runner… to load a JSON map and compute (and optionally write) all checksums in one step. You can also generate a ready template with Right click → Export Checksum Map Template….

Checksum map JSON format (quick example)

Each segment defines a data range, an algorithm, and a store address where the checksum is saved.

{
  "name": "Example ECU map",
  "segments": [
    {"data_start":"0x1000","data_end":"0x1FFF","algo":"CRC16",
     "store_at":"0x2000","store_len":2,"endian":"big",
     "params":{"variant":"CRC-16/CCITT-FALSE"}}
  ]
}

Tip: For Bosch/VAG style “checksum tables”, you normally represent each table entry as a segment in the JSON map. HEX-MASTER does not guess OEM tables automatically (they differ by ECU family), but it gives you a clean way to apply a verified map.