string GetValue(IByteProvider provider, long pos, long length)
{
// Read out the bytes
if ((_hasher != null) && (provider != null) && (pos + length <= provider.Length))
{
byte[] data = new byte[length];
for (long i = 0; i < length; i++)
{
data[i] = provider.ReadByte(pos + i);
}
byte[] hash = _hasher.ComputeHash(data);
StringBuilder builder = new StringBuilder();
foreach (byte b in hash)
{
builder.AppendFormat("{0:X02}", b);
}
return(builder.ToString());
}
else
{
return("");
}
}
public void SetByteProvider(IByteProvider provider)
{
ByteProvider = provider;
UpdateScrollbar();
Invalidate();
}
/// <summary>
/// Shows the bits for the current byte
/// </summary>
/// <returns>A string that is like "Bits of byte n° XXX : XXXXXXXX"</returns>
string Core_ShowBits()
{
string result = "";
byte? currentByte = null;
IByteProvider currentFile = CurrentTabIsROM() ?
MainHexBox.ByteProvider :
FileHexBoxes[CurrentTab].ByteProvider;
uint selection = CurrentAddress;
if (selection < currentFile.Length)
{
currentByte = currentFile.ReadByte(selection);
}
BitInfo bitInfo = (currentByte == null) ? null :
new BitInfo((byte)currentByte, selection);
if (bitInfo != null)
{
byte currentByteNotNull = (byte)currentByte;
result = "Bits: " + bitInfo.ToString();
}
return(result);
}
public void OpenFile(string file)
{
this.Text = file;
ByteProvider = new FileByteProvider(file);
HexView.SetByteProvider(ByteProvider);
}
private static string GetFixedValue(IByteProvider provider, long start, long length, int fixed_length, bool reverse, Func <byte[], string> func)
{
long max_length = provider.Length - start;
if (max_length < fixed_length)
{
return(string.Empty);
}
byte[] ba = new byte[fixed_length];
if (reverse)
{
for (int i = 0; i < fixed_length; ++i)
{
ba[fixed_length - i - 1] = provider.ReadByte(i + start);
}
}
else
{
for (int i = 0; i < fixed_length; ++i)
{
ba[i] = provider.ReadByte(i + start);
}
}
return(func(ba));
}
public void SetByteProvider(Win32Assembly assembly, IByteProvider provider)
{
fileOffsetBox.Clear();
rvaOffsetBox.Clear();
vaOffsetBox.Clear();
this.assembly = assembly;
hexBox.ByteProvider = provider;
}
private byte[] ByteProviderToArray(IByteProvider b)
{
byte[] data = new byte[b.Length];
for (int i = 0; i < b.Length; i++)
{
data[i] = b.ReadByte(i);
}
return(data);
}
private byte[] getSelectedBytes(int len)
{
IByteProvider p = hexBox1.ByteProvider;
byte[] b = new byte[len];
for (int i = 0; i < len; i++)
{
b[i] = p.ReadByte(hexBox1.SelectionStart + i);
}
return b;
}
string GetValue(IByteProvider provider, long pos, long len)
{
string ret = null;
try
{
ret = _inspector.Inspect(new HexInspectorData(provider), pos, len);
}
catch
{
}
return(ret ?? String.Empty);
}
private static string GetUnixTime(IByteProvider provider, long pos, bool littleEndian)
{
byte[] data = GetBytesFromProvider(provider, pos, 4);
if (data != null)
{
DateTime t = new DateTime(1970, 1, 1);
return(t.AddSeconds((double)BitConverter.ToUInt32(data, 0)).ToString());
}
else
{
return("?");
}
}
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
if (e.Node.Name != "")
{
try
{
int off = Convert.ToInt32(e.Node.Name);
IByteProvider db = hb1.ByteProvider;
if (off >= 0 && off < db.Length)
{
hb1.SelectionStart = off;
hb1.SelectionLength = 1;
}
}
catch (Exception ex)
{
}
}
TreeNode t = e.Node;
if (t.Parent != null && t.Parent.Text == "Materials")
{
try
{
string s = t.Text;
for (int i = 0; i < s.Length; i++)
{
if (s[i] == '#')
{
s = s.Substring(i + 1);
}
}
int idx = Convert.ToInt32(s) - 1;
for (int i = 0; i < Materials.Count; i++)
{
if (Materials[i] == idx)
{
toolStripComboBox1.SelectedIndex = i;
}
}
}
catch (Exception ex)
{
}
}
}
string GetValue(IByteProvider provider, long pos, long length)
{
ulong ret = 0;
int bytePos = 0;
while (pos < provider.Length)
{
byte b = provider.ReadByte(pos++);
ret |= ((ulong)b & 0x7F) << (bytePos++ *7);
if ((b & 0x80) == 0)
{
break;
}
}
return(string.Format("{0}/0x{0:X08}", ret));
}
private static byte[] GetBytesFromProvider(IByteProvider provider, long pos, long length)
{
byte[] data = null;
// Read out the bytes
if ((provider != null) && (pos + length <= provider.Length))
{
data = new byte[length];
for (long i = 0; i < length; i++)
{
data[i] = provider.ReadByte(pos + i);
}
}
return(data);
}
private string GetIntegerValue <T>(IByteProvider provider, long pos, bool littleEndian) where T : struct
{
GenericDataValue <T> value = new GenericDataValue <T>("", new T(), littleEndian);
byte[] data = GetBytesFromProvider(provider, pos, Marshal.SizeOf(typeof(T)));
if (data != null)
{
value.FromArray(data);
return(String.Format("{0}/0x{0:X}", value.Value));
}
else
{
return("?");
}
}
private string GetIpAddress(IByteProvider provider, long pos, bool littleEndian, bool ipv6)
{
byte[] data = GetBytesFromProvider(provider, pos, ipv6 ? 16 : 4);
if (data != null)
{
if (littleEndian)
{
data = data.Reverse().ToArray();
}
IPAddress addr = new IPAddress(data);
return(addr.ToString());
}
return("?");
}
public SignatureScan(String pattern, IByteProvider provider, int result = 1)
{
ByteArray = new List <byte>();
Mask = new List <byte>();
Pattern = pattern;
Provider = provider;
Result = result;
PatternSize = 0;
if (!String.IsNullOrEmpty(Pattern))
{
Pattern = Pattern.Replace(" ? ", " ?? ");
while (Pattern.EndsWith(" ") || Pattern.EndsWith("?"))
{
Pattern = Pattern.Substring(0, Pattern.Length - 1);
}
{
String data = Pattern;
data = data.Replace(" ", "");
if (data.Length % 2 == 0 && data.Length > 0)
{
PatternSize = data.Length / 2;
for (int i = 0; i < data.Length; i += 2)
{
if (data[i] == '?' && data[i + 1] == '?')
{
Mask.Add(1);
ByteArray.Add(0);
}
else
{
Mask.Add(0);
ByteArray.Add(Convert.ToByte(data[i].ToString() + data[i + 1].ToString(), 16));
}
}
}
}
}
}
string GetValue(IByteProvider provider, long pos, long length)
{
// Read out the bytes
if ((provider != null) && (pos + length <= provider.Length))
{
byte[] data = new byte[length];
for (long i = 0; i < length; i++)
{
data[i] = provider.ReadByte(pos + i);
}
return(GetChecksumString(data));
}
else
{
return("");
}
}
/// <summary>
/// Manages enabling or disabling of menu items and toolstrip buttons.
/// </summary>
void Update_FileMenu()
{
IByteProvider hexbox = CurrentTabIsROM() ?
MainHexBox.ByteProvider :
FileHexBoxes[CurrentTab].ByteProvider;
if (hexbox.HasChanges())
{
Menu_File_Save.Enabled = true;
}
else
{
Menu_File_Save.Enabled = false;
}
Menu_File_Close.Enabled = !CurrentTabIsROM();
string romfile = CurrentTabIsROM() ? "ROM" : "File";
Menu_File_Save.Text = "Save " + romfile + "...";
Menu_File_SaveAs.Text = "Save " + romfile + " As...";
}
private void SetBytes(byte[] bytes)
{
if (_provider != null)
{
_provider.Changed -= _provider_Changed;
}
if (hexBox.ReadOnly)
{
_provider = new ReadOnlyByteProvider(bytes);
}
else
{
_provider = new DynamicByteProvider(bytes);
}
_provider.Changed += new EventHandler(_provider_Changed);
hexBox.ByteProvider = _provider;
UpdateInspector(true);
}
private static string GetFileTime(IByteProvider provider, long pos, bool littleEndian)
{
byte[] data = GetBytesFromProvider(provider, pos, 8);
if (data != null)
{
long ft = BitConverter.ToInt64(data, 0);
if (ft >= 0)
{
try
{
return(DateTime.FromFileTimeUtc(BitConverter.ToInt64(data, 0)).ToString());
}
catch (ArgumentOutOfRangeException)
{
// Do nothing
}
}
}
return("?");
}
internal HexInspectorData(IByteProvider provider)
{
_provider = provider;
}
internal HexInspectorData(IByteProvider provider)
{
_provider = provider;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="byteIndexProvider">Provider of byte indexes..</param>
/// <param name="byteProvider">Provider of bytes to use.</param>
public ByteProvidedProcessorBase(ByteIndexProviderBase byteIndexProvider, IByteProvider byteProvider)
: base(byteIndexProvider)
{
ByteProvider = byteProvider ?? throw new ArgumentNullException(nameof(byteProvider));
}
public void OpenMemory(IByteProvider bp)
{
hexBox.ByteProvider = bp;
DisplayText();
UpdateFileSizeStatus();
ManageAbility();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="byteRule">Byte rule to apply.</param>
/// <param name="byteProvider">Provider of bytes.</param>
/// <param name="operation">Mathematical operation to perform.</param>
/// <param name="wrapAround">If true, wraps the calculated byte if needed.</param>
public MathProcessor(ByteIndexProviderBase byteRule, IByteProvider byteProvider, Operation operation, bool wrapAround)
: base(byteRule, byteProvider)
{
OperationToPerform = operation;
WrapAround = wrapAround;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="byteRule">Byte rule to apply.</param>
/// <param name="byteProvider">Provider of bytes.</param>
public ReplaceProcessor(ByteIndexProviderBase byteRule, IByteProvider byteProvider)
: base(byteRule, byteProvider)
{
}
protected virtual void InitHexEditorOptions(
IByteProvider ByteProvider = null
, string Filename = ""
, bool ShowMnu_File = true
, bool ShowMnu_Tools = true
, bool ShowMnuItm_File_Exit = true
, bool ShowMnuItm_File_Open = true
, bool ShowMnuItm_File_Recent = true
, bool ShowMnuItm_File_Save = true
)
{
byteProvider = ByteProvider;
filename = Filename;
showMnu_File = ShowMnu_File;
showMnu_Tools = ShowMnu_Tools;
showMnuItm_File_Exit = ShowMnuItm_File_Exit;
showMnuItm_File_Open = ShowMnuItm_File_Open;
showMnuItm_File_Recent = ShowMnuItm_File_Recent;
showMnuItm_File_Save = ShowMnuItm_File_Save;
}
public hexEditorOptions(IByteProvider ByteProvider, string filnam = "")
{
InitHexEditorOptions(ByteProvider, filnam);
}
public string GetValue(IByteProvider provider, long start, long length)
{
return(_func(provider, start, length));
}
public void SetByteProvider(Win32Assembly assembly, IByteProvider provider)
{
fileOffsetBox.Clear();
rvaOffsetBox.Clear();
vaOffsetBox.Clear();
this.assembly = assembly;
hexBox.ByteProvider = provider;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="byteIndexProvider">Provider of byte indexes.</param>
/// <param name="byteProvider">Provider of byte values.</param>
/// <param name="direction">Direction to shift the bits.</param>
public BitShiftProcessor(ByteIndexProviderBase byteIndexProvider, IByteProvider byteProvider, ShiftDirection direction)
: base(byteIndexProvider, byteProvider)
{
Direction = direction;
}
