chemin des processus actif windowsRésolu

Question

je veut recuperer un chemain d'un fichier en cour d'execution comme explorer  dans les processus : 
" c:\windows\explorer.exe " 
s.v.p repondez mon au plus vite possible merci

Caribensila · Accepted Answer

- Et faire une petite recherche sur le site? 
- Hein?  
- Non? 
- Pas trop envie?  
- Ca ne te dit pas trop ce soir, on dirait...
- Une petite flemme?..
- Pourtant, si ça ne te ferait sans doute pas beaucoup de bien côté cérébral vu la paresse du bazar2020, au moins ça musclerait tes petits doigts atrophiés
...

N'oublie jamais ça :
 « Pas de doigt? - Pas de chocolatsur CS 
! »

bazbaz2020 · Answer

je veut recuperer un chemain d'un fichier en cour d'execution comme explorer dans les processus : " c:\windows\explorer.exe " s.v.p repondez mon au plus vite possible merci

Francky23012301 · Answer

[auteur/BAZBAZ2020/1119196.aspx bazbaz2020] : tu peux nous le refaire stp, Cari n'a pas compris je crois

repondez mon au plus vite possible merci : ben tu crois qu'on prend notre temps ? on est à fond là  mais vu le verglas difficile de poster plus vite . Va falloir attendre que les admins mettent du sel .

Caribensila · Answer

Hé! Francky!
T'es bien le roi des mauvaises excuses!
Et la paire de raquettes que je t'ai prêtée hier, hein?!...

Ah! J'entends Cirec qui arrive avec le chasse-neige de CS... 'va dégager le chemin du fichier...

Francky23012301 · Answer

Hé ho ho hé : t'étais bien content que je les prenne les raquettes pour installer le pétard mouillé sur la chèvre. 

Oué oué j'entend Cirec avec son klaxon : roule vite quand même le gars . La dernière fois il a explosé le tire-fesse  . Je te raconte pas la tête de la grosse Josianne le lendemain quand elle a du se taper la piste du Grand ASM en peau phoque : Avec f0xi on était mdrrrr 

Sinon tu as bien recu ton renouvellement de contrat pour CS en ce qui concerne ton job de pisteur ? Moi ils ont pas voulu ; Il parait que je provoque trop d'avalanches  : il y en a quand meme je t'assure ils sont jamais content .

Caribensila · Answer

Ah ouais?..  C'est pour ça que j'avais trouvé la grosse Josianne un peu ramolo ce soir-là... C'était bien la première fois qu'elle n'avait pas dansé à poil sur la table, à la fin du repas de Delphifr !  
(je m'en souviens bien car ça m'avait un peu choqué ce soir-là, perso.)

Ouais, ouais! J'ai bien reçu mon contrat. Y'avait même la prime de fin d'année avec.  Il ne s'est pas foutu de nous, l'ami Nix! On voit que les affaires marchent bien sur CS. Cirec a pu s'acheter un nouveau chasse-neige et f0xi un écran 19 pieds...
Moi, j'ai tout placé en subprimes, comme d'hab. J'ai eu une petite perte l'année dernière, mais PCPT, sympa, a compensé avec la caisse noire.

Au fait... T'as pas peur de faire des envieux en disant à tous que Nix déménage nos bureaux à Megève l'hiver?

bazbaz2020 · Answer

je veut recuperer un chemain d'un fichier en cour d'execution comme explorer dans les processus : " c:\windows\explorer.exe "

Caribensila · Answer

'tain ! Y'a encore l'bazar2020 qu'est toujours perdu dans la montagne !
On l'avait oublié!

J'pensais que Cirec l'avait récupéré, moi...

'va pas passer la nuit, à mon avis.

bazbaz2020 · Answer

repondez moi svp

Francky23012301 · Answer

P'tain mais il est ou : je le vois et l'entend pas le lascard : tu l'entends toi ? Avec tout le bruit que fait Cirec on entend que dalle

