Hello friends, could anyone help me convert this code from C # to C ++?
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Security.AccessControl;
using System.Security.Principal;
namespace FileLockInfo
{
public class Win32API
{
[DllImport("ntdll.dll")]
public static extern int NtQueryObject(IntPtr ObjectHandle, int
ObjectInformationClass, IntPtr ObjectInformation, int ObjectInformationLength,
ref int returnLength);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern uint QueryDosDevice(string lpDeviceName, StringBuilder lpTargetPath, int ucchMax);
[DllImport("ntdll.dll")]
public static extern uint NtQuerySystemInformation(int
SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength,
ref int returnLength);
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern IntPtr OpenMutex(UInt32 desiredAccess, bool inheritHandle, string name);
[DllImport("kernel32.dll")]
public static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwProcessId);
[DllImport("kernel32.dll")]
public static extern int CloseHandle(IntPtr hObject);
[DllImport("kernel32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool DuplicateHandle(IntPtr hSourceProcessHandle,
ushort hSourceHandle, IntPtr hTargetProcessHandle, out IntPtr lpTargetHandle,
uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwOptions);
[DllImport("kernel32.dll")]
public static extern IntPtr GetCurrentProcess();
public enum ObjectInformationClass : int
{
ObjectBasicInformation = 0,
ObjectNameInformation = 1,
ObjectTypeInformation = 2,
ObjectAllTypesInformation = 3,
ObjectHandleInformation = 4
}
[Flags]
public enum ProcessAccessFlags : uint
{
All = 0x001F0FFF,
Terminate = 0x00000001,
CreateThread = 0x00000002,
VMOperation = 0x00000008,
VMRead = 0x00000010,
VMWrite = 0x00000020,
DupHandle = 0x00000040,
SetInformation = 0x00000200,
QueryInformation = 0x00000400,
Synchronize = 0x00100000
}
[StructLayout(LayoutKind.Sequential)]
public struct OBJECT_BASIC_INFORMATION
{
public int Attributes;
public int GrantedAccess;
public int HandleCount;
public int PointerCount;
public int PagedPoolUsage;
public int NonPagedPoolUsage;
public int Reserved1;
public int Reserved2;
public int Reserved3;
public int NameInformationLength;
public int TypeInformationLength;
public int SecurityDescriptorLength;
public System.Runtime.InteropServices.ComTypes.FILETIME CreateTime;
}
[StructLayout(LayoutKind.Sequential)]
public struct OBJECT_TYPE_INFORMATION
{
public UNICODE_STRING Name;
public int ObjectCount;
public int HandleCount;
public int Reserved1;
public int Reserved2;
public int Reserved3;
public int Reserved4;
public int PeakObjectCount;
public int PeakHandleCount;
public int Reserved5;
public int Reserved6;
public int Reserved7;
public int Reserved8;
public int InvalidAttributes;
public GENERIC_MAPPING GenericMapping;
public int ValidAccess;
public byte Unknown;
public byte MaintainHandleDatabase;
public int PoolType;
public int PagedPoolUsage;
public int NonPagedPoolUsage;
}
[StructLayout(LayoutKind.Sequential)]
public struct OBJECT_NAME_INFORMATION
{
public UNICODE_STRING Name;
}
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct UNICODE_STRING
{
public ushort Length;
public ushort MaximumLength;
public IntPtr Buffer;
}
[StructLayout(LayoutKind.Sequential)]
public struct GENERIC_MAPPING
{
public int GenericRead;
public int GenericWrite;
public int GenericExecute;
public int GenericAll;
}
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct SYSTEM_HANDLE_INFORMATION
{
public int ProcessID;
public byte ObjectTypeNumber;
public byte Flags;
public ushort Handle;
public int Object_Pointer;
public UInt32 GrantedAccess;
}
public const int MAX_PATH = 260;
public const uint STATUS_INFO_LENGTH_MISMATCH = 0xC0000004;
public const int DUPLICATE_SAME_ACCESS = 0x2;
public const int DUPLICATE_CLOSE_SOURCE = 0x1;
}
public class Win32Processes
{
const int CNST_SYSTEM_HANDLE_INFORMATION = 16;
const uint STATUS_INFO_LENGTH_MISMATCH = 0xc0000004;
public static string getObjectTypeName(Win32API.SYSTEM_HANDLE_INFORMATION shHandle, Process process)
{
IntPtr m_ipProcessHwnd = Win32API.OpenProcess(Win32API.ProcessAccessFlags.All, false, process.Id);
IntPtr ipHandle = IntPtr.Zero;
var objBasic = new Win32API.OBJECT_BASIC_INFORMATION();
IntPtr ipBasic = IntPtr.Zero;
var objObjectType = new Win32API.OBJECT_TYPE_INFORMATION();
IntPtr ipObjectType = IntPtr.Zero;
IntPtr ipObjectName = IntPtr.Zero;
string strObjectTypeName = "";
int nLength = 0;
int nReturn = 0;
IntPtr ipTemp = IntPtr.Zero;
if (!Win32API.DuplicateHandle(m_ipProcessHwnd, shHandle.Handle,
Win32API.GetCurrentProcess(), out ipHandle,
0, false, Win32API.DUPLICATE_SAME_ACCESS))
return null;
ipBasic = Marshal.AllocHGlobal(Marshal.SizeOf(objBasic));
Win32API.NtQueryObject(ipHandle, (int)Win32API.ObjectInformationClass.ObjectBasicInformation,
ipBasic, Marshal.SizeOf(objBasic), ref nLength);
objBasic = (Win32API.OBJECT_BASIC_INFORMATION)Marshal.PtrToStructure(ipBasic, objBasic.GetType());
Marshal.FreeHGlobal(ipBasic);
ipObjectType = Marshal.AllocHGlobal(objBasic.TypeInformationLength);
nLength = objBasic.TypeInformationLength;
while ((uint)(nReturn = Win32API.NtQueryObject(
ipHandle, (int)Win32API.ObjectInformationClass.ObjectTypeInformation, ipObjectType,
nLength, ref nLength)) ==
Win32API.STATUS_INFO_LENGTH_MISMATCH)
{
Marshal.FreeHGlobal(ipObjectType);
ipObjectType = Marshal.AllocHGlobal(nLength);
}
objObjectType = (Win32API.OBJECT_TYPE_INFORMATION)Marshal.PtrToStructure(ipObjectType, objObjectType.GetType());
if (Is64Bits())
{
ipTemp = new IntPtr(Convert.ToInt64(objObjectType.Name.Buffer.ToString(), 10) >> 32);
}
else
{
ipTemp = objObjectType.Name.Buffer;
}
strObjectTypeName = Marshal.PtrToStringUni(ipTemp, objObjectType.Name.Length >> 1);
Marshal.FreeHGlobal(ipObjectType);
return strObjectTypeName;
}
public static string getObjectName(Win32API.SYSTEM_HANDLE_INFORMATION shHandle, Process process)
{
IntPtr m_ipProcessHwnd = Win32API.OpenProcess(Win32API.ProcessAccessFlags.All, false, process.Id);
IntPtr ipHandle = IntPtr.Zero;
var objBasic = new Win32API.OBJECT_BASIC_INFORMATION();
IntPtr ipBasic = IntPtr.Zero;
IntPtr ipObjectType = IntPtr.Zero;
var objObjectName = new Win32API.OBJECT_NAME_INFORMATION();
IntPtr ipObjectName = IntPtr.Zero;
string strObjectName = "";
int nLength = 0;
int nReturn = 0;
IntPtr ipTemp = IntPtr.Zero;
if (!Win32API.DuplicateHandle(m_ipProcessHwnd, shHandle.Handle, Win32API.GetCurrentProcess(),
out ipHandle, 0, false, Win32API.DUPLICATE_SAME_ACCESS))
return null;
ipBasic = Marshal.AllocHGlobal(Marshal.SizeOf(objBasic));
Win32API.NtQueryObject(ipHandle, (int)Win32API.ObjectInformationClass.ObjectBasicInformation,
ipBasic, Marshal.SizeOf(objBasic), ref nLength);
objBasic = (Win32API.OBJECT_BASIC_INFORMATION)Marshal.PtrToStructure(ipBasic, objBasic.GetType());
Marshal.FreeHGlobal(ipBasic);
nLength = objBasic.NameInformationLength;
ipObjectName = Marshal.AllocHGlobal(nLength);
while ((uint)(nReturn = Win32API.NtQueryObject(
ipHandle, (int)Win32API.ObjectInformationClass.ObjectNameInformation,
ipObjectName, nLength, ref nLength))
== Win32API.STATUS_INFO_LENGTH_MISMATCH)
{
Marshal.FreeHGlobal(ipObjectName);
ipObjectName = Marshal.AllocHGlobal(nLength);
}
objObjectName = (Win32API.OBJECT_NAME_INFORMATION)Marshal.PtrToStructure(ipObjectName, objObjectName.GetType());
if (Is64Bits())
{
ipTemp = new IntPtr(Convert.ToInt64(objObjectName.Name.Buffer.ToString(), 10) >> 32);
}
else
{
ipTemp = objObjectName.Name.Buffer;
}
if (ipTemp != IntPtr.Zero)
{
byte[] baTemp2 = new byte[nLength];
try
{
Marshal.Copy(ipTemp, baTemp2, 0, nLength);
strObjectName = Marshal.PtrToStringUni(Is64Bits() ?
new IntPtr(ipTemp.ToInt64()) :
new IntPtr(ipTemp.ToInt32()));
return strObjectName;
}
catch (AccessViolationException)
{
return null;
}
finally
{
Marshal.FreeHGlobal(ipObjectName);
Win32API.CloseHandle(ipHandle);
}
}
return null;
}
public static List<Win32API.SYSTEM_HANDLE_INFORMATION>
GetHandles(Process process = null, string IN_strObjectTypeName = null, string IN_strObjectName = null)
{
uint nStatus;
int nHandleInfoSize = 0x10000;
IntPtr ipHandlePointer = Marshal.AllocHGlobal(nHandleInfoSize);
int nLength = 0;
IntPtr ipHandle = IntPtr.Zero;
while ((nStatus = Win32API.NtQuerySystemInformation(CNST_SYSTEM_HANDLE_INFORMATION, ipHandlePointer,
nHandleInfoSize, ref nLength)) ==
STATUS_INFO_LENGTH_MISMATCH)
{
nHandleInfoSize = nLength;
Marshal.FreeHGlobal(ipHandlePointer);
ipHandlePointer = Marshal.AllocHGlobal(nLength);
}
byte[] baTemp = new byte[nLength];
Marshal.Copy(ipHandlePointer, baTemp, 0, nLength);
long lHandleCount = 0;
if (Is64Bits())
{
lHandleCount = Marshal.ReadInt64(ipHandlePointer);
ipHandle = new IntPtr(ipHandlePointer.ToInt64() + 8);
}
else
{
lHandleCount = Marshal.ReadInt32(ipHandlePointer);
ipHandle = new IntPtr(ipHandlePointer.ToInt32() + 4);
}
Win32API.SYSTEM_HANDLE_INFORMATION shHandle;
List<Win32API.SYSTEM_HANDLE_INFORMATION> lstHandles = new List<Win32API.SYSTEM_HANDLE_INFORMATION>();
for (long lIndex = 0; lIndex < lHandleCount; lIndex++)
{
shHandle = new Win32API.SYSTEM_HANDLE_INFORMATION();
if (Is64Bits())
{
shHandle = (Win32API.SYSTEM_HANDLE_INFORMATION)Marshal.PtrToStructure(ipHandle, shHandle.GetType());
ipHandle = new IntPtr(ipHandle.ToInt64() + Marshal.SizeOf(shHandle) + 8);
}
else
{
ipHandle = new IntPtr(ipHandle.ToInt64() + Marshal.SizeOf(shHandle));
shHandle = (Win32API.SYSTEM_HANDLE_INFORMATION)Marshal.PtrToStructure(ipHandle, shHandle.GetType());
}
if (process != null)
{
if (shHandle.ProcessID != process.Id) continue;
}
string strObjectTypeName = "";
if (IN_strObjectTypeName != null){
strObjectTypeName = getObjectTypeName(shHandle, Process.GetProcessById(shHandle.ProcessID));
if (strObjectTypeName != IN_strObjectTypeName) continue;
}
string strObjectName = "";
if (IN_strObjectName != null){
strObjectName = getObjectName(shHandle, Process.GetProcessById(shHandle.ProcessID));
if (strObjectName != IN_strObjectName) continue;
}
string strObjectTypeName2 = getObjectTypeName(shHandle, Process.GetProcessById(shHandle.ProcessID));
string strObjectName2 = getObjectName(shHandle, Process.GetProcessById(shHandle.ProcessID));
Console.WriteLine("{0} {1} {2}", shHandle.ProcessID, strObjectTypeName2, strObjectName2);
lstHandles.Add(shHandle);
}
return lstHandles;
}
public static bool Is64Bits()
{
return Marshal.SizeOf(typeof(IntPtr)) == 8 ? true : false;
}
}
class Program
{
static void Main(string[] args)
{
try
{
WindowsIdentity identity = WindowsIdentity.GetCurrent();
WindowsPrincipal principal = new WindowsPrincipal(identity);
if (!principal.IsInRole(WindowsBuiltInRole.Administrator))
{
Console.WriteLine("===========================================================");
Console.WriteLine(" ");
Console.WriteLine("Please Run A3-Unlocker.exe as a \"Run As Administrator\" ");
Console.WriteLine(" ");
Console.WriteLine("===========================================================");
Console.WriteLine("Press Enter to Exit");
}
else {
String MutexName = "OnceMutexA3Client";
String ProcessName = "A3Client";
bool Violated = false;
Console.WriteLine("===========================================================");
Console.WriteLine(" ");
Console.WriteLine("Welcome To A3 Unlocker, Lets Kill Some Mutex");
Console.WriteLine(" ");
Console.WriteLine("===========================================================");
Console.WriteLine(" ");
try {
Process [] processes = Process.GetProcessesByName(ProcessName);
if (processes.Length == 0) {
Console.WriteLine("NO A3 Client Running");
Console.WriteLine(" ");
Console.WriteLine(" Please Run A3 Client First!!!");
Violated = false;
}
else {
Console.WriteLine("{0} A3 Instance", processes.Length);
foreach (var process in processes ) {
try
{
var handles = Win32Processes.GetHandles(process, "Mutant", "\\Sessions\\1\\BaseNamedObjects\\" + MutexName);
if (handles.Count == 0) throw new System.ArgumentException("NoMutex", "original");
foreach (var handle in handles) {
IntPtr ipHandle = IntPtr.Zero;
if (!Win32API.DuplicateHandle(Process.GetProcessById(handle.ProcessID).Handle, handle.Handle, Win32API.GetCurrentProcess(), out ipHandle, 0, false, Win32API.DUPLICATE_CLOSE_SOURCE))
Console.WriteLine("DuplicateHandle() failed, error = {0}", Marshal.GetLastWin32Error());
Console.WriteLine("Mutex was killed");
Violated = true;
}
}
catch (ArgumentException)
{
Console.WriteLine("The Mutex '{0}' was not found in the process '{1}'", MutexName, ProcessName);
Violated = true;
}
}
}
}
catch (IndexOutOfRangeException)
{
Console.WriteLine("NO A3 Client Running");
Console.WriteLine(" ");
Console.WriteLine(" Please Run A3 Client First!!!");
Violated = false;
}
if (Violated) {
Console.WriteLine(" ");
Console.WriteLine("We are done!!! Enjoy");
Console.WriteLine(" ");
Console.WriteLine("Must close this EXE before running another A3 Instance. Press Enter to exit");
}
}
}
catch (Exception ex)
{
if (ex != null) {}
}
Console.ReadLine();
}
}
}
What I have tried:
I already tried a conversion by APP but it returns me error
#include <string>
#include <vector>
#include <iostream>
#include <stdexcept>
namespace FileLockInfo
{
class Win32API
{
public:
enum class ObjectInformationClass : int
{
ObjectBasicInformation = 0,
ObjectNameInformation = 1,
ObjectTypeInformation = 2,
ObjectAllTypesInformation = 3,
ObjectHandleInformation = 4
};
public:
enum class ProcessAccessFlags : int
{
All = 0x001F0FFF,
Terminate = 0x00000001,
CreateThread = 0x00000002,
VMOperation = 0x00000008,
VMRead = 0x00000010,
VMWrite = 0x00000020,
DupHandle = 0x00000040,
SetInformation = 0x00000200,
QueryInformation = 0x00000400,
Synchronize = 0x00100000
};
public:
class OBJECT_BASIC_INFORMATION
{ public:
int Attributes = 0;
int GrantedAccess = 0;
int HandleCount = 0;
int PointerCount = 0;
int PagedPoolUsage = 0;
int NonPagedPoolUsage = 0;
int Reserved1 = 0;
int Reserved2 = 0;
int Reserved3 = 0;
int NameInformationLength = 0;
int TypeInformationLength = 0;
int SecurityDescriptorLength = 0;
System::Runtime::InteropServices::ComTypes::FILETIME CreateTime;
};
public:
class OBJECT_TYPE_INFORMATION
{ public:
UNICODE_STRING Name;
int ObjectCount = 0;
int HandleCount = 0;
int Reserved1 = 0;
int Reserved2 = 0;
int Reserved3 = 0;
int Reserved4 = 0;
int PeakObjectCount = 0;
int PeakHandleCount = 0;
int Reserved5 = 0;
int Reserved6 = 0;
int Reserved7 = 0;
int Reserved8 = 0;
int InvalidAttributes = 0;
GENERIC_MAPPING GenericMapping;
int ValidAccess = 0;
unsigned char Unknown = 0;
unsigned char MaintainHandleDatabase = 0;
int PoolType = 0;
int PagedPoolUsage = 0;
int NonPagedPoolUsage = 0;
};
public:
class OBJECT_NAME_INFORMATION
{ public:
UNICODE_STRING Name;
};
public:
class UNICODE_STRING
{
public:
unsigned short Length = 0;
unsigned short MaximumLength = 0;
void* Buffer;
};
public:
class GENERIC_MAPPING
{
public:
int GenericRead = 0;
int GenericWrite = 0;
int GenericExecute = 0;
int GenericAll = 0;
};
public:
class SYSTEM_HANDLE_INFORMATION
{ public:
int ProcessID = 0;
unsigned char ObjectTypeNumber = 0;
unsigned char Flags = 0; unsigned short Handle = 0;
int Object_Pointer = 0;
unsigned int GrantedAccess = 0;
};
public:
__declspec( dllimport ) static int NtQueryObject( IntPtr ObjectHandle, int ObjectInformationClass, IntPtr ObjectInformation, int ObjectInformationLength, int& returnLength );
__declspec( dllimport ) static unsigned int QueryDosDevice( const std::wstring& lpDeviceName, StringBuilder* lpTargetPath, int ucchMax );
__declspec( dllimport ) static unsigned int NtQuerySystemInformation( int SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength, int& returnLength );
__declspec( dllimport ) static IntPtr OpenMutex( unsigned int desiredAccess, bool inheritHandle, const std::wstring& name );
__declspec( dllimport ) static IntPtr OpenProcess( ProcessAccessFlags dwDesiredAccess, bool bInheritHandle, int dwProcessId );
__declspec( dllimport ) static int CloseHandle( IntPtr hObject );
__declspec( dllimport ) static bool DuplicateHandle( IntPtr hSourceProcessHandle, unsigned short hSourceHandle, IntPtr hTargetProcessHandle, IntPtr& lpTargetHandle, unsigned int dwDesiredAccess, bool bInheritHandle, unsigned int dwOptions );
__declspec( dllimport ) static IntPtr GetCurrentProcess();
static constexpr int MAX_PATH = 260;
static constexpr unsigned int STATUS_INFO_LENGTH_MISMATCH = 0xC0000004;
static constexpr int DUPLICATE_SAME_ACCESS = 0x2;
static constexpr int DUPLICATE_CLOSE_SOURCE = 0x1;
};
class Win32Processes
{
private:
static constexpr int CNST_SYSTEM_HANDLE_INFORMATION = 16;
static constexpr unsigned int STATUS_INFO_LENGTH_MISMATCH = 0xc0000004;
public:
static std::wstring getObjectTypeName( Win32API::SYSTEM_HANDLE_INFORMATION shHandle, Process* process )
{
void* m_ipProcessHwnd = Win32API::OpenProcess( Win32API::ProcessAccessFlags::All, false, process->Id );
void* ipHandle = void*::Zero;
auto objBasic = Win32API::OBJECT_BASIC_INFORMATION();
void* ipBasic = void*::Zero;
auto objObjectType = Win32API::OBJECT_TYPE_INFORMATION();
void* ipObjectType = void*::Zero;
void* ipObjectName = void*::Zero;
std::wstring strObjectTypeName = L"";
int nLength = 0;
int nReturn = 0;
void* ipTemp = void*::Zero;
if ( ! Win32API::DuplicateHandle( m_ipProcessHwnd, shHandle.Handle, Win32API::GetCurrentProcess(), ipHandle, 0, false, Win32API::DUPLICATE_SAME_ACCESS ) )
{
return L"";
}
ipBasic = Marshal::AllocHGlobal( System::Runtime::InteropServices::Marshal::SizeOf( objBasic ) );
Win32API::NtQueryObject( ipHandle, static_cast<int>( Win32API::ObjectInformationClass::ObjectBasicInformation ), ipBasic, System::Runtime::InteropServices::Marshal::SizeOf( objBasic ), nLength );
objBasic = static_cast<Win32API::OBJECT_BASIC_INFORMATION>( Marshal::PtrToStructure( ipBasic, objBasic->GetType() ) );
Marshal::FreeHGlobal( ipBasic );
ipObjectType = Marshal::AllocHGlobal( objBasic->TypeInformationLength );
nLength = objBasic->TypeInformationLength;
while ( static_cast<unsigned int>( nReturn = Win32API::NtQueryObject( ipHandle, static_cast<int>( Win32API::ObjectInformationClass::ObjectTypeInformation ), ipObjectType, nLength, nLength ) ) == Win32API::STATUS_INFO_LENGTH_MISMATCH )
{
Marshal::FreeHGlobal( ipObjectType );
ipObjectType = Marshal::AllocHGlobal( nLength );
}
objObjectType = static_cast<Win32API::OBJECT_TYPE_INFORMATION>( Marshal::PtrToStructure( ipObjectType, objObjectType->GetType() ) );
if ( Is64Bits() )
{
ipTemp = new void*( Convert::ToInt64( objObjectType->Name->Buffer->ToString(), 10 ) >> 32 );
} else
{
ipTemp = objObjectType->Name->Buffer;
}
strObjectTypeName = Marshal::PtrToStringUni( ipTemp, objObjectType->Name->Length >> 1 );
Marshal::FreeHGlobal( ipObjectType );
return strObjectTypeName;
}
static std::wstring getObjectName( Win32API::SYSTEM_HANDLE_INFORMATION shHandle, Process* process )
{
void* m_ipProcessHwnd = Win32API::OpenProcess( Win32API::ProcessAccessFlags::All, false, process->Id );
void* ipHandle = void*::Zero;
auto objBasic = Win32API::OBJECT_BASIC_INFORMATION();
void* ipBasic = void*::Zero;
void* ipObjectType = void*::Zero;
auto objObjectName = Win32API::OBJECT_NAME_INFORMATION();
void* ipObjectName = void*::Zero;
std::wstring strObjectName = L"";
int nLength = 0;
int nReturn = 0;
void* ipTemp = void*::Zero;
if ( ! Win32API::DuplicateHandle( m_ipProcessHwnd, shHandle.Handle, Win32API::GetCurrentProcess(), ipHandle, 0, false, Win32API::DUPLICATE_SAME_ACCESS ) )
{
return L"";
}
ipBasic = Marshal::AllocHGlobal( System::Runtime::InteropServices::Marshal::SizeOf( objBasic ) );
Win32API::NtQueryObject( ipHandle, static_cast<int>( Win32API::ObjectInformationClass::ObjectBasicInformation ), ipBasic, System::Runtime::InteropServices::Marshal::SizeOf( objBasic ), nLength );
objBasic = static_cast<Win32API::OBJECT_BASIC_INFORMATION>( Marshal::PtrToStructure( ipBasic, objBasic->GetType() ) );
Marshal::FreeHGlobal( ipBasic );
nLength = objBasic->NameInformationLength;
ipObjectName = Marshal::AllocHGlobal( nLength );
while ( static_cast<unsigned int>( nReturn = Win32API::NtQueryObject( ipHandle, static_cast<int>( Win32API::ObjectInformationClass::ObjectNameInformation ), ipObjectName, nLength, nLength ) ) == Win32API::STATUS_INFO_LENGTH_MISMATCH )
{
Marshal::FreeHGlobal( ipObjectName );
ipObjectName = Marshal::AllocHGlobal( nLength );
}
objObjectName = static_cast<Win32API::OBJECT_NAME_INFORMATION>( Marshal::PtrToStructure( ipObjectName, objObjectName->GetType() ) );
if ( Is64Bits() )
{
ipTemp = new void*( Convert::ToInt64( objObjectName->Name->Buffer->ToString(), 10 ) >> 32 );
} else
{
ipTemp = objObjectName->Name->Buffer;
}
if ( ipTemp != void*::Zero )
{
unsigned char baTemp2[ nLength ];
try
{
Marshal::Copy( ipTemp, baTemp2, 0, nLength );
strObjectName = Marshal::PtrToStringUni( Is64Bits() ? new void*(ipTemp.ToInt64()) : new void*(ipTemp.ToInt32()) );
return strObjectName;
} catch ( AccessViolationException e1 )
{
return L"";
} finally
{
Marshal::FreeHGlobal( ipObjectName );
Win32API::CloseHandle( ipHandle );
}
}
return L"";
}
static std::vector<Win32API::SYSTEM_HANDLE_INFORMATION> GetHandles( Process* process = nullptr, const std::wstring& IN_strObjectTypeName = L"", const std::wstring& IN_strObjectName = L"" )
{
unsigned int nStatus;
int nHandleInfoSize = 0x10000;
void* ipHandlePointer = Marshal::AllocHGlobal( nHandleInfoSize );
int nLength = 0;
void* ipHandle = void*::Zero;
while ( ( nStatus = Win32API::NtQuerySystemInformation( CNST_SYSTEM_HANDLE_INFORMATION, ipHandlePointer, nHandleInfoSize, nLength ) ) == STATUS_INFO_LENGTH_MISMATCH )
{
nHandleInfoSize = nLength;
Marshal::FreeHGlobal( ipHandlePointer );
ipHandlePointer = Marshal::AllocHGlobal( nLength );
}
unsigned char baTemp[ nLength ];
Marshal::Copy( ipHandlePointer, baTemp, 0, nLength );
long long lHandleCount = 0;
if ( Is64Bits() )
{
lHandleCount = Marshal::ReadInt64( ipHandlePointer );
ipHandle = new void*( ipHandlePointer.ToInt64() + 8 );
} else
{
lHandleCount = Marshal::ReadInt32( ipHandlePointer );
ipHandle = new void*( ipHandlePointer.ToInt32() + 4 );
}
Win32API::SYSTEM_HANDLE_INFORMATION shHandle;
std::vector<Win32API::SYSTEM_HANDLE_INFORMATION> lstHandles = std::vector<Win32API::SYSTEM_HANDLE_INFORMATION>();
for ( long long lIndex = 0; lIndex < lHandleCount; lIndex ++ )
{
shHandle = Win32API::SYSTEM_HANDLE_INFORMATION();
if ( Is64Bits() )
{
shHandle = static_cast<Win32API::SYSTEM_HANDLE_INFORMATION>( Marshal::PtrToStructure( ipHandle, shHandle.GetType() ) );
ipHandle = new void*( ipHandle.ToInt64() + System::Runtime::InteropServices::Marshal::SizeOf(shHandle) + 8 );
} else
{
ipHandle = new void*( ipHandle.ToInt64() + System::Runtime::InteropServices::Marshal::SizeOf(shHandle) );
shHandle = static_cast<Win32API::SYSTEM_HANDLE_INFORMATION>( Marshal::PtrToStructure( ipHandle, shHandle.GetType() ) );
}
if ( process != nullptr )
{
if ( shHandle.ProcessID != process->Id )
{
continue;
}
}
std::wstring strObjectTypeName = L"";
if ( IN_strObjectTypeName != L"" )
{
strObjectTypeName = getObjectTypeName( shHandle, Process::GetProcessById( shHandle.ProcessID ) );
if ( strObjectTypeName != IN_strObjectTypeName )
{
continue;
}
}
std::wstring strObjectName = L"";
if ( IN_strObjectName != L"" )
{
strObjectName = getObjectName( shHandle, Process::GetProcessById( shHandle.ProcessID ) );
if ( strObjectName != IN_strObjectName )
{
continue;
}
}
std::wstring strObjectTypeName2 = getObjectTypeName( shHandle, Process::GetProcessById( shHandle.ProcessID ) );
std::wstring strObjectName2 = getObjectName( shHandle, Process::GetProcessById( shHandle.ProcessID ) );
std::cout << shHandle.ProcessID << std::wstring( L" " ) << strObjectTypeName2 << std::wstring( L" " ) << strObjectName2 << std::endl;
lstHandles.push_back( shHandle );
}
return lstHandles;
}
static bool Is64Bits()
{
return System::Runtime::InteropServices::Marshal::SizeOf( void*::typeid ) == 8 ? true : false;
}
};
class Program
{
static void Main( std::wstring& args[] )
{
try
{
WindowsIdentity* identity = WindowsIdentity::GetCurrent();
WindowsPrincipal* principal = new WindowsPrincipal( identity );
if ( ! principal->IsInRole( WindowsBuiltInRole::Administrator ) )
{
std::cout << std::wstring( L"===========================================================" ) << std::endl;
std::cout << std::wstring( L" " ) << std::endl;
std::cout << std::wstring( L"Please Run A3-Unlocker.exe as a \"Run As Administrator\" " ) << std::endl;
std::cout << std::wstring( L" " ) << std::endl;
std::cout << std::wstring( L"===========================================================" ) << std::endl;
std::cout << std::wstring( L"Press Enter to Exit" ) << std::endl;
} else
{
std::wstring MutexName = L"OnceMutexA3Client";
std::wstring ProcessName = L"A3Client";
bool Violated = false;
std::cout << std::wstring( L"===========================================================" ) << std::endl;
std::cout << std::wstring( L" " ) << std::endl;
std::cout << std::wstring( L"Welcome To A3 Unlocker, Lets Kill Some Mutex" ) << std::endl;
std::cout << std::wstring( L" " ) << std::endl;
std::cout << std::wstring( L"===========================================================" ) << std::endl;
std::cout << std::wstring( L" " ) << std::endl;
try
{
Process* processes = Process::GetProcessesByName( ProcessName );
if ( processes->Length == 0 )
{
std::cout << std::wstring( L"NO A3 Client Running" ) << std::endl;
std::cout << std::wstring( L" " ) << std::endl;
std::cout << std::wstring( L" Please Run A3 Client First!!!" ) << std::endl;
Violated = false;
} else
{
std::cout << processes->Length << std::endl;
for ( auto process : processes )
{
try
{
auto handles = Win32Processes::GetHandles( process, L"Mutant", std::wstring( L"\\Sessions\\1\\BaseNamedObjects\\" ) + MutexName );
if ( handles->Count == 0 )
{
throw System::ArgumentException( L"NoMutex", L"original" );
}
for ( auto handle : handles )
{
void* ipHandle = void*::Zero;
if ( ! Win32API::DuplicateHandle( Process::GetProcessById( handle->ProcessID )->Handle, handle->Handle, Win32API::GetCurrentProcess(), ipHandle, 0, false, Win32API::DUPLICATE_CLOSE_SOURCE ) )
{
std::cout << std::wstring( L"DuplicateHandle() failed, error = " ) << Marshal::GetLastWin32Error() << std::endl;
}
std::cout << std::wstring( L"Mutex was killed" ) << std::endl;
Violated = true;
}
}
catch ( ArgumentException e1 )
{
std::cout << std::wstring( L"The Mutex '" ) << MutexName << std::wstring( L"' was not found in the process '" ) << ProcessName << std::endl;
Violated = true;
}
}
}
} catch ( IndexOutOfRangeException e2 )
{
std::cout << std::wstring( L"NO A3 Client Running" ) << std::endl;
std::cout << std::wstring( L" " ) << std::endl;
std::cout << std::wstring( L" Please Run A3 Client First!!!" ) << std::endl;
Violated = false;
}
if ( Violated )
{
std::cout << std::wstring( L" " ) << std::endl;
std::cout << std::wstring( L"We are done!!! Enjoy" ) << std::endl;
std::cout << std::wstring( L" " ) << std::endl;
std::cout << std::wstring( L"Must close this EXE before running another A3 Instance. Press Enter to exit" ) << std::endl;
}
}
} catch ( std::exception& ex )
{
if ( ex != nullptr )
{
}
}
Console::ReadLine();
}
};
}