815 lines
32 KiB
C#
815 lines
32 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Text.RegularExpressions;
|
|
using System.Runtime.InteropServices;
|
|
using System.IO;
|
|
|
|
namespace IW4MAdmin
|
|
{
|
|
class Utilities
|
|
{
|
|
//Get string with specified number of spaces -- really only for visual output
|
|
public static String getSpaces(int Num)
|
|
{
|
|
String SpaceString = String.Empty;
|
|
while (Num > 0)
|
|
{
|
|
SpaceString += ' ';
|
|
Num--;
|
|
}
|
|
|
|
return SpaceString;
|
|
}
|
|
|
|
//Sleep for x amount of seconds
|
|
public static void Wait(double time)
|
|
{
|
|
Thread.Sleep((int)Math.Ceiling(time*1000));
|
|
}
|
|
|
|
//Remove words from a space delimited string
|
|
public static String removeWords(String str, int num)
|
|
{
|
|
String newStr = String.Empty;
|
|
String[] tmp = str.Split(' ');
|
|
|
|
for (int i = 0; i < tmp.Length; i++)
|
|
{
|
|
if (i >= num)
|
|
newStr += tmp[i] + ' ';
|
|
}
|
|
|
|
return newStr;
|
|
}
|
|
|
|
public static Player.Permission matchPermission(String str)
|
|
{
|
|
String lookingFor = str.ToLower();
|
|
|
|
for (Player.Permission Perm = Player.Permission.User; Perm < Player.Permission.Owner; Perm++)
|
|
{
|
|
if (lookingFor.Contains(Perm.ToString().ToLower()))
|
|
return Perm;
|
|
}
|
|
|
|
return Player.Permission.Banned;
|
|
}
|
|
|
|
public static String removeNastyChars(String str)
|
|
{
|
|
if (str != null)
|
|
return str.Replace("`", "").Replace("\\", "").Replace("\"", "").Replace(""", "''").Replace("&", "&").Replace("\"", "''");
|
|
else
|
|
return String.Empty;
|
|
}
|
|
|
|
public static int GetLineNumber(Exception ex)
|
|
{
|
|
var lineNumber = 0;
|
|
const string lineSearch = ":line ";
|
|
var index = ex.StackTrace.LastIndexOf(lineSearch);
|
|
if (index != -1)
|
|
{
|
|
var lineNumberText = ex.StackTrace.Substring(index + lineSearch.Length);
|
|
if (int.TryParse(lineNumberText, out lineNumber))
|
|
{
|
|
}
|
|
}
|
|
return lineNumber;
|
|
}
|
|
|
|
public static String cleanChars(String S)
|
|
{
|
|
StringBuilder Cleaned = new StringBuilder();
|
|
|
|
foreach (char c in S)
|
|
if (c < 127 && c > 31 && c != 37 && c != 34 && c != 92) Cleaned.Append(c);
|
|
return Cleaned.ToString();
|
|
}
|
|
|
|
public static String stripColors(String str)
|
|
{
|
|
return Regex.Replace(str, @"\^[0-9]", "");
|
|
}
|
|
|
|
public static String levelToColor(Player.Permission level)
|
|
{
|
|
switch (level)
|
|
{
|
|
case Player.Permission.Banned:
|
|
return "^1" + Player.Permission.Banned;
|
|
case Player.Permission.Flagged:
|
|
return "^0" + Player.Permission.Flagged;
|
|
case Player.Permission.Owner:
|
|
return "^5" + Player.Permission.Owner;
|
|
case Player.Permission.User:
|
|
return "^2" + Player.Permission.User;
|
|
default:
|
|
return "^3" + level;
|
|
}
|
|
}
|
|
|
|
public static String processMacro(Dictionary<String, Object> Dict, String str)
|
|
{
|
|
MatchCollection Found = Regex.Matches(str, @"\{\{[A-Z]+\}\}", RegexOptions.IgnoreCase);
|
|
foreach (Match M in Found)
|
|
{
|
|
String Match = M.Value;
|
|
String Identifier = M.Value.Substring(2, M.Length - 4);
|
|
String Replacement = Dict[Identifier].ToString();
|
|
str = str.Replace(Match, Replacement);
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
public static Dictionary<String, String> IPFromStatus(String[] players)
|
|
{
|
|
Dictionary<String, String> Dict = new Dictionary<String, String>();
|
|
|
|
if (players == null)
|
|
return null;
|
|
|
|
foreach (String S in players)
|
|
{
|
|
String S2 = S.Trim();
|
|
if (S.Length < 50)
|
|
continue;
|
|
if (Regex.Matches(S2, @"\d+$", RegexOptions.IgnoreCase).Count > 0)
|
|
{
|
|
String[] eachPlayer = S2.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
for (int i = 3; i < eachPlayer.Length; i++ )
|
|
{
|
|
if (eachPlayer[i].Split(':').Length > 1)
|
|
{
|
|
Dict.Add(eachPlayer[3], eachPlayer[i].Split(':')[0]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
return Dict;
|
|
|
|
}
|
|
|
|
public static String nameHTMLFormatted(Player P)
|
|
{
|
|
switch (P.getLevel())
|
|
{
|
|
case Player.Permission.User:
|
|
return "<span style='color:rgb(87, 150, 66)'>" + P.getName() + "</span>";
|
|
case Player.Permission.Moderator:
|
|
return "<span style='color:#e7b402'>" + P.getName() + "</span>";
|
|
case Player.Permission.Administrator:
|
|
return "<span style='color:#ec82de'>" + P.getName() + "</span>";
|
|
case Player.Permission.SeniorAdmin:
|
|
return "<span style='color:#2eb6bf'>" + P.getName() + "</span>";
|
|
case Player.Permission.Owner:
|
|
return "<span style='color:rgb(38,120,230)'>" + P.getName() + "</span>";
|
|
case Player.Permission.Creator:
|
|
return "<span style='color:rgb(38,120,230)'>" + P.getName() + "</span>";
|
|
case Player.Permission.Banned:
|
|
return "<span style='color:rgb(196, 22, 28)'>" + P.getName() + "</span>";
|
|
case Player.Permission.Flagged:
|
|
return "<span style='color:rgb(251, 124, 98)'>" + P.getName() + "</span>";
|
|
default:
|
|
return "<i>" + P.getName() + "</i>";
|
|
}
|
|
}
|
|
|
|
public static String nameHTMLFormatted(Player.Permission Level)
|
|
{
|
|
switch (Level)
|
|
{
|
|
case Player.Permission.User:
|
|
return "<span style='color:rgb(87, 150, 66)'>" + Level + "</span>";
|
|
case Player.Permission.Moderator:
|
|
return "<span style='color:#e7b402'>" + Level + "</span>";
|
|
case Player.Permission.Administrator:
|
|
return "<span style='color:#ec82de'>" + Level + "</span>";
|
|
case Player.Permission.SeniorAdmin:
|
|
return "<span style='color:#2eb6bf'>" + Level + "</span>";
|
|
case Player.Permission.Owner:
|
|
return "<span style='color:rgb(38,120,230)'>" + Level + "</span>";
|
|
case Player.Permission.Creator:
|
|
return "<span style='color:rgb(38,120,230)'>" + Level + "</span>";
|
|
case Player.Permission.Banned:
|
|
return "<span style='color:rgb(196, 22, 28)'>" + Level + "</span>";
|
|
case Player.Permission.Flagged:
|
|
return "<span style='color:rgb(251, 124, 98)'>" + Level + "</span>";
|
|
default:
|
|
return "<i>" + Level + "</i>";
|
|
}
|
|
}
|
|
|
|
public static String gametypeLocalized(String input)
|
|
{
|
|
switch (input)
|
|
{
|
|
case "dm":
|
|
return "Deathmatch";
|
|
case "war":
|
|
return "Team Deathmatch";
|
|
case "koth":
|
|
return "Headquarters";
|
|
case "ctf":
|
|
return "Capture The Flag";
|
|
case "dd":
|
|
return "Demolition";
|
|
case "dom":
|
|
return "Domination";
|
|
case "sab":
|
|
return "Sabotage";
|
|
case "sd":
|
|
return "Search & Destroy";
|
|
case "vip":
|
|
return "Very Important Person";
|
|
case "gtnw":
|
|
return "Global Thermonuclear War";
|
|
case "oitc":
|
|
return "One In The Chamber";
|
|
case "arena":
|
|
return "Arena";
|
|
case "dzone":
|
|
return "Drop Zone";
|
|
case "gg":
|
|
return "Gun Game";
|
|
case "snipe":
|
|
return "Sniping";
|
|
case "ss":
|
|
return "Sharp Shooter";
|
|
case "m40a3":
|
|
return "M40A3";
|
|
case "fo":
|
|
return "Face Off";
|
|
case "dmc":
|
|
return "Deathmatch Classic";
|
|
case "killcon":
|
|
return "Kill Confirmed";
|
|
case "oneflag":
|
|
return "One Flag CTF";
|
|
default:
|
|
return "Unknown";
|
|
}
|
|
}
|
|
|
|
public static Dictionary<String, Player> playersFromStatus(String[] Status)
|
|
{
|
|
Dictionary<String, Player> playerDictionary = new Dictionary<String, Player>();
|
|
|
|
if (Status == null) // looks like we didn't get a proper response
|
|
return null;
|
|
|
|
foreach (String S in Status)
|
|
{
|
|
String responseLine = S.Trim();
|
|
|
|
if (Regex.Matches(responseLine, @"\d+$", RegexOptions.IgnoreCase).Count > 0 && responseLine.Length > 92) // its a client line!
|
|
{
|
|
String[] playerInfo = responseLine.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
|
|
int cID = -1;
|
|
String cName = stripColors(responseLine.Substring(46, 18)).Trim();
|
|
String npID = responseLine.Substring(29, 17).Trim(); // DONT TOUCH PLZ
|
|
int.TryParse(playerInfo[0], out cID);
|
|
String cIP = responseLine.Substring(72,20).Trim().Split(':')[0];
|
|
|
|
Player P = new Player(cName, npID, cID, cIP);
|
|
|
|
try
|
|
{
|
|
playerDictionary.Add(npID, P);
|
|
}
|
|
|
|
catch(Exception E)
|
|
{
|
|
/// need to handle eventually
|
|
Console.WriteLine("Error handling player add -- " + E.Message);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
return playerDictionary;
|
|
|
|
}
|
|
|
|
public static String DateTimeSQLite(DateTime datetime)
|
|
{
|
|
string dateTimeFormat = "{0}-{1}-{2} {3}:{4}:{5}.{6}";
|
|
return string.Format(dateTimeFormat, datetime.Year, datetime.Month, datetime.Day, datetime.Hour, datetime.Minute, datetime.Second, datetime.Millisecond);
|
|
}
|
|
|
|
public static String timePassed(DateTime start)
|
|
{
|
|
TimeSpan Elapsed = DateTime.Now - start;
|
|
|
|
if (Elapsed.TotalMinutes < 120)
|
|
return Math.Round(Elapsed.TotalMinutes, 0) + " minutes";
|
|
if (Elapsed.TotalHours <= 24)
|
|
return Math.Round(Elapsed.TotalHours, 0) + " hours";
|
|
if (Elapsed.TotalDays <= 365)
|
|
return Math.Round(Elapsed.TotalDays, 0) + " days";
|
|
else
|
|
return "a very long time";
|
|
}
|
|
|
|
const int PROCESS_CREATE_THREAD = 0x0002;
|
|
const int PROCESS_QUERY_INFORMATION = 0x0400;
|
|
const int PROCESS_VM_OPERATION = 0x0008;
|
|
const int PROCESS_VM_WRITE = 0x0020;
|
|
const int PROCESS_VM_READ = 0x0010;
|
|
|
|
[Flags]
|
|
public enum ProcessAccessFlags : uint
|
|
{
|
|
Terminate = 0x00000001,
|
|
CreateThread = 0x00000002,
|
|
VMOperation = 0x00000008,
|
|
VMRead = 0x00000010,
|
|
VMWrite = 0x00000020,
|
|
DupHandle = 0x00000040,
|
|
SetInformation = 0x00000200,
|
|
QueryInformation = 0x00000400,
|
|
Synchronize = 0x00100000,
|
|
All = 0x001F0FFF
|
|
}
|
|
|
|
[Flags]
|
|
public enum AllocationType
|
|
{
|
|
Commit = 0x00001000,
|
|
Reserve = 0x00002000,
|
|
Decommit = 0x00004000,
|
|
Release = 0x00008000,
|
|
Reset = 0x00080000,
|
|
TopDown = 0x00100000,
|
|
WriteWatch = 0x00200000,
|
|
Physical = 0x00400000,
|
|
LargePages = 0x20000000
|
|
}
|
|
|
|
[Flags]
|
|
public enum MemoryProtection
|
|
{
|
|
NoAccess = 0x0001,
|
|
ReadOnly = 0x0002,
|
|
ReadWrite = 0x0004,
|
|
WriteCopy = 0x0008,
|
|
Execute = 0x0010,
|
|
ExecuteRead = 0x0020,
|
|
ExecuteReadWrite = 0x0040,
|
|
ExecuteWriteCopy = 0x0080,
|
|
GuardModifierflag = 0x0100,
|
|
NoCacheModifierflag = 0x0200,
|
|
WriteCombineModifierflag = 0x0400
|
|
}
|
|
|
|
[DllImport("kernel32.dll")]
|
|
public static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, bool bInheritHandle, int dwProcessId);
|
|
|
|
[DllImport("kernel32.dll")]
|
|
public static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
|
|
|
|
[DllImport("kernel32.dll")]
|
|
public static extern bool ReadProcessMemory(int hProcess, int lpBaseAddress, byte[] lpBuffer, int dwSize, ref int lpNumberOfBytesRead);
|
|
|
|
[DllImport("kernel32.dll")]
|
|
public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint nSize, out UIntPtr lpNumberOfBytesWritten);
|
|
|
|
[DllImport("kernel32.dll")]
|
|
static extern bool TerminateThread(IntPtr hThread, uint dwExitCode);
|
|
|
|
[DllImport("kernel32.dll")]
|
|
public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
public static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, out uint lpThreadId);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
|
|
static extern bool VirtualFreeEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, AllocationType dwFreeType);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
static extern UInt32 WaitForSingleObject(IntPtr hHandle, UInt32 dwMilliseconds);
|
|
|
|
[DllImport("kernel32", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)]
|
|
static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);
|
|
|
|
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
|
|
static extern IntPtr GetModuleHandle(string lpModuleName);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
static extern int CloseHandle(IntPtr hObject);
|
|
|
|
[DllImport("ntdll.dll")]
|
|
public static extern uint RtlCreateUserThread(
|
|
[In] IntPtr Process,
|
|
[In] IntPtr ThreadSecurityDescriptor,
|
|
[In] bool CreateSuspended,
|
|
[In] int StackZeroBits,
|
|
uint MaximumStackSize,
|
|
[In] [Optional] IntPtr InitialStackSize,
|
|
[In] IntPtr StartAddress,
|
|
[In] IntPtr Parameter,
|
|
[Out] out IntPtr Thread,
|
|
[Out] out ClientId ClientId
|
|
);
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct ClientId
|
|
{
|
|
public ClientId(int processId, int threadId)
|
|
{
|
|
this.UniqueProcess = new IntPtr(processId);
|
|
this.UniqueThread = new IntPtr(threadId);
|
|
}
|
|
|
|
public IntPtr UniqueProcess;
|
|
public IntPtr UniqueThread;
|
|
|
|
public int ProcessId { get { return this.UniqueProcess.ToInt32(); } }
|
|
public int ThreadId { get { return this.UniqueThread.ToInt32(); } }
|
|
}
|
|
|
|
public static dvar getDvar(int Location, IntPtr Handle)
|
|
{
|
|
int numberRead = 0;
|
|
Byte[] Buff = new Byte[72];
|
|
|
|
ReadProcessMemory((int)Handle, Location, Buff, Buff.Length, ref numberRead); // read dvar memory
|
|
|
|
dvar_t dvar_raw = Helpers.ReadStruct<dvar_t>(Buff); // get the dvar struct
|
|
dvar dvar_actual = new dvar(); // gotta convert to something readable
|
|
|
|
dvar_actual.name = getStringFromPointer((int)dvar_raw.name, (int)Handle);
|
|
dvar_actual.description = getStringFromPointer((int)dvar_raw.description, (int)Handle);
|
|
|
|
if ((int)dvar_raw._default > short.MaxValue)
|
|
dvar_actual._default = getStringFromPointer((int)dvar_raw._default, (int)Handle);
|
|
else
|
|
dvar_actual._default = dvar_raw._default.ToString();
|
|
|
|
if ((int)dvar_raw.current > short.MaxValue)
|
|
dvar_actual.current = getStringFromPointer((int)dvar_raw.current, (int)Handle);
|
|
else if ((int)dvar_raw.current <= 1025)
|
|
dvar_actual.current = ((int)dvar_raw.current % 1024).ToString();
|
|
else
|
|
dvar_actual.current = dvar_raw.current.ToString();
|
|
|
|
if ((int)dvar_raw.latched > short.MaxValue)
|
|
dvar_actual.latched = getStringFromPointer((int)dvar_raw.latched, (int)Handle);
|
|
else
|
|
dvar_actual.latched = dvar_raw.latched.ToString();
|
|
|
|
dvar_actual.type = dvar_raw.type;
|
|
dvar_actual.flags = getIntFromPointer((int)dvar_raw.flags, (int)Handle);
|
|
dvar_actual.max = getIntFromPointer((int)dvar_raw.max, (int)Handle);
|
|
dvar_actual.min = getIntFromPointer((int)dvar_raw.min, (int)Handle);
|
|
|
|
// done!
|
|
|
|
return dvar_actual;
|
|
}
|
|
|
|
public static dvar getDvarOld(int Location, int Handle)
|
|
{
|
|
int loc = getIntFromPointer(Location, Handle);
|
|
return getDvar(loc, (IntPtr)Handle);
|
|
}
|
|
|
|
public static int getDvarCurrentAddress(int Location, int Handle)
|
|
{
|
|
int numberRead = 0;
|
|
Byte[] Buff = new Byte[72];
|
|
Byte[] Ptr = new Byte[4];
|
|
|
|
ReadProcessMemory(Handle, Location, Ptr, Ptr.Length, ref numberRead); // get location of dvar
|
|
ReadProcessMemory(Handle, (int)BitConverter.ToUInt32(Ptr, 0), Buff, Buff.Length, ref numberRead); // read dvar memory
|
|
|
|
dvar_t dvar_raw = Helpers.ReadStruct<dvar_t>(Buff); // get the dvar struct
|
|
int current = (int)dvar_raw.current;
|
|
|
|
return current;
|
|
}
|
|
|
|
public static void setDvar(int Location, int Handle, String Value)
|
|
{
|
|
UIntPtr bytesWritten = UIntPtr.Zero;
|
|
WriteProcessMemory((IntPtr)Handle, (IntPtr)Location, Encoding.ASCII.GetBytes(Value), (uint)Value.Length, out bytesWritten);
|
|
}
|
|
|
|
public static String getStringFromPointer(int Location, int Handle)
|
|
{
|
|
int numberRead = 0;
|
|
Byte[] Buff = new Byte[256];
|
|
|
|
ReadProcessMemory(Handle, Location, Buff, Buff.Length, ref numberRead);
|
|
|
|
StringBuilder str = new StringBuilder();
|
|
for ( int i = 0; i < Buff.Length; i++)
|
|
{
|
|
if (Buff[i] == 0)
|
|
break;
|
|
|
|
str.Append((char)Buff[i]);
|
|
}
|
|
return str.ToString();
|
|
}
|
|
|
|
public static int getIntFromPointer(int Location, int Handle)
|
|
{
|
|
int numberRead = 0;
|
|
Byte[] Buff = new Byte[4];
|
|
|
|
ReadProcessMemory(Handle, Location, Buff, Buff.Length, ref numberRead);
|
|
|
|
return BitConverter.ToInt32(Buff, 0);
|
|
}
|
|
|
|
public static Boolean getBoolFromPointer(int Location, int Handle)
|
|
{
|
|
int numberRead = 0;
|
|
Byte[] Buff = new Byte[1];
|
|
|
|
ReadProcessMemory(Handle, Location, Buff, Buff.Length, ref numberRead);
|
|
|
|
return BitConverter.ToBoolean(Buff, 0);
|
|
}
|
|
|
|
public static void executeCommand(int pID, String Command)
|
|
{
|
|
/*IntPtr ProcessHandle = OpenProcess(ProcessAccessFlags.All, false, pID);
|
|
IntPtr memoryForCMDName = allocateAndWrite(Encoding.ASCII.GetBytes(Command + "\0"), ProcessHandle);
|
|
uint threadID;
|
|
|
|
if (memoryForCMDName == IntPtr.Zero)
|
|
return;
|
|
|
|
// set the dvar's current value pointer to our desired command
|
|
setDvarCurrentPtr((IntPtr)0x2098D9C, memoryForCMDName, ProcessHandle);
|
|
|
|
// assembly instruction to execute the command we want stored in `surogate` dvar
|
|
byte[] executeCMD = {
|
|
0x55, 0x8B, 0xEC, 0x51, 0xC7, 0x45, 0xFC, // ---------------------------------------------
|
|
0x9C, 0x8D, 0x09, 0x02, 0x8B, 0x45, 0xFC, // dvar_t** dvarWithCMD = (dvar_t**)(0x2098D9C);
|
|
0x8B, 0x08, 0x8B, 0x51, 0x10, 0x52, 0x6A,
|
|
0x00, 0x6A, 0x00, 0xFF, 0x15, 0x1C, 0x53, // Cmd_ExecuteSingleCommand(0, 0, (*dvarWithCMD)->current.string );
|
|
0x11, 0x10, 0x83, 0xC4, 0x0C, 0x8B, 0xE5, // ---------------------------------------------
|
|
0x5D, 0xC3
|
|
};
|
|
|
|
// allocate the memory for the assembly command and write it
|
|
IntPtr codeAllocation = allocateAndWrite(executeCMD, ProcessHandle);
|
|
if (codeAllocation == IntPtr.Zero)
|
|
return;
|
|
|
|
// create our thread that executes command :)
|
|
IntPtr ThreadHandle = CreateRemoteThread(ProcessHandle, IntPtr.Zero, 0, codeAllocation, IntPtr.Zero, 0, out threadID);
|
|
if (ThreadHandle == null || ThreadHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
WaitForSingleObject(ThreadHandle, Int32.MaxValue); // gg if it doesn't finishe
|
|
|
|
// cleanup
|
|
if (!VirtualFreeEx(ProcessHandle, codeAllocation, 0, AllocationType.Release))
|
|
Console.WriteLine(Marshal.GetLastWin32Error());
|
|
if (!VirtualFreeEx(ProcessHandle, memoryForCMDName, 0, AllocationType.Release))
|
|
Console.WriteLine(Marshal.GetLastWin32Error());*/
|
|
|
|
IntPtr ProcessHandle = OpenProcess(ProcessAccessFlags.All, false, pID);
|
|
IntPtr memoryForDvarName = allocateAndWrite(Encoding.ASCII.GetBytes(Command + "\0"), ProcessHandle);
|
|
|
|
if (memoryForDvarName == IntPtr.Zero)
|
|
{
|
|
Console.WriteLine("UNABLE TO ALLOCATE MEMORY FOR DVAR NAME");
|
|
return;
|
|
}
|
|
|
|
setDvarCurrentPtr(0x2098D9C, memoryForDvarName, ProcessHandle);
|
|
|
|
Utilities.Wait(.3);
|
|
|
|
if (!VirtualFreeEx(ProcessHandle, memoryForDvarName, 0, AllocationType.Release))
|
|
Console.WriteLine("Virtual Free Failed -- Error #" + Marshal.GetLastWin32Error());
|
|
|
|
CloseHandle(ProcessHandle);
|
|
|
|
}
|
|
|
|
public static IntPtr allocateAndWrite(Byte[] Data, IntPtr ProcessHandle)
|
|
{
|
|
UIntPtr bytesWritten;
|
|
IntPtr AllocatedMemory = VirtualAllocEx(ProcessHandle, IntPtr.Zero, (uint)Data.Length, AllocationType.Commit, MemoryProtection.ExecuteReadWrite);
|
|
if (!WriteProcessMemory(ProcessHandle, AllocatedMemory, Data, (uint)Data.Length, out bytesWritten))
|
|
{
|
|
Console.WriteLine("UNABLE TO WRITE PROCESS MEMORY!");
|
|
return IntPtr.Zero;
|
|
}
|
|
|
|
if ((int)bytesWritten != Data.Length)
|
|
return IntPtr.Zero;
|
|
else
|
|
return AllocatedMemory;
|
|
}
|
|
|
|
public static bool setDvarCurrentPtr(int DvarAddress, IntPtr ValueAddress, IntPtr ProcessHandle)
|
|
{
|
|
int locationOfCurrentPtr = getIntFromPointer(DvarAddress, (int)ProcessHandle) + 0x10;
|
|
Byte[] newTextPtr = BitConverter.GetBytes((int)ValueAddress);
|
|
UIntPtr bytesWritten;
|
|
if (!WriteProcessMemory(ProcessHandle, (IntPtr)locationOfCurrentPtr, newTextPtr, (uint)newTextPtr.Length, out bytesWritten))
|
|
return false;
|
|
if (newTextPtr.Length != (int)bytesWritten)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
public static bool initalizeInterface(int pID)
|
|
{
|
|
String Path = AppDomain.CurrentDomain.BaseDirectory + "lib\\AdminInterface.dll";
|
|
|
|
if (!File.Exists(Path))
|
|
{
|
|
Console.WriteLine("AdminInterface DLL does not exist!");
|
|
return false;
|
|
}
|
|
|
|
UIntPtr bytesWritten;
|
|
IntPtr threadID;
|
|
|
|
IntPtr ProcessHandle = OpenProcess(ProcessAccessFlags.All, false, pID);
|
|
#if DEBUG
|
|
Console.WriteLine("Process handle is: " + ProcessHandle);
|
|
#endif
|
|
if (ProcessHandle == IntPtr.Zero)
|
|
{
|
|
Console.WriteLine("Unable to open target process");
|
|
return false;
|
|
}
|
|
|
|
IntPtr lpLLAddress = GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
|
|
|
|
if (lpLLAddress == IntPtr.Zero)
|
|
{
|
|
Console.WriteLine("Could not obtain address of function address");
|
|
return false;
|
|
}
|
|
|
|
#if DEBUG
|
|
Console.WriteLine("LoadLibraryA location is 0x" + lpLLAddress.ToString("X8"));
|
|
#endif
|
|
|
|
IntPtr pathAllocation = VirtualAllocEx(ProcessHandle, IntPtr.Zero, (uint)Path.Length + 1, AllocationType.Commit, MemoryProtection.ExecuteReadWrite);
|
|
|
|
if (pathAllocation == IntPtr.Zero)
|
|
{
|
|
Console.WriteLine("Could not allocate memory for path location");
|
|
return false;
|
|
}
|
|
#if DEBUG
|
|
Console.WriteLine("Allocated DLL path address is 0x" + pathAllocation.ToString("X8"));
|
|
#endif
|
|
|
|
byte[] pathBytes = Encoding.ASCII.GetBytes(Path);
|
|
|
|
if (!WriteProcessMemory(ProcessHandle, pathAllocation, pathBytes, (uint)pathBytes.Length, out bytesWritten))
|
|
{
|
|
Console.WriteLine("Could not write process memory");
|
|
return false;
|
|
}
|
|
|
|
ClientId clientid = new ClientId();
|
|
threadID = new IntPtr();
|
|
RtlCreateUserThread(ProcessHandle, IntPtr.Zero, false, 0, (uint)0, IntPtr.Zero, lpLLAddress, pathAllocation, out threadID, out clientid);
|
|
|
|
if (threadID == IntPtr.Zero)
|
|
{
|
|
Console.WriteLine("Could not create remote thread");
|
|
return false;
|
|
}
|
|
#if DEBUG
|
|
//Console.WriteLine("Thread Status is " + threadStatus);
|
|
Console.WriteLine("Thread ID is " + threadID);
|
|
#endif
|
|
uint responseCode = WaitForSingleObject (threadID, 3000);
|
|
|
|
if (responseCode != 0x00000000L)
|
|
{
|
|
Console.WriteLine("Thread did not finish in a timely manner!");
|
|
Console.WriteLine("Last error is: " + Marshal.GetLastWin32Error());
|
|
return false;
|
|
}
|
|
|
|
if (!VirtualFreeEx(ProcessHandle, pathAllocation, 0, AllocationType.Decommit))
|
|
Console.WriteLine("Could not free memory allocated for DLL name");
|
|
|
|
CloseHandle(ProcessHandle);
|
|
|
|
#if DEBUG
|
|
Console.WriteLine("Initialization finished -- last error : " + Marshal.GetLastWin32Error());
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
public static dvar getDvar(int pID, String DVAR)
|
|
{
|
|
dvar requestedDvar = new dvar();
|
|
IntPtr ProcessHandle = OpenProcess(ProcessAccessFlags.All, false, pID);
|
|
IntPtr memoryForDvarName = allocateAndWrite(Encoding.ASCII.GetBytes(DVAR + "\0"), ProcessHandle);
|
|
|
|
if (memoryForDvarName == IntPtr.Zero)
|
|
{
|
|
Console.WriteLine("UNABLE TO ALLOCATE MEMORY FOR DVAR NAME");
|
|
return requestedDvar;
|
|
}
|
|
|
|
setDvarCurrentPtr(0x2089E04, memoryForDvarName, ProcessHandle); // sv_debugRate
|
|
#if ASD
|
|
/* byte[] copyDvarValue = {
|
|
0x55, 0x8B, 0xEC, 0x83, 0xEC, 0x08, // -----------------------------------------------
|
|
0xC7, 0x45, 0xFC, 0x9C, 0x8D, 0x09, // dvar_t** surogateDvar = (dvar_t**)(0x2098D9C);
|
|
0x02, 0x8B, 0x45, 0xFC, 0x8B, 0x08, //
|
|
0x8B, 0x51, 0x10, 0x52, 0xFF, 0x15, // dvar_t *newDvar = Dvar_FindVar((*surogateDvar)->current.string);
|
|
0x6C, 0x53, 0x11, 0x10, 0x83, 0xC4, //
|
|
0x04, 0x89, 0x45, 0xF8, 0x83, 0x7D, // if (newDvar)
|
|
0xF8, 0x00, 0x74, 0x0B, 0x8B, 0x45, //
|
|
0xFC, 0x8B, 0x08, 0x8B, 0x55, 0xF8, // (*surogateDvar)->current.integer = (int)newDvar;
|
|
0x89, 0x51, 0x10, 0x8B, 0xE5, 0x5D, // -----------------------------------------------
|
|
0xC3
|
|
};
|
|
|
|
IntPtr codeAllocation = allocateAndWrite(copyDvarValue, ProcessHandle);
|
|
|
|
if (codeAllocation == IntPtr.Zero)
|
|
Console.WriteLine("UNABLE TO ALLOCATE MEMORY FOR CODE");
|
|
|
|
IntPtr ThreadHandle = CreateRemoteThread(ProcessHandle, IntPtr.Zero, 0, codeAllocation, IntPtr.Zero, 0, out threadID);
|
|
if (ThreadHandle == null || ThreadHandle == IntPtr.Zero)
|
|
return requestedDvar;
|
|
|
|
WaitForSingleObject(ThreadHandle, Int32.MaxValue); // gg if thread doesn't finish
|
|
|
|
if (!VirtualFreeEx(ProcessHandle, codeAllocation, 0, AllocationType.Release))
|
|
Console.WriteLine(Marshal.GetLastWin32Error());
|
|
if (!VirtualFreeEx(ProcessHandle, memoryForDvarName, 0, AllocationType.Release))
|
|
Console.WriteLine(Marshal.GetLastWin32Error());*/
|
|
#endif
|
|
Utilities.Wait(.3);
|
|
int dvarLoc = getIntFromPointer(0x2089E04, (int)ProcessHandle); // this is where the dvar is stored
|
|
|
|
if (dvarLoc == 0)
|
|
return requestedDvar;
|
|
|
|
dvarLoc = getIntFromPointer(dvarLoc + 0x10, (int)ProcessHandle);
|
|
|
|
requestedDvar = getDvar(dvarLoc, ProcessHandle);
|
|
CloseHandle(ProcessHandle);
|
|
|
|
return requestedDvar;
|
|
}
|
|
|
|
public static String timesConnected(int connection)
|
|
{
|
|
String Prefix = String.Empty;
|
|
if (connection % 10 > 3 || connection % 10 == 0 || (connection % 100 > 9 && connection % 100 < 19))
|
|
Prefix = "th";
|
|
else
|
|
{
|
|
switch (connection % 10)
|
|
{
|
|
case 1:
|
|
Prefix = "st";
|
|
break;
|
|
case 2:
|
|
Prefix = "nd";
|
|
break;
|
|
case 3:
|
|
Prefix = "rd";
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (connection)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
return "first";
|
|
case 2:
|
|
return "second";
|
|
case 3:
|
|
return "third";
|
|
case 4:
|
|
return "fourth";
|
|
case 5:
|
|
return "fifth";
|
|
case 100:
|
|
return "One-Hundreth (amazing!)";
|
|
default:
|
|
return connection.ToString() + Prefix;
|
|
}
|
|
}
|
|
}
|
|
}
|