beckerich · Answer

allez je suis bon prince, je réponds :

c:\windows\explorer.exe

bonne nuit.
Lucho

bazbaz2020 · Answer

merci mais j'ai pas trouver un exemple qui donne le chemin d'un processus .
dans mon application je veut fair une liste des processuse (résolu) mais je veut aussi affichier le chemain de chaque processuse . répondéz moi s.v.p

Caribensila · Answer

Y'en a marre de risquer sa vie pour des mecs qui font du hors-piste, je trouve !

bazbaz2020 · Answer

je veut fair un logiciel comme Process Explorer

cs_rt15 · Answer

Salut,

Dites les gens, c'est fini de martyriser bazbaz un peu ? 

En plus, je ne crois pas qu'il y ait un tel code sur tout delphifr ! 

Non non, un autre que celui sur cette page.

Voici donc une solution qui utilise une fonction "non documentée". Cette fonction permet de récupérer un pointeur sur un jeu de structures... Non documentées.

En fait, c'est un abus de langage : la fonction et les structures sont documentées (ici). Il y a cependant des remarques dans ce style :
[NtQueryInformationProcess may be altered or unavailable in future versions of Windows. Applications should use the alternate functions listed in this topic.]

Bref, ce code peut fonctionner sur certaines versions de Windows et pas sur d'autres.

