Utils.cs

using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows;

namespace MiscUtils
{
    public class Utils
    {
        public static void debugWrite(string str)
        {
            Trace.WriteLine(str);
        }

        public static int compVers(string a, string b)
        {
            try
            {
                return new Version(a).CompareTo(new Version(b));
            }
            catch (Exception ex)
            {
                debugWrite(ex.ToString());
                return -100;
            }
        }

        public static string doHTTPReq(string url, string userAgent)
        {
            string ret = null;
            try
            {
                var request = WebRequest.Create(url);
                ((HttpWebRequest)request).UserAgent = userAgent;
                var response = request.GetResponse();
                debugWrite($"StatusCode: {((HttpWebResponse)response).StatusCode}");
                var dataStream = response.GetResponseStream();
                var reader = new StreamReader(dataStream);

                ret = reader.ReadToEnd();
                reader.Close(); //closes the stream and the response
            }
            catch (Exception ex)
            {
                debugWrite(ex.ToString());
            }
            return ret;
        }

        public static int checkVerAgainstURL(string url, string userAgent, string appVer)
        {
            //appVer -> Application.ProductVersion
            //URL should have a version number followed by a newline. later lines are ignored.

            //1 -> newer ver available.
            //0 -> current.
            //-1 -> this version is newer.
            //-100 -> error
            var vInfo = doHTTPReq(url, userAgent);
            if (string.IsNullOrEmpty(vInfo)) { return -100; }
            debugWrite(vInfo);
            try
            {
                var r = new StringReader(vInfo);
                var ver = r.ReadLine();
                if (ver != null) { return compVers(ver, appVer); }
            }
            catch (Exception ex)
            {
                debugWrite(ex.ToString());
            }
            return -100;
        }

        public static string getFnameInAppdata(string fname, string appName, bool localAppData = false)
        {//will create dir if needed, otherwise return a full filename.
            var appData = Environment.GetFolderPath(localAppData ? Environment.SpecialFolder.LocalApplicationData : Environment.SpecialFolder.ApplicationData);
            var appFolder = Path.Combine(appData, appName);
            if (!Directory.Exists(appFolder))
            {
                Directory.CreateDirectory(appFolder);
            }
            return Path.Combine(appFolder, fname);
        }

        public static DateTime getFileDate(string fname)
        {//will create a file if needed
            var ret = new DateTime(0);
            try
            {
                if (File.Exists(fname))
                {
                    ret = File.GetLastWriteTime(fname);
                }
                else
                {
                    File.Create(fname).Dispose();
                }
            }
            catch (Exception ex) { debugWrite(ex.ToString()); }
            return ret;
        }
        public static bool setFileDate(string fname)
        {
            try
            {
                File.SetLastWriteTime(fname, DateTime.Now);
                return true;
            }
            catch (Exception ex) { debugWrite(ex.ToString()); }
            return false;
        }
        public static void removeFile(string fname)
        {
            try
            {
                if (File.Exists(fname)) { File.Delete(fname); }
            }
            catch (Exception ex) { debugWrite(ex.ToString()); }
        }
    }

    public class LaunchUtils
    {
        public static string promptForFile(string startFolder, string filter)
        {
            OpenFileDialog d = new OpenFileDialog();
            d.InitialDirectory = startFolder;
            d.Filter = filter;
            if (d.ShowDialog() != true)
            {
                return null;
            }
            return d.FileName;
        }


        public static bool launchGame()
        {
            try
            {
                string exename = @"eldenring.exe";
                string path = exename;

                if (File.Exists(path)) // prioritize running Elden Ring from the folder this exe is in.
                {
                    Utils.debugWrite("Found Elden Ring exe at: " + path);
                }
                else // otherwise dynamically search for the game in steam config files
                {
                    path = GetEldenRingExePath();
                    Utils.debugWrite("Found Elden Ring exe at: " + path);
                }

                var psi = new ProcessStartInfo(path);
                psi.EnvironmentVariables["SteamAppId"] = "1245620";
                psi.UseShellExecute = false;
                psi.WorkingDirectory = System.IO.Path.GetDirectoryName(path);
                Process.Start(psi);
                return true;
            }
            catch
            {
                return false;
            }
        }

