Prozesse oder Anwendungen ermitteln, die eine Datei benutzen

[daPimP]

Da mir das Thema nicht aus dem Kopf geht, werde ich in geraumer Zeit einige Fortschritte hier posten,
hoffe das wir der Lsg dann Näher kommen.

Ich halte nochmal fest:

ZIEL: eine X-beliebige Datei (nicht nur dll, exe) soll überprüft werden, von welchem Prozess
sie gerade benutzt wird.


AUFGABE: Ermitteln des HANDLE der Datei (und ich rede hier nicht von den Fensterhandles)

Verwirklicht wurde das schon im Programm Unlocker und im C++ SourceCode codeguru.com

Desweiteren ist das bloße Anzeigen des speziellen Handles definiv ONHE Treiberdatei möglich.
(im Gegensatz zu Unlocker)

Es reicht wenn es unter XP läuft.

FORTSCHRITT:
meine Delphi Übersetzung:

Hier soll ein Prozess per PID überprüft werden, und ALLE seine Handleverknüpfungen angezeigt werden.
Ich bekomme auch eine Zahl, die im Bereich der Handles liegt zurück, kann sie aber nicht zuordnen.

Delphi-Quellcode:

(*
Note: 1. SE_DEBUG privilege must be enabled.                   OK
      2. The function works with every kind of HANDLE
      3. It will bother the remote process :)
      4. The handles will be invalid after you closed          OK
         them remotely
*)

function CloseRemoteHandle(processID: DWORD; lpparameter: pointer ):DWORD;
var
  ht :THANDLE;
  rc : DWORD;
  hProcess: THandle;
  hKernel32: cardinal;
begin
 TRY
 lpparameter:= nil;
   ht:=0;
   rc:=0;
   // open the process
   HPROcESS:= OpenProcess(PROCESS_CREATE_THREAD
                                or PROCESS_VM_OPERATION
                                or PROCESS_VM_WRITE
                                or PROCESS_VM_READ, FALSE, processID);
   if  hProcess = 0 then
     showmessage('hprocess ist null'); //tritt nicht ein

   // load kernel32.dll
   hKernel32 := LoadLibrary('kernel32.dll');

   // CreateRemoteThread()
   ht := CreateRemoteThread(
   hProcess,
   0,
   0,
   GetProcAddress(hKernel32, 'CloseHandle'),
   lpparameter,        //////was mach ich hiermit?????
   0,
   rc ); 

    if  ht =0 then begin
     rc := GetLastError();
     showmessage('ht ist null');               //tritt nicht ein
   end;

   case WaitForSingleObject(ht, 2000) of
     WAIT_OBJECT_0:  begin  end;               //OK
   else
     rc := GetLastError();                     //tritt nicht ein
     showmessage('Fehler WaitForSingle:');
   end;
 FINALLY
  result:= rc;      
  showmessage('rc  :'+ inttostr(rc)+'  ht  :'+ inttostr(ht))  //zum Anzeigen der Werte

  CloseHandle(ht);

  //Free up the kernel32.dll
  if  hKernel32 <> 0 then
    FreeLibrary(hKernel32);

  CloseHandle(hProcess);
 END;
end;


procedure Tform1.Button1Click(Sender: TObject);      
var PID: cardinal;
begin
 PID:= ....;
 CloseRemoteHandle(PID, 0);  //die null is auch nicht astrein...
end;

der Original C++ Code

Delphi-Quellcode:

/*
Note: 1. SE_DEBUG privilege must be enabled.
      2. The function works with every kind of HANDLE
      3. It will bother the remote process :)
      4. The handles will be invalid after you closed
         them remotely
*/

//Close a handle in a remote process
DWORD CloseRemoteHandle( DWORD processID, HANDLE handle )
{
 HANDLE ht = 0;
 DWORD rc = 0;

 _tprintf( _T("Closing handle in process #%d ... "),
          processID );

 // open the process
 HANDLE hProcess = OpenProcess( PROCESS_CREATE_THREAD
                                | PROCESS_VM_OPERATION
                                | PROCESS_VM_WRITE
                                | PROCESS_VM_READ,
                                FALSE, processID );

 if ( hProcess == NULL )
 {
  rc = GetLastError();
  _tprintf( _T("OpenProcess() failed\n") );
  return rc;
 }

 // load kernel32.dll
 HMODULE hKernel32 = LoadLibrary( _T("kernel32.dll") );

 // CreateRemoteThread()
 ht = CreateRemoteThread(
  hProcess,
  0,
  0,
  (DWORD(__stdcall *)(void*))GetProcAddress(hKernel32,"CloseHandle"),
  handle,
  0,
  &rc );

 if ( ht == NULL )
 {
  //Something is wrong with the privileges,
  //or the process doesn't like us
  rc = GetLastError();
  _tprintf( _T("CreateRemoteThread() failed\n") );
  goto cleanup;
 }

 switch ( WaitForSingleObject( ht, 2000 ) )
 {
  case WAIT_OBJECT_0:
   //Well done
   rc = 0;
   _tprintf( _T("Ok\n"), rc );
  break;

  default:
   //Oooops, shouldn't be here
   rc = GetLastError();
   _tprintf( _T("WaitForSingleObject() failed\n") );
   goto cleanup;
  break;
 }

 cleanup:
 //Closes the remote thread handle
 CloseHandle( ht );

 //Free up the kernel32.dll
 if ( hKernel32 != NULL)
  FreeLibrary( hKernel32 );

 //Close the process handle
 CloseHandle( hProcess );

 return rc;
}

FRAGE: Ist die Übersetzung soweit in Ordnung? Irgendwelche konstruktiven Anregungen?