J'imagine qu'il devrait fonctionner correctement sur 2000, XP et Vista (Peut être faut exécuter le processus en tant qu'admin). Je l'ai développé sous XP/Delphi 6.

Autre solution : utiliser WMI et sa classe Win32_Process.
Encore autre solution : injection de code et utilisation de GetModuleFilename(0).

Mais quelle que soit la solution, c'est relativement lourd, relativement technique à écrire, et pas des plus portable.
 unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, TLHelp32;

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;

var
  Form1: TForm1;

{
PEB inspiré de celle de Nico Bendlin :
http://www.faqsen.de/delphi/faq_print.jsp?ID=505448494850494849545250
}

type TNtAnsiString = packed record
  Length: Word;
  MaximumLength: Word;
  Buffer: PAnsiChar;
end;

type TNtUnicodeString = packed record
  Length: Word;
  MaximumLength: Word;
  Buffer: PWideChar;
end;

type TClientId = record
  UniqueProcess: THandle;
  UniqueThread: THandle;
end;

type TPebLdrData = packed record
  Length: Cardinal;
  Initialized: LongBool;
  SsHandle: THandle;
  InLoadOrderModuleList: TListEntry;
  InMemoryOrderModuleList: TListEntry;
  InInitializationOrderModuleList: TListEntry;
end;

type TCurDir = packed record
  DosPath: TNtUnicodeString;
  Handle : THandle;
end;

type TRtlDriveLetterCurDir = packed record
  Flags    : Word;
  Length   : Word;
  TimeStamp: Cardinal;
  DosPath  : TNtAnsiString;
end;

type TRtlUserProcessParameters = record
  MaximumLength    : Cardinal;
  Length           : Cardinal;
  Flags            : Cardinal;
  DebugFlags       : Cardinal;
  ConsoleHandle    : THandle;
  ConsoleFlags     : Cardinal;
  StandardInput    : THandle;
  StandardOutput   : THandle;
  StandardError    : THandle;
  CurrentDirectory : TCurDir;
  DllPath          : TNtUnicodeString;
  ImagePathName    : TNtUnicodeString;
  CommandLine      : TNtUnicodeString;
  Environment      : Pointer;
  StartingX        : Cardinal;
  StartingY        : Cardinal;
  CountX           : Cardinal;
  CountY           : Cardinal;
  CountCharsX      : Cardinal;
  CountCharsY      : Cardinal;
  FillAttribute    : Cardinal;
  WindowFlags      : Cardinal;
  ShowWindowFlags  : Cardinal;
  WindowTitle      : TNtUnicodeString;
  DesktopInfo      : TNtUnicodeString;
  ShellInfo        : TNtUnicodeString;
  RuntimeData      : TNtUnicodeString;
  CurrentDirectores: array [0..31] of TRtlDriveLetterCurDir;
end;

type TPebFreeBlock = record
  Next: Pointer;
  Size: Cardinal;
end;

type TPeb = packed record
  InheritedAddressSpace         : Boolean;
  ReadImageFileExecOptions      : Boolean;
  BeingDebugged                 : Boolean;
  SpareBool                     : Boolean;
  Mutant                        : Pointer;  // THandle
  ImageBaseAddress              : Pointer;
  Ldr                           : ^TPebLdrData;
  ProcessParameters             : ^TRtlUserProcessParameters;
  SubSystemData                 : Pointer;
  ProcessHeap                   : Pointer;  // THandle
  FastPebLock                   : Pointer;
  FastPebLockRoutine            : Pointer;
  FastPebUnlockRoutine          : Pointer;
  EnvironmentUpdateCount        : Cardinal;
  KernelCallbackTable           : Pointer;
  case Integer of
    4: (
      EventLogSection           : Pointer;   // THandle
      EventLog                  : Pointer);  // THandle
    5: (
      SystemReserved            : array [0..1] of Cardinal;
 { end; }
  FreeList                      : ^TPebFreeBlock;
  TlsExpansionCounter           : Cardinal;
  TlsBitmap                     : Pointer;
  TlsBitmapBits                 : array [0..1] of Cardinal;
  ReadOnlySharedMemoryBase      : Pointer;
  ReadOnlySharedMemoryHeap      : Pointer;
  ReadOnlyStaticServerData      : ^Pointer;
  AnsiCodePageData              : Pointer;
  OemCodePageData               : Pointer;
  UnicodeCaseTableData          : Pointer;
  NumberOfProcessors            : Cardinal;
  NtGlobalFlag                  : Cardinal;
  Unknown                       : Cardinal;
  CriticalSectionTimeout        : _LARGE_INTEGER;
  HeapSegmentReserve            : Cardinal;
  HeapSegmentCommit             : Cardinal;
  HeapDeCommitTotalFreeThreshold: Cardinal;
  HeapDeCommitFreeBlockThreshold: Cardinal;
  NumberOfHeaps                 : Cardinal;
  MaximumNumberOfHeaps          : Cardinal;
  ProcessHeaps                  : ^Pointer;
  GdiSharedHandleTable          : Pointer;
  ProcessStarterHelper          : Pointer;
  GdiDCAttributeList            : Cardinal;
  LoaderLock                    : Pointer;
  OSMajorVersion                : Cardinal;
  OSMinorVersion                : Cardinal;
  OSBuildNumber                 : Word;
  OSCSDVersion                  : Word;
  OSPlatformId                  : Cardinal;
  ImageSubsystem                : Cardinal;
  ImageSubsystemMajorVersion    : Cardinal;
  ImageSubsystemMinorVersion    : Cardinal;
  ImageProcessAffinityMask      : Cardinal;
  GdiHandleBuffer               : array [0..33] of Cardinal;
  { Windows 2000 - begin }
  PostProcessInitRoutine        : ^Pointer;  // ^function
  TlsExpansionBitmap            : Pointer;
  TlsExpansionBitmapBits        : array [0..31] of Cardinal;
  SessionId                     : Cardinal;
  AppCompatInfo                 : Pointer;
  CSDVersion                    : TNtUnicodeString);
  { Windows 2000 - end }
end;

type TProcessBasicInformation = packed record
  ExitStatus: Cardinal;
  PebBaseAddress: Pointer;
  AffinityMask: Cardinal;
  BasePriority: Cardinal;
  UniqueProcessId: Cardinal;
  InheritedUniquePID: Cardinal;
end;

const
  SE_DEBUG_NAME: String = 'SeDebugPrivilege';
  ProcessBasicInformation: Integer = 0;

function NtQueryInformationProcess(
  ProcessHandle: THandle;
  ProcessInformationClass: Cardinal;
  var ProcessInformation: TProcessBasicInformation;
  ProcessInformationLength: Cardinal;
  var ReturnLength: Cardinal
  ): Integer; stdcall; external 'NtDll.dll';

implementation

{$R *.dfm}

function RetrieveProcessExePath(hProcess: THandle): String;
var
  processInfo: TProcessBasicInformation;    // Informations sur le processus
  peb: TPeb;                                // Process Environment Block
  processParams: TRtlUserProcessParameters; // Contient le chemin
  lpUnicodePath: array[0..MAX_PATH] of WideChar;
  nBuffer: Cardinal;
begin
  Result:= '';

  ZeroMemory(@lpUnicodePath, SizeOf(lpUnicodePath));

  if NtQueryInformationProcess(hProcess, ProcessBasicInformation, processInfo,
                               SizeOf(processInfo), nBuffer) >= 0 then
    if ReadProcessMemory(hProcess, processInfo.PebBaseAddress,
                         @peb, SizeOf(peb), nBuffer) then
      if ReadProcessMemory(hProcess, peb.ProcessParameters,
                           @processParams, SizeOf(processParams), nBuffer) then
        with processParams.ImagePathName do
        begin
          if ReadProcessMemory(hProcess, Buffer,
                           @lpUnicodePath, Length, nBuffer) then
            Result:= lpUnicodePath;
        end;
end;

procedure EnableTokenPrivilege(lpPrivilege: String);
var
  hToken: THandle;                // Handle sur le token
  tokenPriv: TTokenPrivileges;    // Tableau de privilèges
  nBuffer: Cardinal;         
begin
  // TTokenPrivileges ne propose qu'une entrée
  tokenPriv.PrivilegeCount:= 1;

  // Récupération du token du processus
  if not OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES,
                          hToken) then RaiseLastOSError;

  // Recherche du LUID associé au privilège
  if not LookupPrivilegeValue(nil, PChar(lpPrivilege),
                              tokenPriv.Privileges[0].Luid) then
  begin
    CloseHandle(hToken);
    RaiseLastOSError;
  end;

  // On va demandé l'activation du privilège
  tokenPriv.Privileges[0].Attributes:= SE_PRIVILEGE_ENABLED;

  // Activation du privilège
  if not AdjustTokenPrivileges(hToken, False, tokenPriv, 0, nil, nBuffer) then
  begin
    CloseHandle(hToken);
    RaiseLastOSError;
  end;

  CloseHandle(hToken);
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  hProcessSnap: THandle;  // Handle du snapshot
  hProcess: Thandle;      // Handle sur le processus à traiter
  pe32: PROCESSENTRY32;   // Informations sur un processus
  lpPath: String;         // Chemin de l'exe
