Added value compare type and Undo scan features

Author: Stridemann

StructureSpiderAdvanced/MainViewModel.cs

@@ -15,6 +15,7 @@ public MainViewModel()
         {
             Instance = this;
             DataTypes.AddRange(Enum.GetValues(typeof(DataType)) as IEnumerable<DataType>);
+            DataCompareTypes.AddRange(Enum.GetValues(typeof(DataCompareType)) as IEnumerable<DataCompareType>);
             StringCompareTypes.AddRange(Enum.GetValues(typeof(StringCompareType)) as IEnumerable<StringCompareType>);
         }
 
@@ -103,6 +104,17 @@ public int ValuesScanned
                 RaisePropertyChanged(nameof(ValuesScanned));
             }
         }
+
+        private bool canUndoScan;
+        public bool CanUndoScan
+        {
+            get => canUndoScan;
+            set
+            {
+                canUndoScan = value;
+                RaisePropertyChanged(nameof(CanUndoScan));
+            }
+        }
         ////////////////////////////////////////////////
         public ObservableCollection<VisibleResult> VisibleResults { get; set; } = new AsyncObservableCollection<VisibleResult>();
         public void AddRezultAsync(VisibleResult rezult)
@@ -138,17 +150,28 @@ public ushort Alignment
             }
         }
 
-        private DataType selectedDataType = DataType.Pointer;
+        private DataType _selectedDataType = DataType.Pointer;
         public DataType SelectedDataType
         {
-            get { return selectedDataType; }
+            get => _selectedDataType;
             set
             {
-                selectedDataType = value;
+                _selectedDataType = value;
                 RaisePropertyChanged(nameof(SelectedDataType));
             }
         }
 
+        private DataCompareType _compareType = DataCompareType.Equal;
+        public DataCompareType CompareType
+        {
+            get => _compareType;
+            set
+            {
+                _compareType = value;
+                RaisePropertyChanged(nameof(CompareType));
+            }
+        }
+
         public long StartSearchAddress { get; set; } = 0x0;
 
 
@@ -210,6 +233,7 @@ public bool UseEndOffsets
         ////////////////////////////////////////////////
         public List<int> MaxLevels { get; set; } = new List<int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
         public List<DataType> DataTypes { get; set; } = new List<DataType>();
+        public List<DataCompareType> DataCompareTypes { get; set; } = new List<DataCompareType>();
         public List<ushort> Alignments { get; set; } = new List<ushort>() { 1, 2, 4, 8 };
         public List<StringCompareType> StringCompareTypes { get; set; } = new List<StringCompareType>();
     }
@@ -222,20 +246,30 @@ public enum StringCompareType
         EndsWith
     }
 
-    public enum DataType
-    {
+    public enum DataType
+    {
         Pointer,
-        Int,
-        UInt,
-        Short,
-        UShort,
-        Byte,
-        Long,
-        Float,
-        String, 
+        Int,
+        UInt,
+        Short,
+        UShort,
+        Byte,
+        Long,
+        Float,
+        String, 
         StringU,
     }
 
+    public enum DataCompareType
+    {
+        Equal,
+        Bigger,
+        BiggerOrEqual,
+        Less,
+        LessOrEqual,
+        NotEqual
+    }
+
     public class VisibleResult : BindableBase
     {
         public int Level { get; set; }
@@ -252,6 +286,8 @@ public string Address
             }
         }
 