        public static string GetEldenRingExePath()
        {
            string steamPath = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Valve\Steam", "InstallPath", null) as string;
            if (string.IsNullOrEmpty(steamPath))
                return null;

            List<string> libraries = new List<string>();

            string steamInstallConfigPath = Path.Combine(steamPath, "steamapps", "libraryfolders.vdf"); // contains info about steam games install locations
            if (File.Exists(steamInstallConfigPath))
            {

                string[] lines = File.ReadAllLines(steamInstallConfigPath);
                var regex = new Regex(@"""path""\s+""(.+?)"""); // search the config for lines with the text: "path" 

                foreach (string line in lines)
                {
                    var match = regex.Match(line);
                    if (match.Success)
                    {
                        string path = match.Groups[1].Value.Replace(@"\\", @"\");
                        libraries.Add(path);
                    }
                }

            }

            foreach (string installDir in libraries)
            {
                string gamePath = Path.Combine(installDir, "steamapps", "common", "ELDEN RING", "Game", "eldenring.exe");
                if (File.Exists(gamePath))
                {
                    return gamePath;
                }
            }

            return null;
        }
    }

#if NO_WPF
    //alternative/dummy implementations for console tools
    enum MessageBoxButton { OK }
    enum MessageBoxImage { Information }
    class MessageBox
    {
        public static void Show(string str = "", string str2 = "", MessageBoxButton b = MessageBoxButton.OK, MessageBoxImage i = MessageBoxImage.Information)
        {
            Console.WriteLine($"{str2} {str}");
        }
    }
    class OpenFileDialog
    {
        public string InitialDirectory { get; set; }
        public string Filter { get; set; }
        public string FileName { get; set; }
        public bool? ShowDialog() { return null; }
    }
#endif

    public class AOBScanner : IDisposable
    {
        [DllImport("ntdll.dll")]
        static extern int NtReadVirtualMemory(IntPtr ProcessHandle, IntPtr BaseAddress, byte[] Buffer, UInt32 NumberOfBytesToRead, ref UInt32 NumberOfBytesRead);

        public uint textOneSize = 0;
        public int textOneAddr = 0;
        public uint textTwoSize = 0;
        public int textTwoAddr = 0;
        public byte[] sectionOne = new byte[0];
        public byte[] sectionTwo = new byte[0];

        public AOBScanner(IntPtr handle, IntPtr baseAddr, int size)
        {
#if !DEBUG
            outputConsole = false;
#endif

            //TODO: switch to .NET 5+ and use PEHeaders?
            //for now: assume two text sections, and aob scan for them, of course.

            var buf = new byte[0x600];
            uint bytesRead = 0;
            NtReadVirtualMemory(handle, baseAddr, buf, (uint)buf.Length, ref bytesRead);
            var dotText = Encoding.ASCII.GetBytes(".text");
            var dummy = new byte[5];
            int textOne = FindBytes(buf, dotText, dummy);
            if (textOne < 0)
            {
                Console.WriteLine("Cannot find text section");
                return;
            }
            textOneSize = BitConverter.ToUInt32(buf, textOne + 8);
            textOneAddr = BitConverter.ToInt32(buf, textOne + 12);
            sectionOne = new byte[textOneSize];
            NtReadVirtualMemory(handle, baseAddr + textOneAddr, sectionOne, textOneSize, ref bytesRead);

            int textTwo = FindBytes(buf, dotText, dummy, textOne + 0x28);
            if (textTwo > 0)
            {
                textTwoSize = BitConverter.ToUInt32(buf, textTwo + 8);
                textTwoAddr = BitConverter.ToInt32(buf, textTwo + 12);
                sectionTwo = new byte[textTwoSize];
                NtReadVirtualMemory(handle, baseAddr + textTwoAddr, sectionTwo, textTwoSize, ref bytesRead);
            }

            Console.ReadLine();
        }