begin
  Memo1.Clear;

  // Activation du privilège de debug pour ce processus
  EnableTokenPrivilege(SE_DEBUG_NAME);

  // Pris du snapshot
  hProcessSnap:= CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  if hProcessSnap = INVALID_HANDLE_VALUE then
  begin
    ShowMessage('Echec du snapshot');
    Exit;
  end;

  // Affectation de la taille de la structure avant utilisation
  pe32.dwSize:= SizeOf(PROCESSENTRY32);

  // Récupération des infos sur le premier processus
  if not Process32First(hProcessSnap, pe32) then
  begin
    ShowMessage('Echec de la récupération du premier processus');
    CloseHandle(hProcessSnap);
    Exit;
  end;

  // On boucle sur les processus
  repeat
    // Récupération d'un handle sur le processus
    hProcess:= OpenProcess(PROCESS_QUERY_INFORMATION or PROCESS_VM_READ,
                           False, pe32.th32ProcessID);

    if hProcess <> INVALID_HANDLE_VALUE then
    begin
      lpPath:= RetrieveProcessExePath(hProcess);
      if lpPath = '' then lpPath:= pe32.szExeFile;
      Memo1.Lines.Add(lpPath);
      CloseHandle(hProcess);
    end
    else
      ShowMessage('Impossible de récupérer un handle sur ' + pe32.szExeFile);
      
  until not Process32Next(hProcessSnap, pe32);

  CloseHandle(hProcessSnap);