+        public IComparable ComparableValue { get; set; }
+
         private string value;
         public string Value
         {

StructureSpiderAdvanced/MainWindow.xaml

@@ -82,11 +82,16 @@
 					</Binding>
 				</TextBox.Text>
 			</TextBox>
-
+            
 			<ComboBox materialDesign:HintAssist.Hint="Alignment" ToolTip="Scan step. For x32 bit process pointers and strings recommended alignment value is 4, for x64 recommended value is 8" Style="{StaticResource MaterialDesignFloatingHintComboBox}" 
 					  ItemsSource="{Binding Path=ViewModel.Alignments}" SelectedValue="{Binding Path=ViewModel.Alignment}" IsEnabled="{Binding Path=ViewModel.InterfaceEnabled}"
 					  MinWidth="50" Margin="5" Foreground="#FFC8C8C8"/>
 
+			<ComboBox materialDesign:HintAssist.Hint="Compare type" Style="{StaticResource MaterialDesignFloatingHintComboBox}" 
+			          ItemsSource="{Binding Path=ViewModel.DataCompareTypes}" SelectedValue="{Binding Path=ViewModel.CompareType}" 
+			          MinWidth="80" Margin="5" Foreground="#FFC8C8C8" SelectionChanged="OnSearchTypeChanged" IsEnabled="{Binding Path=ViewModel.InterfaceEnabled}"
+			          Visibility="{Binding Path=ViewModel.SelectedDataType, Converter={StaticResource ScanTypeToVisibilityConverter}, ConverterParameter=NotString}"/>
+
 			<TextBox materialDesign:HintAssist.Hint="String Length" ToolTip="Maximum length of string bytes to read" Style="{StaticResource MaterialDesignFloatingHintTextBox}" 
 					 VerticalContentAlignment="Center" Margin="5" MinWidth="50" Foreground="#FFC8C8C8"
 					 IsEnabled="{Binding Path=ViewModel.InterfaceEnabled}" 
@@ -108,6 +113,7 @@
 					  Foreground="#FFC8C8C8" Visibility="{Binding Path=ViewModel.SelectedDataType, Converter={StaticResource ScanTypeToVisibilityConverter}, ConverterParameter=StringLength}"/>
 
 			<Button Name="SearchButton" Content="Search" HorizontalAlignment="Left" VerticalAlignment="Top" Width="80" Margin="5" Click="SearchButtonClick"/>
+			<Button Name="UndoScanButton" Content="Undo Scan" HorizontalAlignment="Left" VerticalAlignment="Top" Width="100" Margin="5" Click="UndoScan" IsEnabled="{Binding Path=ViewModel.CanUndoScan}"/>
 
 		</StackPanel>
 		<GridSplitter Grid.Row="3" HorizontalAlignment="Stretch" Height="10"></GridSplitter>

StructureSpiderAdvanced/MainWindow.xaml.cs

@@ -141,6 +141,7 @@ private void UpdateListOfProcesses()
         }
 
         /// GUI buttons ////////////////////////////////////////////////
+
         private void SearchButtonClick(object sender, RoutedEventArgs e)
         {
             if (!ViewModel.InterfaceEnabled)
@@ -168,12 +169,34 @@ private void SearchButtonClick(object sender, RoutedEventArgs e)
             SearchButton.Content = "Cancel";
             ViewModel.InterfaceEnabled = false;
 
+            BackupLastScan();
             ViewModel.VisibleResults.Clear();
 
             SearchThread = new Thread(SearchAsync);
             SearchThread.Start();
         }
 