        //originally from https://github.com/Wulf2k/ER-Patcher.git
        //try and keep in sync with https://github.com/kh0nsu/FromAobScan
        public byte[] hs2b(string hex)
        {
            hex = hex.Replace(" ", "");
            hex = hex.Replace("-", "");
            hex = hex.Replace(":", "");

            byte[] b = new byte[hex.Length >> 1];
            for (int i = 0; i <= b.Length - 1; ++i)
            {
                b[i] = (byte)((hex[i * 2] - (hex[i * 2] < 58 ? 48 : (hex[i * 2] < 97 ? 55 : 87))) * 16 + (hex[i * 2 + 1] - (hex[i * 2 + 1] < 58 ? 48 : (hex[i * 2 + 1] < 97 ? 55 : 87))));
            }
            return b;
        }

        public byte[] hs2w(string hex)
        {
            hex = hex.Replace(" ", "");
            hex = hex.Replace("-", "");
            hex = hex.Replace(":", "");

            byte[] wild = new byte[hex.Length >> 1];
            for (int i = 0; i <= wild.Length - 1; ++i)
            {
                if (hex[i * 2].Equals('?'))
                {
                    wild[i] = 1;
                }
            }
            return wild;
        }

        public int FindBytes(byte[] buf, byte[] find, byte[] wild, int startIndex = 0, int lastIndex = -1)
        {
            if (buf == null || find == null || buf.Length == 0 || find.Length == 0 || find.Length > buf.Length) return -1;
            if (lastIndex < 1) { lastIndex = buf.Length - find.Length; }
            for (int i = startIndex; i < lastIndex + 1; i++)
            {
                if (buf[i] == find[0])
                {
                    for (int m = 1; m < find.Length; m++)
                    {
                        if ((buf[i + m] != find[m]) && (wild[m] != 1)) break;
                        if (m == find.Length - 1) return i;
                    }
                }
            }
            return -1;
        }

        public bool outputConsole = true;

        public int findAddr(byte[] buf, int blockVirtualAddr, string find, string desc, int readoffset32 = -1000, int nextInstOffset = -1000, int justOffset = -1000, int startIndex = 0, bool singleMatch = true, Action<int> callback = null)
        {//TODO: for single match and non-zero start index, try zero start index if no match is found?
            int count = 0;

            byte[] fb = hs2b(find);
            byte[] fwb = hs2w(find);

            int index = startIndex;

            int result = -1;

            do
            {
                index = FindBytes(buf, fb, fwb, index);
                if (index != -1)
                {
                    count++;
                    int rva = index + blockVirtualAddr;
                    result = rva;
                    string output = desc + " found at index " + index + " offset hex " + rva.ToString("X2");

                    if (readoffset32 > -1000)
                    {
                        int index32 = index + readoffset32;
                        var val = BitConverter.ToInt32(buf, index32);
                        result = val;
                        output += " raw val " + val.ToString("X2");
                        if (nextInstOffset > -1000)
                        {
                            int next = blockVirtualAddr + index + nextInstOffset + val;
                            result = next;
                            output += " final offset " + next.ToString("X2");
                        }
                    }

                    if (justOffset > -1000)
                    {
                        result = rva + justOffset;
                        output += " with offset " + (rva + justOffset).ToString("X2");
                    }

                    if (outputConsole) { Console.WriteLine(output); }
                    index += fb.Length; //keep searching in case there's multiple.
                }
                if (index != -1 && callback != null) { callback(result); }
            }
            while (index != -1 && !singleMatch);
            if (0 == count) { Console.WriteLine("Nothing found for " + desc); }
            return result;
        }

        public void Dispose()
        {
            sectionOne = null;
            sectionTwo = null;
        }
    }

    public class FileUtils
    {
        public static List<string[]> importGenericTextResource(string name, char separator = '\t')
        {
            var ret = new List<string[]>();
            try
            {
                var assembly = Assembly.GetExecutingAssembly();
                string resourceName = assembly.GetManifestResourceNames().Single(str => str.EndsWith(name));
                using (Stream stream = assembly.GetManifestResourceStream(resourceName))
                using (StreamReader reader = new StreamReader(stream))
                {
                    string line = "";
                    while ((line = reader.ReadLine()) != null)
                    {
                        var spl = line.Split(separator);
                        if (spl.Length < 1) { continue; }
                        ret.Add(spl);
                    }
                }
                return ret;
            }
            catch
            {
                return ret;
            }
        }
    }

    public class StringWrap
    {
        public string DisplayStr { get; set; } = "";
        public object o = null;
        public override string ToString() { return DisplayStr; }
    }
}