end;

end.

cs_rt15 · Answer

Mouarf !

Mais qu'il est nul ce rt15 ! Encore heureux qu'il y a une fonction ! Et elle a même déjà été utilisée sur delphifr !

Et voilà qu'il sort la grosse artillerie pour écraser une mouche... Ridicule. Vraiment.

Bon y a une fonction pour Vista apparemment...

Mais y a surtout GetModuleFileNameEx :
 unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, TLHelp32, PsApi;

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
var
  hProcessSnap: THandle;  // Handle du snapshot
  hProcess: Thandle;      // Handle sur le processus à traiter
  pe32: PROCESSENTRY32;   // Informations sur un processus
  lpName: Array[0..200] of Char;
begin
  Memo1.Clear;

  // Pris du snapshot
  hProcessSnap:= CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  if hProcessSnap = INVALID_HANDLE_VALUE then
  begin
    ShowMessage('Echec du snapshot');
    Exit;
  end;

  // Affectation de la taille de la structure avant utilisation
  pe32.dwSize:= SizeOf(PROCESSENTRY32);

  // Récupération des infos sur le premier processus
  if not Process32First(hProcessSnap, pe32) then
  begin
    ShowMessage('Echec de la récupération du premier processus');
    CloseHandle(hProcessSnap);
    Exit;
  end;

  // On boucle sur les processus
  repeat
    // Récupération d'un handle sur le processus
    hProcess:= OpenProcess(PROCESS_QUERY_INFORMATION or PROCESS_VM_READ,
                           False, pe32.th32ProcessID);

    if hProcess <> INVALID_HANDLE_VALUE then
    begin
      GetModuleFileNameEx(hProcess, 0, @lpName, 200);
      Memo1.Lines.Add(lpName);
      CloseHandle(hProcess);
    end
    else
      ShowMessage('Impossible de récupérer un handle sur ' + pe32.szExeFile);
     
  until not Process32Next(hProcessSnap, pe32);

  CloseHandle(hProcessSnap);
end;

end.

azizx2 · Answer

bonsoir; je pense avoir la solution 

function trouver_ficpr(P: DWORD): string;
var
  Handle: THandle;
  dll: Cardinal;
  GetModuleFileNameEx: function(hProcess: THandle; hModule: HMODULE;
    lpFilename: PChar; nSize: DWORD): DWORD; stdcall;
begin
  Result := '';
  Handle := OpenProcess(PROCESS_QUERY_INFORMATION or PROCESS_VM_READ, False, P);
  if Handle <> 0 then
  try
    SetLength(Result, MAX_PATH);
    begin
      dll := LoadLibrary(pchar('PSAPI.dll'));
      @GetModuleFileNameEx := GetProcAddress(dll, pchar('GetModuleFileNameExA'));

      if GetModuleFileNameEx(Handle, 0, PChar(Result), MAX_PATH) > 0 then
      SetLength(Result, StrLen(PChar(Result)))
      else
      Result := '';
    end;
    finally
    CloseHandle(Handle);
  end;
end;

Bien entendu en listant la liste des processus actifs, tu envoi le Id_process de chaque processus trouvé à la fonction proposée si-dessus et tu devrais pouvoir récupérer le chemins en résultat genre (rouver_ficpr(ProcessEntry.th32ProcessID));
j'espère avoir pu aider cordialement.

Chemin des processus actif windows

17 réponses

Votre réponse

Discussions similaires