Benutzer von Prozessen

hallo!

Mit diesem Code lese ich die Prozesse aus:
HANDLE hSnapShot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);

PROCESSENTRY32* processInfo = new PROCESSENTRY32;
processInfo->dwSize = sizeof ( PROCESSENTRY32);

int i=0;

if(Process32First(hSnapShot, processInfo))
{
do
{
i++;
sprintf(buffer,"Prozess %04i %08i %s ",i, processInfo->th32ProcessID,processInfo->szExeFile);
SendMessage(hListProc,LB_ADDSTRING,0,(long)buffer);
}while(Process32Next(hSnapShot, processInfo));
}

CloseHandle (hSnapShot);

delete processInfo;

gibt es eine möglichkeit herauszufinden, zu welchem benutzer welcher prozess gehört??

danke,mfg

Hol dir die SID von dem Prozess und lösen sie entsprechend auf.

http://www.michael-puff.de/Developer/Artikel/2006_06/sid.shtml

hallo,
vielen dank,
aber wie kann ich die SID vom Prozess bekommen??

danke,
mfg

thesparrow schrieb:

hallo,
vielen dank,
aber wie kann ich die SID vom Prozess bekommen??
danke,
mfg

http://www.michael-puff.de/Developer/Artikel/2006_06/sid.shtml

Bitte mfg

kernel64

Vielleicht hilfts:

http://msdn2.microsoft.com/en-US/library/aa379554.aspx

Here we go:

program Project1;

{$APPTYPE CONSOLE}

uses
  Windows;

function GetSecurityInfo(handle: THandle; ObjectType: DWord; SecurityInfo: SECURITY_INFORMATION; ppsidOwner: PSID;
  ppsidGroup: PSID; ppDacl: PACL; ppSacl: PACL; ppSecurityDescriptor: PSECURITY_DESCRIPTOR): DWORD; stdcall; external
'advapi32.dll';
function ConvertSidToStringSid(Sid: PSID; var StringSid: PChar): LongBool; stdcall; external 'advapi32.dll' name
'ConvertSidToStringSidA';
function ConvertStringSidToSid(StringSid: PChar; var Sid: PSID): Boolean; stdcall; external 'advapi32.dll' name
'ConvertStringSidToSidA';

//  Converts a SID to its string representation
function SidToString(ASID: PSID): string;
var
  sDummy            : LPTSTR;
begin
  ConvertSidToStringSid(ASID, sDummy);
  Result := string(sDummy);
end;

//  Obtains the name for a String-SID
function StrSIDToName(const StrSID: string; var Name: string; var SIDType: DWORD): Boolean;
var
  SID               : PSID;
  Buffer            : PChar;
  NameLen, TempLen  : Cardinal;
  err               : Boolean;
begin
  SID := nil;
  err := ConvertStringSIDToSID(PChar(StrSID), SID);
  if err then
  begin
    NameLen := 0;
    TempLen := 0;
    LookupAccountSidW(nil, SID, nil, NameLen, nil, TempLen, SIDType);
    GetMem(Buffer, NameLen);
    try
      err := LookupAccountSidA(nil, SID, Buffer, NameLen, nil, TempLen, SIDType);
      if err then
        SetString(Name, Buffer, Namelen);
    finally
      FreeMem(Buffer);
    end;
  end;
  if Assigned(SID) then
    LocalFree(Cardinal(SID));
  result := err;
end;

// Obtains the process owner
function GetProcessOwner(PID: DWord): string;
var
  hProcess          : THandle;
  ppsidOwner        : PSID;
  SecDescriptor     : PSECURITY_DESCRIPTOR;
  nResult           : DWord;
  s                 : string;
  SIDType           : DWORD;

const
  SE_UNKNOWN_OBJECT_TYPE: DWord = 0;
  SE_FILE_OBJECT    : DWord = 1;
  SE_SERVICE        : DWord = 2;
  SE_PRINTER        : DWord = 3;
  SE_REGISTRY_KEY   : DWord = 4;
  SE_LMSHARE        : DWord = 5;
  SE_KERNEL_OBJECT  : DWord = 6;
  SE_WINDOW_OBJECT  : DWord = 7;

begin
  Result := '';
  try
    hProcess := OpenProcess(PROCESS_QUERY_INFORMATION or GENERIC_READ, False, pid);
    if (hProcess <> 0) then
    begin
      nResult := GetSecurityInfo(hProcess, SE_KERNEL_OBJECT, OWNER_SECURITY_INFORMATION, @ppsidOwner, nil, nil, nil,
        @SecDescriptor);
      if (nResult = 0) then
      begin
        s := SidToString(ppsidOwner);
        StrSIDToName(s, result, SIDType);
        LocalFree(Cardinal(SecDescriptor));
      end;
      CloseHandle(hProcess);
    end;
  except
  end;
end;

var
  ProcOwner: String;

begin
  ProcOwner:= GetProcessOwner(GetCurrentProcessId);
  Writeln(ParamStr(0) + ': ' +ProcOwner);
  Readln;
end.

Ist zwar Delphi, aber das Prinzip und die API-Funktionen sind natürlich die selben.

Hat es denn geholfen?

jep danke! hab mir zwar dann eine übersetzung für c++ gesucht, aber war im großen und ganzen dasselbe. danke an alle