private void DisplayWinner(GameObject winner) { var blackTex = @"Contents\UI\Winners\blackWinsText.png"; var purpleTex = @"Contents\UI\Winners\purpleWinsText.png"; var car = winner as Car; if (car != null) { switch (car.id) { case "Black": EngineCore.AddGameObject(new UIElement(blackTex, new Vector2(0f, 0f))); EndGame(); break; case "Purple": EngineCore.AddGameObject(new UIElement(purpleTex, new Vector2(0f, 0f))); EndGame(); break; default: throw new Exception("There is nothing to display."); } } }
/// <summary> /// Creates a new snapshot of memory in the target process. Will not read any memory. /// </summary> /// <returns>The snapshot of memory taken in the target process.</returns> private Snapshot CreateSnapshotFromSettings() { MemoryProtectionEnum requiredPageFlags = SettingsViewModel.GetInstance().GetRequiredProtectionSettings(); MemoryProtectionEnum excludedPageFlags = SettingsViewModel.GetInstance().GetExcludedProtectionSettings(); MemoryTypeEnum allowedTypeFlags = SettingsViewModel.GetInstance().GetAllowedTypeSettings(); IntPtr startAddress, endAddress; if (SettingsViewModel.GetInstance().IsUserMode) { startAddress = IntPtr.Zero; endAddress = EngineCore.GetInstance().VirtualMemory.GetMaxUsermodeAddress().ToIntPtr(); } else { startAddress = SettingsViewModel.GetInstance().StartAddress.ToIntPtr(); endAddress = SettingsViewModel.GetInstance().EndAddress.ToIntPtr(); } List <ReadGroup> memoryRegions = new List <ReadGroup>(); IEnumerable <NormalizedRegion> virtualPages = EngineCore.GetInstance().VirtualMemory.GetVirtualPages( requiredPageFlags, excludedPageFlags, allowedTypeFlags, startAddress, endAddress); // Convert each virtual page to a snapshot region foreach (NormalizedRegion virtualPage in virtualPages) { memoryRegions.Add(new ReadGroup(virtualPage.BaseAddress, virtualPage.RegionSize)); } return(new Snapshot(null, memoryRegions)); }
public void InitializeEngine() { Directory.CreateDirectory($"{Environment.CurrentDirectory}/Object"); Directory.CreateDirectory($"{Environment.CurrentDirectory}/Animation"); Directory.CreateDirectory($"{Environment.CurrentDirectory}/Project"); Directory.CreateDirectory($"{Environment.CurrentDirectory}/Export"); var engineParameters = new EngineParameters { Handle = PictureAnimation.Handle, Width = PictureAnimation.Width, Height = PictureAnimation.Height }; var fontParameters = new EngineFontParameters { Name = "Tahoma", Size = 9f, Style = FontStyle.Regular }; engine = new EngineCore(engineParameters, fontParameters); UpdateClipArea(); AddLanguages(); }
/// <summary> /// Processes all pages, computing checksums to determine chunks of virtual pages that have changed. /// </summary> private void ProcessPages() { Boolean isOpenedProcess32Bit = EngineCore.GetInstance().Processes.IsOpenedProcess32Bit(); dynamic invalidPointerMin = isOpenedProcess32Bit ? (UInt32)UInt16.MaxValue : (UInt64)UInt16.MaxValue; dynamic invalidPointerMax = isOpenedProcess32Bit ? Int32.MaxValue : Int64.MaxValue; ConcurrentHashSet <IntPtr> foundPointers = new ConcurrentHashSet <IntPtr>(); // Add static bases List <SnapshotRegion> baseRegions = new List <SnapshotRegion>(); foreach (NormalizedModule normalizedModule in EngineCore.GetInstance().OperatingSystemAdapter.GetModules()) { baseRegions.Add(new SnapshotRegion(normalizedModule.BaseAddress, normalizedModule.RegionSize)); } ((dynamic)this.PrefilteredSnapshot).AddSnapshotRegions(baseRegions); lock (this.RegionLock) { List <SnapshotRegion> pointerRegions = new List <SnapshotRegion>(); foreach (IntPtr pointer in PointerCollector.GetInstance().GetFoundPointers()) { pointerRegions.Add(new SnapshotRegion(pointer.Subtract(ShallowPointerPrefilter.PointerRadius), ShallowPointerPrefilter.PointerRadius * 2)); } ((dynamic)this.PrefilteredSnapshot).AddSnapshotRegions(pointerRegions); this.processedCount = Math.Max(this.processedCount, this.PrefilteredSnapshot.GetRegionCount()); } }
/// <summary> /// Creates a new snapshot of memory in the target process. Will not read any memory. /// </summary> /// <returns>The snapshot of memory taken in the target process.</returns> public Snapshot CreateSnapshotFromSettings() { MemoryProtectionEnum requiredPageFlags = SettingsViewModel.GetInstance().GetRequiredProtectionSettings(); MemoryProtectionEnum excludedPageFlags = SettingsViewModel.GetInstance().GetExcludedProtectionSettings(); MemoryTypeEnum allowedTypeFlags = SettingsViewModel.GetInstance().GetAllowedTypeSettings(); IntPtr startAddress, endAddress; if (SettingsViewModel.GetInstance().IsUserMode) { startAddress = IntPtr.Zero; endAddress = EngineCore.GetInstance().VirtualMemory.GetUserModeRegion().EndAddress; } else { startAddress = SettingsViewModel.GetInstance().StartAddress.ToIntPtr(); endAddress = SettingsViewModel.GetInstance().EndAddress.ToIntPtr(); } List <SnapshotRegion> memoryRegions = new List <SnapshotRegion>(); IEnumerable <NormalizedRegion> virtualPages = EngineCore.GetInstance().VirtualMemory.GetVirtualPages( requiredPageFlags, excludedPageFlags, allowedTypeFlags, startAddress, endAddress); // Convert each virtual page to a snapshot region (a more condensed representation of the information) foreach (NormalizedRegion virtualPage in virtualPages) { memoryRegions.Add(new SnapshotRegion(virtualPage.BaseAddress, virtualPage.RegionSize)); } return(new Snapshot(memoryRegions)); }
private IntPtr ResolvePointer(Tuple <IntPtr, List <Int32> > fullPointer) { IntPtr pointer = fullPointer.Item1; List <Int32> offsets = fullPointer.Item2; if (offsets == null || offsets.Count == 0) { return(pointer); } Boolean successReading = true; foreach (Int32 offset in offsets) { pointer = EngineCore.GetInstance().OperatingSystemAdapter.Read <IntPtr>(pointer, out successReading); pointer = pointer.Add(offset); if (!successReading) { break; } } return(pointer); }
public void RulesThatCheckContextValue() { var identity = new Identity("device", "1"); var context = CreateContext(identity, new Tuple <string, JsonValue>("PartnerBrand", JsonValue.NewString("ABC"))); var rulesRepo = RulesRepositoryHelpers .With("path/to/key", FakeRule.Create(ctx => ctx("device.PartnerBrand") == JsonValue.NewString("ABC") ? new ConfigurationValue(JsonValue.NewString("SomeValue")) : Option <ConfigurationValue> .None)); var value = EngineCore.GetRulesEvaluator(new IdentityHashSet { identity }, context, rulesRepo)("path/to/key").Map(x => x.Value); Assert.Equal(JsonValue.NewString("SomeValue"), value); rulesRepo = rulesRepo .With("path/to/other/key", FakeRule.Create(ctx => ctx("device.OtherProp") == JsonValue.NewString("DEF") ? new ConfigurationValue(JsonValue.NewString("SomeValue")) : Option <ConfigurationValue> .None)); value = EngineCore.GetRulesEvaluator(new IdentityHashSet { identity }, context, rulesRepo)("path/to/other/key").Map(x => x.Value); Assert.True(value.IsNone); rulesRepo = rulesRepo .With("path/to/other/key", FakeRule.Create(ctx => ctx("device.PartnerBrand") == JsonValue.NewString("ABC") ? new ConfigurationValue(JsonValue.NewString("SomeValue")) : Option <ConfigurationValue> .None)); value = EngineCore.GetRulesEvaluator(new IdentityHashSet { identity }, context, rulesRepo)("path/to/other/key").Map(x => x.Value); Assert.Equal(JsonValue.NewString("SomeValue"), value); }
/// <summary> /// Run method for the injected library, invoked by EasyHook when injecting a wrapper process. /// </summary> /// <remarks> /// The GC won't unload the library as long as this method doesn't return. /// <br /> /// The Run() method should return if you want the injected library needs to be unloaded. /// Unhandled exceptions ARE NOT redirected automatically. /// As the connection to the host is established in <see cref="EngineCore.Initialize"/>, /// errors should be reported using <see cref="EngineCore.Log"/>. /// </remarks> /// <param name="inContext">Information about the environment in which the library main method has been invoked, used by the EasyHook library.</param> /// <param name="channelName">The name of the inter-process communication channel to connect to, used by the EasyHook library.</param> /// <param name="wrappedProcessExecutable">The executable containing the main method of the guest process.</param> /// <param name="args">Optional arguments to pass to the guest's main method.</param> public void Run(RemoteHooking.IContext inContext, string channelName, string wrappedProcessExecutable, string args) { try { InitializeForRun(); // Set the working directory to the one expected by the executable. Directory.SetCurrentDirectory(Path.GetDirectoryName(wrappedProcessExecutable)); // Run the main method of the wrapped process. string[] arguments = args.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); EngineCore.Log.Debug("Invoking main method of targeted guest... using #{0} method parameters{1}", arguments.Length, arguments.Length == 0 ? "" : ": " + args); var exitCode = AssemblyHelper.RunMainMethod(wrappedProcessExecutable, arguments.Length == 0 ? null : arguments); EngineCore.Log.Message("Target main method returned exitcode " + exitCode); // First attempt a clean shutdown, then try a forced shutdown. EngineCore.TerminateProcess(exitCode, ExitMethod.Request | ExitMethod.Kill); } catch (Exception e) { #if DEBUG if (Debugger.IsAttached) { Debugger.Break(); } #endif EngineCore.Log.Critical("An unexpected exception occured.", e); // Exit code 1067 = ERROR_PROCESS_ABORTED "The process terminated unexpectedly." if (!EngineCore.TerminateProcess(1067, ExitMethod.Request | ExitMethod.Kill)) { throw new ApplicationException("An unexpected fatal exception occured.", e); } } }
/// <summary> /// Creates a snapshot from modules in the selected process. /// </summary> /// <returns>The created snapshot.</returns> private Snapshot CreateSnapshotFromModules() { IEnumerable <ReadGroup> moduleGroups = EngineCore.GetInstance().VirtualMemory.GetModules().Select(region => new ReadGroup(region.BaseAddress, region.RegionSize)); Snapshot moduleSnapshot = new Snapshot(null, moduleGroups); return(moduleSnapshot); }
/// <summary> /// Determines if a process is 32 bit /// </summary> /// <param name="process">The process to check</param> /// <returns>Returns true if the process is 32 bit, otherwise false</returns> public Boolean IsProcess32Bit(NormalizedProcess process) { Boolean isWow64; // First do the simple check if seeing if the OS is 32 bit, in which case the process wont be 64 bit if (EngineCore.GetInstance().OperatingSystemAdapter.IsOperatingSystem32Bit()) { return(true); } // No process provided, assume 32 bit if (process == null) { return(true); } try { if (this.SystemProcess == null || !Native.NativeMethods.IsWow64Process(this.SystemProcess.Handle, out isWow64)) { // Error, assume 32 bit return(true); } } catch { // Error, assume 32 bit return(true); } return(isWow64); }
/// <summary> /// Update event for this project item. Resolves addresses and values. /// </summary> /// <returns>True if update was made, otherwise false.</returns> public override Boolean Update() { this.CalculatedAddress = this.ResolveAddress(); if (this.IsActivated) { // Freeze current value if this entry is activated Object value = this.AddressValue; if (value != null && value.GetType() == this.DataType) { this.WriteValue(value); } } else { // Otherwise we read as normal (bypass value setter and set value directly to avoid a write-back to memory) Boolean readSuccess; Object oldValue = addressValue; this.addressValue = EngineCore.GetInstance()?.VirtualMemory?.Read(this.DataType, this.CalculatedAddress, out readSuccess); if (this.AddressValue?.ToString() != oldValue?.ToString()) { this.RaisePropertyChanged(nameof(this.AddressValue)); return(true); } } return(false); }
/// <summary> /// Injects instructions at the specified location, overwriting following instructions. This will nop-fill. /// </summary> /// <param name="address">The injection address.</param> /// <param name="assembly">The assembly code to disassemble and inject into the code cave.</param> /// <returns>The address of the code cave.</returns> public UInt64 InjectCode(UInt64 address, String assembly) { this.PrintDebugTag(); assembly = this.ResolveKeywords(assembly); Int32 assemblySize = this.GetAssemblySize(assembly, address); Byte[] originalBytes = this.CollectOriginalBytes(address, assemblySize); if (originalBytes == null) { throw new Exception("Could not gather original bytes"); } // Determine number of no-ops to fill dangling bytes String noOps = (originalBytes.Length - assemblySize > 0 ? "db " : String.Empty) + String.Join(" ", Enumerable.Repeat("0x90,", originalBytes.Length - assemblySize)).TrimEnd(','); Byte[] injectionBytes = this.GetAssemblyBytes(assembly + "\n" + noOps, address); EngineCore.GetInstance().VirtualMemory.WriteBytes(address.ToIntPtr(), injectionBytes); CodeCave codeCave = new CodeCave(address, 0, originalBytes); this.CodeCaves.Add(codeCave); return(address); }
/// <summary> /// Resolves the address of an address, pointer, or managed object. /// </summary> /// <returns>The base address of this object.</returns> protected override IntPtr ResolveAddress() { IntPtr pointer = AddressResolver.GetInstance().ResolveModule(this.ModuleName); Boolean successReading = true; pointer = pointer.Add(this.ModuleOffset); if (this.PointerOffsets == null || this.PointerOffsets.Count() == 0) { return(pointer); } foreach (Int32 offset in this.PointerOffsets) { if (EngineCore.GetInstance().Processes.IsOpenedProcess32Bit()) { pointer = EngineCore.GetInstance().VirtualMemory.Read <Int32>(pointer, out successReading).ToIntPtr(); } else { pointer = EngineCore.GetInstance().VirtualMemory.Read <Int64>(pointer, out successReading).ToIntPtr(); } if (pointer == IntPtr.Zero || !successReading) { pointer = IntPtr.Zero; break; } pointer = pointer.Add(offset); } return(pointer); }
public IntPtr EvaluatePointer(IntPtr address, IEnumerable <Int32> offsets) { IntPtr finalAddress = address; if (!offsets.IsNullOrEmpty()) { // Add and trace offsets foreach (Int32 offset in offsets.Take(offsets.Count() - 1)) { Boolean success; if (EngineCore.GetInstance().Processes.IsOpenedProcess32Bit()) { finalAddress = (this.Read <UInt32>(finalAddress + offset, out success).ToInt64()).ToIntPtr(); } else { finalAddress = (this.Read <UInt64>(finalAddress, out success).ToInt64() + offset).ToIntPtr(); } } // The last offset is added, but not traced finalAddress = finalAddress.Add(offsets.Last()); } return(finalAddress); }
internal static void LoadZoneFile(string path, EngineCore engine) { using (var zip = ZipFile.OpenRead(path)) { using (var ms = new MemoryStream()) { using (var temp = zip.GetEntry("main.oes")?.Open()) temp?.CopyTo(ms); ms.Position = 0; var zone = OESFile.Read <OESZone>(ms); WriteLine($"Loading {zone.Name}"); engine.Add(FromMeshes(FromSkin(zone.Find <OESSkin>().First(), zip), new[] { Matrix4x4.Identity }, zone.Find <OESStaticMesh>())); var objInstances = zone.Find <OESObject>().ToDictionary(x => x, x => new List <Matrix4x4>()); zone.Find <OESInstance>().ForEach(inst => { objInstances[inst.Object].Add(Matrix4x4.CreateScale(inst.Scale) * Matrix4x4.CreateFromQuaternion(inst.Rotation) * Matrix4x4.CreateTranslation(inst.Position)); }); foreach (var(obj, instances) in objInstances) { engine.Add(FromMeshes( FromSkin(obj.Find <OESSkin>().First(), zip), instances.ToArray(), obj.Find <OESStaticMesh>() )); } zone.Find <OESLight>().ForEach(light => engine.AddLight(light.Position, light.Radius, light.Attenuation, light.Color)); } } }
static void Main(string[] args) { if (!Configuration.Open()) { MessageBox.Show("Arquivo de configuração não encontrado. O programa será fechado."); return; } Application.EnableVisualStyles(); GraphicsDisplay = new CreateDevice(); if (!EngineCore.InitializeDirectX()) { MessageBox.Show("Não foi possível inicializar o Direct3D. O programa será fechado."); return; } if (!EngineCore.InitializeEngine()) { MessageBox.Show("Não foi possível inicializar os recursos. O programa será fechado."); return; } GraphicsDisplay.Show(); Application.Idle += new EventHandler(GraphicsDisplay.OnApplicationIdle); Application.Run(GraphicsDisplay); }
/// <summary> /// Update event for this project item. Resolves addresses and values. /// </summary> public override void Update() { this.CalculatedAddress = this.ResolveAddress(); // Freeze current value if this entry is activated if (this.IsActivated) { Object value = this.AddressValue; if (value != null && value.GetType() == this.DataType) { this.WriteValue(value); } } else { Object previousValue = this.AddressValue; // Otherwise we read as normal (bypass assigning setter and set value directly to avoid a write-back to memory) this.addressValue = EngineCore.GetInstance()?.VirtualMemory?.Read(this.DataType, this.CalculatedAddress, out _); if (!(this.AddressValue?.Equals(previousValue) ?? false)) { this.RaisePropertyChanged(nameof(this.AddressValue)); this.RaisePropertyChanged(nameof(this.DisplayValue)); } } }
public void Ensure_Registered_Properties_Are_Injected() { var collection = new ServiceCollection(); string expectedValue = "TestValue"; collection.AddSingleton(new TestViewModel() { Title = expectedValue }); var propertyInjector = new PropertyInjector(collection.BuildServiceProvider()); var builder = new StringBuilder(); builder.AppendLine("@model object"); builder.AppendLine("@inject RazorLight.MVC.Tests.TestViewModel test"); builder.AppendLine("Hello @test"); IEngineCore engineCore = new EngineCore(new Templating.Embedded.EmbeddedResourceTemplateManager(typeof(PropertyInjectorTest))); CompilationResult result = engineCore.CompileSource(new Templating.LoadedTemplateSource(builder.ToString()), new ModelTypeInfo(typeof(object))); var page = (TemplatePage)Activator.CreateInstance(result.CompiledType); propertyInjector.Inject(page); var prop = page.GetType().GetProperty("test").GetValue(page); Assert.NotNull(prop); Assert.IsAssignableFrom <TestViewModel>(prop); Assert.Equal((prop as TestViewModel).Title, expectedValue); }
/// <summary> /// Loads the instructions to display. /// </summary> private void LoadInstructions() { Byte[] bytes = EngineCore.GetInstance().VirtualMemory.ReadBytes(this.BaseAddress.ToIntPtr(), 200, out _); if (bytes.IsNullOrEmpty()) { return; } Boolean isProcess32Bit = EngineCore.GetInstance().Processes.IsOpenedProcess32Bit(); // Disassemble instructions IEnumerable <NormalizedInstruction> disassembledInstructions = this.Disassembler.Disassemble(bytes, isProcess32Bit, this.BaseAddress.ToIntPtr()); IList <InstructionItem> instructions = new List <InstructionItem>(); foreach (NormalizedInstruction disassembledInstruction in disassembledInstructions) { String moduleName; UInt64 address = AddressResolver.GetInstance().AddressToModule(disassembledInstruction.Address, out moduleName); instructions.Add(new InstructionItem(address.ToIntPtr(), moduleName, disassembledInstruction.Instruction, disassembledInstruction.Bytes)); } this.Instructions = new FullyObservableCollection <InstructionItem>(instructions); }
public void OnDeserialized(StreamingContext streamingContext) { this.LastActivated = DateTime.MinValue; this.ActivationDelay = KeyboardHotkey.DefaultActivationDelay; this.AccessLock = new object(); this.Subscription = EngineCore.GetInstance().Input?.GetKeyboardCapture().WeakSubscribe(this); }
/// <summary> /// Reads the array of bytes of the specified count at the given address. /// </summary> /// <param name="address">The address of the read.</param> /// <param name="count">The number of bytes to read.</param> /// <returns>The bytes read at the address.</returns> public Byte[] Read(UInt64 address, Int32 count) { this.PrintDebugTag(address.ToString("x"), count.ToString()); Boolean readSuccess; return(EngineCore.GetInstance().VirtualMemory.ReadBytes(address.ToIntPtr(), count, out readSuccess)); }
/// <summary> /// Reads the value at the given address. /// </summary> /// <typeparam name="T">The data type to read.</typeparam> /// <param name="address">The address of the read.</param> /// <returns>The value read from memory.</returns> public T Read <T>(UInt64 address) { this.PrintDebugTag(address.ToString("x")); Boolean readSuccess; return(EngineCore.GetInstance().VirtualMemory.Read <T>(address.ToIntPtr(), out readSuccess)); }
public UInt64 EvaluatePointer(UInt64 address, IEnumerable <Int32> offsets) { this.PrintDebugTag(); UInt64 finalAddress = EngineCore.GetInstance().VirtualMemory.EvaluatePointer(address.ToIntPtr(), offsets).ToUInt64(); return(finalAddress); }
/// <summary> /// Reads the value at the given address. /// </summary> /// <typeparam name="T">The data type to read.</typeparam> /// <param name="address">The address of the read.</param> /// <returns>The value read from memory.</returns> public T Read <T>(UInt64 address) { this.PrintDebugTag(address.ToString("x")); Boolean readSuccess; return(EngineCore.GetInstance().OperatingSystemAdapter.Read <T>(address.ToIntPtr(), out readSuccess)); }
static void Main(string[] args) { var engine = new EngineCore(); LoadZoneFile($"../ConverterApp/{args[0]}_oes.zip", engine); engine.Run(); }
/// <summary> /// Searches for the first address that matches the array of bytes. /// </summary> /// <param name="bytes">The array of bytes to search for.</param> /// <returns>The address of the first first array of byte match.</returns> public UInt64 SearchAob(Byte[] bytes) { this.PrintDebugTag(); UInt64 address = EngineCore.GetInstance().VirtualMemory.SearchAob(bytes).ToUInt64(); return(address); }
/// <summary> /// Searches for the first address that matches the array of bytes. /// </summary> /// <param name="bytes">The array of bytes to search for.</param> /// <returns>The address of the first first array of byte match.</returns> public UInt64 SearchAob(Byte[] bytes) { this.PrintDebugTag(); UInt64 address = EngineCore.GetInstance().OperatingSystemAdapter.SearchAob(bytes).ToUInt64(); return(address); }
private void CleanUp() { this.Snapshot = null; EngineCore.GetInstance().Input?.GetKeyboardCapture().Unsubscribe(this); EngineCore.GetInstance().Input?.GetControllerCapture().Unsubscribe(this); EngineCore.GetInstance().Input?.GetMouseCapture().Unsubscribe(this); }
/// <summary> /// Writes a value to the computed address of this item. /// </summary> /// <param name="newValue">The value to write.</param> protected virtual void WriteValue(Object newValue) { if (newValue == null) { return; } EngineCore.GetInstance()?.VirtualMemory?.Write(this.DataType, this.CalculatedAddress, newValue); }
public void Update(NormalizedProcess process) { if (process != null) { this.BaseAddress = EngineCore.GetInstance().VirtualMemory.GetModules().FirstOrDefault()?.BaseAddress.ToUInt64() ?? 0UL; this.LoadInstructions(); } }