+        private Stack<AsyncObservableCollection<VisibleResult>> PrevScanBackup = new Stack<AsyncObservableCollection<VisibleResult>>();
+
+        private void BackupLastScan()
+        {
+            if (ViewModel.VisibleResults.Count > 0)
+            {
+                PrevScanBackup.Push(new AsyncObservableCollection<VisibleResult>(ViewModel.VisibleResults));
+            }
+            ViewModel.CanUndoScan = PrevScanBackup.Count > 0;
+        }
+
+        private void UndoScan(object sender, RoutedEventArgs e)
+        {
+            if (PrevScanBackup.Count > 0)
+            {
+                ViewModel.VisibleResults = PrevScanBackup.Pop();
+            }
+
+            ViewModel.CanUndoScan = PrevScanBackup.Count > 0;
+        }
+
         private void RefreshProcesses(object sender, RoutedEventArgs e)
         {
             UpdateListOfProcesses();
@@ -203,6 +226,7 @@ private void DeleteBrokenPointers(object sender, RoutedEventArgs e)
 
         private void FilterValues(object sender, RoutedEventArgs e)
         {
+            BackupLastScan();
             RefreshTable(RezultRefreshType.FilterValues);
         }
 
@@ -216,7 +240,7 @@ private void RefreshTable(RezultRefreshType refreshType)
 
             var startPointer = new IntPtr(ViewModel.StartSearchAddress);
 
-            var convertedCompareValue = comparer.ConvertCompareValue(ViewModel.ScanValue);
+            var convertedCompareValue = comparer.ConvertToComparableValue(ViewModel.ScanValue);
 
             foreach (var pointer in ViewModel.VisibleResults.ToList())
             {

StructureSpiderAdvanced/Memory.cs

@@ -33,7 +33,7 @@ public byte[] ReadBytes(IntPtr addr, int length)
             return ReadMem(addr, length);
         }
 
-        public int ReadByte(IntPtr addr)
+        public byte ReadByte(IntPtr addr)
         {
             var bytes = ReadMem(addr, 1);
             return bytes[0];

StructureSpiderAdvanced/Scanner.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Windows.Forms;
+using StructureSpiderAdvanced.ValueReaders;
+using StructureSpiderAdvanced.ValueReaders.Base;
 
 namespace StructureSpiderAdvanced
 {
@@ -22,36 +24,36 @@ public Scanner(MainViewModel viewModel, Memory m)
             MVM.PointersEvaluated = 0;
             MVM.ValuesScanned = 0;
 
-            var pLength = (ushort)M.PointerLength;
+            var pLength = (ushort) M.PointerLength;
 
             if (viewModel.SelectedDataType == DataType.Pointer ||
                 viewModel.SelectedDataType == DataType.String ||
                 viewModel.SelectedDataType == DataType.StringU
-                )
+            )
             {
-                if(MVM.Alignment != pLength)
+                if (MVM.Alignment != pLength)
                 {
                     var bits = m.Is64Bit ? "x64" : "x32";
 
                     var result = MessageBox.Show($"Do you really want to scan with alignment {MVM.Alignment} " +
-                        $"(For {bits} process structure alignment is {pLength})? " + Environment.NewLine +
-                        $"For this scan type recommended value is {pLength}" + Environment.NewLine +
-                        $"Yes - continue using {MVM.Alignment}" + Environment.NewLine +
-                        $"No - set to {pLength} (Recommended)", "Alighnment", MessageBoxButtons.YesNo);
+                                                 $"(For {bits} process structure alignment is {pLength})? " + Environment.NewLine +
+                                                 $"For this scan type recommended value is {pLength}" + Environment.NewLine +
+                                                 $"Yes - continue using {MVM.Alignment}" + Environment.NewLine +
+                                                 $"No - set to {pLength} (Recommended)", "Alighnment", MessageBoxButtons.YesNo);
 
                     if (result == DialogResult.No)
                         MVM.Alignment = pLength;
                 }
             }
 
             var scansCount = MVM.MaxScanLength / MVM.Alignment;
-            MVM.MaxScanLength = (ushort)(scansCount * MVM.Alignment);
+            MVM.MaxScanLength = (ushort) (scansCount * MVM.Alignment);
 
             ValueReader = GetValueReaderByDataType(viewModel.SelectedDataType, M, MVM);
             ValueReader.SetCompareValue(MVM.ScanValue);
 
             var startPointer = new IntPtr(MVM.StartSearchAddress);
-            PossibleSubPointers.Enqueue(new SubClassScan() { Address = startPointer });
+            PossibleSubPointers.Enqueue(new SubClassScan() {Address = startPointer});
             MVM.PointersFound = 1;
 
             while (PossibleSubPointers.Count > 0)
@@ -89,7 +91,7 @@ public static BaseValueReader GetValueReaderByDataType(DataType dataType, Memory
                     return new UStringValueReader(m, mvm);
                 default:
                     throw new NotImplementedException($"Scan type is not defined in code: {dataType}");
-            } 
+            }
         }
 
         private void DoScan(SubClassScan subScan)
@@ -109,29 +111,41 @@ private void DoScan(SubClassScan subScan)
                     {
                         var longPointer = ValueReader.LastReadPointer.ToInt64();
                         allowAdd = !ProcessedPointers.Contains(longPointer);
+
                         if (allowAdd)
                             ProcessedPointers.Add(longPointer);
                     }
 
                     if (allowAdd)
                     {
-                        var newPointer = new SubClassScan() { Address = ValueReader.LastReadPointer, Level = subScan.Level + 1, };
+                        var newPointer = new SubClassScan() {Address = ValueReader.LastReadPointer, Level = subScan.Level + 1,};
+
                         newPointer.Offsets = new List<int>(subScan.Offsets)
                         {
                             offset
                         };
+
                         PossibleSubPointers.Enqueue(newPointer);
                         MVM.CurrentEntries = PossibleSubPointers.Count;
                         MVM.PointersFound++;
                     }
                 }
 
                 var readCompareRezult = ValueReader.ReadCompareValue(scanAddress);
-                if (readCompareRezult.IsEqual)
+
+                if (readCompareRezult.IsSatisfying)
                 {
-                    var newScanResult = new VisibleResult() { Offsets = new List<int>(subScan.Offsets) { offset }, Address = scanAddress.ToString("x"), Level = subScan.Level, Value = readCompareRezult.DisplayValue};
+                    var newScanResult = new VisibleResult()
+                    {
+                        Offsets = new List<int>(subScan.Offsets) {offset}, 
+                        Address = scanAddress.ToString("x"), 
+                        Level = subScan.Level, 
+                        Value = readCompareRezult.DisplayValue,
+                        ComparableValue = readCompareRezult.ComparableValue,
+                    };
                     MVM.AddRezultAsync(newScanResult);
                 }
+
                 MVM.ValuesScanned++;
             }
         }