File Owner mittels GetNamedSecurityInfo - Hilfe!

[FragKing]

Hi Leute!

Ich bin ziemlich "frisch" mit Delphi am herumtüfteln und werkeln. Es funktioniert soweit ganz gut, ist wirklich einfach das zeugs...
Nur habe ich jetzt etwas was weder mit Delphi selber noch mit dem .net Framework implementiert ist (Im .net v2.0 wirds dann drin sein hab ich gelesen ;)

Und zwar geht es darum den Owner eines files herauszufinden, und zwar benötige ich eigentlich nur die SID, Domain&Account wären dann noch zusatz-gimmicks.
Das ganze mache ich laut Platform SDK mittels des Win32 API calls "GetNamedSecurityInfo" (MSDN).

Ich habe bereits zahlreiche newsgroups / foren durchkämmt, habe aber entweder nur Delphi für Win32 solutions gefunden (mit GetMem FreeMem calls etc -> nicht .net kompatibel) oder dann nur für andere Sprachen (z.b. hier). Ich habe das ganze mal soweit zusammengestiefelt dass ich (zumindest dachte) es sollte funktionieren, tut es aber nicht :coder2:

Für ein funktionierendes Beispiel wäre ich sehr dankbar, und mit einigen erläuterungen verstehe ich das nachher hoffentlich auch noch ;)

Danke schonmal im voraus!

Hier der Code:

Delphi-Quellcode:

unit Unit1;

{$UNSAFECODE ON}
interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, System.Text;

  type
  SE_OBJECT_TYPE = (
    SE_UNKNOWN_OBJECT_TYPE,
    SE_FILE_OBJECT,
    SE_SERVICE,
    SE_PRINTER,
    SE_REGISTRY_KEY,
    SE_LMSHARE,
    SE_KERNEL_OBJECT,
    SE_WINDOW_OBJECT,
    SE_DS_OBJECT,
    SE_DS_OBJECT_ALL,
    SE_PROVIDER_DEFINED_OBJECT,
    SE_WMIGUID_OBJECT
  );

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);

  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

function GetNamedSecurityInfo(var pObjectName: String; const ObjectType: SE_OBJECT_TYPE; const SecurityInfo: SECURITY_INFORMATION; ppsidOwner: PSID; ppsidGroup: IntPtr; ppDacl: IntPtr; ppSacl: IntPtr; ppSecurityDescriptor: PSecurity_Descriptor): Integer; cdecl; unsafe;

var
  Form1: TForm1;

implementation

const advapi32 = 'advapi32.dll';

function GetNamedSecurityInfo(var pObjectName: String; const ObjectType: SE_OBJECT_TYPE; const SecurityInfo: SECURITY_INFORMATION; ppsidOwner: PSID; ppsidGroup: IntPtr; ppDacl: IntPtr; ppSacl: IntPtr; ppSecurityDescriptor: PSecurity_Descriptor): Integer; cdecl; unsafe;
external advapi32 name 'GetNamedSecurityInfo';

{$R *.nfm}

procedure TForm1.FormCreate(Sender: TObject); unsafe;
var ssid: PSID;
    user, domainname: string;
    acctype: IntPtr;
    blah: DWORD;
    dir: String;
    dirchar: Char;
    stringsid: String;
    error: Integer;

    sspointer: PSecurity_Descriptor;
begin
dir := ('c:\Test.txt');
error := GetNamedSecurityInfo(dir, SE_FILE_OBJECT, OWNER_SECURITY_INFORMATION, ssid, nil, nil, nil, sspointer);

if error <> 0 then
ShowMessage(SysErrorMessage(error));
ShowMessage(SysErrorMessage(System.Runtime.InteropServices.Marshal.GetLastWin32Error));

ShowMessage(ssid.ToString);

end;

end.

[Olli]

Autsch, woher hast du denn den obigen Prototypen?

Code:

function GetNamedSecurityInfoA( [color=red]pObjectName: PWideChar[/color]; ObjectType: SE_OBJECT_TYPE; SecurityInfo: SECURITY_INFORMATION;  [color=red]var[/color] ppsidOwner: PSID;  [color=red]var[/color] ppsidGroup: PSID;  [color=red]var[/color] ppDacl: PACL;  [color=red]var[/color] ppSacl: PACL;  [color=red]var[/color] ppSecurityDescriptor: PSecurity_Descriptor): DWORD; [color=red]stdcall;[/color] external 'Advapi32.dll';

function GetNamedSecurityInfoW(pObjectName: PWideChar; ObjectType: SE_OBJECT_TYPE; SecurityInfo: SECURITY_INFORMATION; var ppsidOwner: PSID; var ppsidGroup: PSID; var ppDacl: PACL; var ppSacl: PACL; var ppSecurityDescriptor: PSecurity_Descriptor): DWORD; stdcall; external 'Advapi32.dll';

Wenn PACL bei dir nicht definiert ist, benutzt du einfach Pointer oder einen untypisierten Pointertypen - keine Ahnung was das bei Delphi.NET ist.

[Luckie]

Du hast den Beitrag mit .NET gekennzeichnet, bist du sicher dass das richtig war? Das was du da gepsotet hast, sieht mir mehr nach einem herkömlichen Win32 Delphi Programm aus.

[Olli]

Zitat:

Zitat von Luckie

Du hast den Beitrag mit .NET gekennzeichnet, bist du sicher dass das richtig war? Das was du da gepsotet hast, sieht mir mehr nach einem herkömlichen Win32 Delphi Programm aus.

Ich denke das war schon korrekt. Er will mit Delphi.NET auf Win32-APIs zugreifen:

Delphi-Quellcode:

ShowMessage(SysErrorMessage(error)); 
ShowMessage(SysErrorMessage(System.Runtime.InteropServices.Marshal.GetLastWin32Error));

Und dann die vielen Stellen mit "unsafe". Also das kenne ich vom traditionellen Delphi her nicht.

[FragKing]

Nein, es ist schon korrekt dass es Delphi.NET ist.
Ich möchte wie Olli sagt von Delphi.NET her auf Win32-API's zugreiffen.

Der Prototyp ist von mir. Habe viel hin und her geübt mit dem ding ;)
Ich probiere deinen Vorschlag so schnell wie möglich, danke! Werd mich melden ob's geklappt hat.

Grüsse
Michel

[Olli]

Zitat:

Zitat von FragKing

Der Prototyp ist von mir. Habe viel hin und her geübt mit dem ding ;)
Ich probiere deinen Vorschlag so schnell wie möglich, danke! Werd mich melden ob's geklappt hat.

Na dann noch ein paar Hinweise. Guck mal hier.

Wenn man einen Pointer auf eine Struktur hat (PStruktur = ^TStruktur) kann man C

Code:

void bla(PStruktur x);

nach Delphi

Code:

procedure bla(var x:TStruktur);

oder

Code:

procedure bla(x:PStruktur);

übersetzen. Entsprechend ergibt sich für den Pointer auf den Pointer auf eine Struktur (Dopplung beachten) von C

Code:

void bla(PStruktur *x);

in Delphi

Code:

procedure bla(var x:PStruktur);

oder, wenn PPStruktur = ^PStruktur, dann

Code:

procedure bla(x:PPStruktur);

.

Hoffe du siehst dabei durch. Obige Vorkommen von var können auch durch const oder out ersetzt werden, wenn dies Sinn macht. Es ist nur wichtig zu verstehen, daß bei var, const und out unter Delphi die Übergabe "by reference" (also als Pointer auf übergebenen Typ) geschieht. Hingegen in den Win32-C/C++-Headern ist OUT nur ein "leeres" Makro, welches als Anhaltspunkt für den Programmierer dient.

Ach ja: alle WINAPIs sind in stdcall. Alle klingt etwas übertrieben (ist es auch), aber bis auf wenige dokumentierte Ausnahmen (meist C-Lib oder ähnliche Funktionen), sind alle stdcall, nicht cdecl!

[Robert_G]

Kennst du den Reflector? Sau geiles Teil.
Du nimmst deinen C#/Delphi.Net/Chrome/Eifel/whatsoever - Samplecode und kompostierst ihn auch in dem Compiler.
Die entstandene Assembly jagst du durch den Reflector und wählst deine Sprache ala Darstellung aus.
*Fump* Schon findest du den Cod ein deiner Sprache... :shock:

Der Beispielcode bei P/Invoke ist übrigens falsch, da ihre Version von xxx mit einem anderen Typen für den pSid-Parameter arbeitet. Dieses hier geht. ;)

Ich habe es einfach in eine neue C#-ClassLib kopiert, ein wenig rum-ReSharpert (damit man es auch lesen kann :? ) und kompiliert.

Code:

using System;
using System.Runtime.InteropServices;
using System.Text;

namespace FileOwnerDings
{
    public class SecurityDescriptor
    {
        [DllImport("advapi32.dll", SetLastError=true)]
        static extern int GetNamedSecurityInfo(string pObjectName,
                                               SeObjectType ObjectType,
                                               SecurityInformation SecurityInfo,
                                               out IntPtr ppsidOwner,
                                               out IntPtr ppsidGroup,
                                               out IntPtr ppDacl,
                                               out IntPtr ppSacl,
                                               out IntPtr ppSecurityDescriptor);

        [DllImport("advapi32.dll", CharSet=CharSet.Auto, SetLastError=true)]
        static extern int LookupAccountSid(string systemName,
                                           IntPtr psid,
                                           StringBuilder accountName,
                                           ref int cbAccount,
                                           [Out] StringBuilder domainName,
                                           ref int cbDomainName,
                                           out int use);

        public static string GetFileObjectOwner(string objectName)
        {
            IntPtr pZero = IntPtr.Zero;
            IntPtr pSid = pZero;
            IntPtr psd = pZero; // Not used here
            int errorReturn = GetNamedSecurityInfo(objectName,
                                                   SeObjectType.FileObject,
                                                   SecurityInformation.Owner,
                                                   out pSid,
                                                   out pZero,
                                                   out pZero,
                                                   out pZero,
                                                   out psd);
            if (errorReturn != 0)
            {
                throw new Exception(string.Format("GetNamedSecurityInfo has exited with code {0}. (last error is {0})",
                                                  errorReturn,
                                                  Marshal.GetLastWin32Error()));
            }
            int bufferSize = 64;
            StringBuilder buffer = new StringBuilder();
            int accounLength = bufferSize;
            int domainLength = bufferSize;
            int sidNameUse = 0;
            StringBuilder account = new StringBuilder(bufferSize);
            StringBuilder domain = new StringBuilder(bufferSize);
            errorReturn = LookupAccountSid(null,
                                           pSid,
                                           account,
                                           ref accounLength,
                                           domain,
                                           ref domainLength,
                                           out sidNameUse);
            if (errorReturn == 0)
            {
                throw new Exception(string.Format("LookupAccountSid has exited with code 0. (last error is {0})",
                                                  Marshal.GetLastWin32Error()));
            }
            buffer.Append(domain);
            buffer.Append(@"\");
            buffer.Append(account);
            return buffer.ToString();
        }
    }
}

Die Enums:

Code:

    [Flags]
    public enum SecurityInformation
    {
        Owner = 1,
        Group = 2,
        DACL  = 4,
        SACL  = 8
    }

Code:

   public enum SeObjectType
    {
        UnknownObjectType = 0,
        FileObject,
        Service,
        Printer,
        RegistryKey,
        LMShare,
        KernelObject,
        WindowObject,
        DsObject,
        DsObjectAll,
        ProviderDefinedObject,
        WMIGUIDObject,
        RegistryWOW64Key
    }

Mangels eines Delphi.Net Komposters nahm ich das Chrome PlugIn für den Reflector und ieß mir Chrome Code erzeugen. (Ist ja sehr ähnlich zu Delphi.Net)
Nachdem ich die lokalen Variablen umbenannt habe (DIe werden von der IL nicht wirklich benannt ;) ) und auch hier einen Formatter drüberrennen ließ, sah es so aus:

Delphi-Quellcode:

namespace FileOwnerDings;

interface
uses 
   System,
   System.Runtime.InteropServices,
   System.Text;

type
  SecurityDescriptor = public class
  private
    [DllImport('advapi32.dll', SetLastError := True)]
    class method GetNamedSecurityInfo(pObjectName: string;
                                      ObjectType: SeObjectType;
                                      SecurityInfo: SecurityInformation;
                                      out ppsidOwner,
                                          ppsidGroup,
                                          ppDacl,
                                          ppSacl,
                                          ppSecurityDescriptor: IntPtr): Integer; external;
    [DllImport('advapi32.dll', CharSet := CharSet.Auto, SetLastError := True)]
    class method LookupAccountSid(systemName: string;
                                   psid: IntPtr;
                                   accountName: StringBuilder;
                                   var cbAccount: Integer;
                                   [&Out] domainName: StringBuilder;
                                   var cbDomainName: Integer;
                                   out use: Integer): Integer; external;
  public
    class method GetFileObjectOwner(objectName: string): string;
  end;


implementation

class method SecurityDescriptor.GetFileObjectOwner(objectName: string): string;
var
  pZero, pSid, psd : IntPtr;
  errorReturn      : Integer;
  bufferSize       : Integer;
  accountLength    : Integer;
  domainLength     : Integer;
  sidNameUse       : Integer;
  buffer           : StringBuilder;
  account          : StringBuilder;
  domain           : StringBuilder;
begin
  pZero := IntPtr.Zero;
  pSid := IntPtr.Zero;
  psd := pZero;
  errorReturn := SecurityDescriptor.GetNamedSecurityInfo(objectName,
                                                         SeObjectType.FileObject,
                                                         SecurityInformation.Owner,
                                                         pSid,
                                                         pZero,
                                                         pZero,
                                                         pZero,
                                                         psd);
  if (errorReturn <> 0) then
    raise new Exception(string.Format('GetNamedSecurityInfo excited with code {0}. (last error is {0})',
                                      errorReturn,
                                      Marshal.GetLastWin32Error));

  bufferSize    := 64;
  accountLength := bufferSize;
  domainLength  := bufferSize;
  sidNameUse    := 0;
  
  buffer  := new StringBuilder;
  account := new StringBuilder(bufferSize);
  domain  := new StringBuilder(bufferSize);
  
  errorReturn := SecurityDescriptor.LookupAccountSid(nil,
                                                     pSid,
                                                     account,
                                                     accountLength,
                                                     domain,
                                                     domainLength,
                                                     sidNameUse);
  if (errorReturn = 0) then
    raise new Exception(string.Format('LookupAccountSid excited with code 0. (last error is {0})',
                                      Marshal.GetLastWin32Error));

  buffer.Append(domain);
  buffer.Append('\');
  buffer.Append(account);
  Result := buffer.ToString;
end;

end.

Ab hier sollte eine Konvertierung zu D.Net easy sein. ;)

Der zeitaufwendigste Part an allem war das Schreiben dieses Beitrages. :mrgreen: Also -> Schau dir den Reflector mal an.
Es macht auch Spass die Microsoft Assemblies damit auseinanderzunehmen. ;)

[Olli]

Zitat:

Zitat von Robert_G

Delphi-Quellcode:

    [DllImport('advapi32.dll', SetLastError := True)]
    class method GetNamedSecurityInfo(pObjectName: string;
                                      ObjectType: SeObjectType;
                                      SecurityInfo: SecurityInformation;
                                      out ppsidOwner,
                                          ppsidGroup,
                                          ppDacl,
                                          ppSacl,
                                          ppSecurityDescriptor: IntPtr): Integer; external;

Ich verspüre den Drang zu ulfen :kotz:

Sorry, @FragKing, ich konnte nicht wissen, daß auch eine solche Verballhornung von ObjectPascal existiert. Aber zumindest das out (siehe var, const, out) hat sich erhalten. Nur string für den ersten Parameter befremdet mich leicht. Aber wird schon richtig sein, ist schließlich die .NETte Version.

[FragKing]

Das String, so habe ich gelesen, wird vom compiller selber in ein brauchbares format umgewandelt

Ich probiere das ganze mal, danke vielmals! Und das mit diesem Reflector klingt wirklich hervorragend!
Danke euch allen für die Hilfe! So sollts doch sicher klappen =)

Melde mich wieder!

Gruss
Michel

[Robert_G]

Zitat:

Zitat von Olli

Sorry, @FragKing, ich konnte nicht wissen, daß auch eine solche Verballhornung von ObjectPascal existiert. Aber zumindest das out (siehe var, const, out) hat sich erhalten. Nur string für den ersten Parameter befremdet mich leicht.

Hmpf? :shock:
Was ist an der Zeile anders als in Delphi.Net? :gruebel: (Mal abgesehen davon, dass es in Chrome method statt function/procedure heißt)...

Zitat:

Zitat von Olli

Aber wird schon richtig sein, ist schließlich die .NETte Version.

Das wird vom Marshaler übersetzt. ;)

[Olli]

Zitat:

Zitat von Robert_G

Hmpf? :shock:
Was ist an der Zeile anders als in Delphi.Net? :gruebel: (Mal abgesehen davon, dass es in Chrome method statt function/procedure heißt)...

Nene, immer ruhig bleiben! Ich meinte, daß mir diese Syntax unbekannt war. Deshalb habe ich mich beim FragKing entschuldigt, daß ich eine falsche Auskunft erteilt habe. Wer würde denn die Aussage eines Robert_G infrage stellen? :zwinker:

[FragKing]

So, danke für eure mühe Leute :)

Leider ist programmieren glaube ich nix für mich, hab's immernoch nicht so geschafft wie ich das gerne hätte :(
Muss mir glaube ich noch ein bisschen Literatur durch den Kopf gehen lassen. :(

Es ist noch kein Meister vom Himmel gefallen! (leider) :wall: :wall:

Vielleicht mit ein paar Bier nochmals probieren ;)

Gruss

[Robert_G]

Na na na...
Nicht gleich aufgeben. ;)
Wie weit bist du denn? Bzw. wo drückt der Schuh? Es könnte vielleicht auch helfen wenn du die Fähigkeit von D2005 nutzt, mehrere Sprachen in eine IDE zu vereinen.
Du könntest eine Projektgruppe anlegen, die eine C# ClassLib und eine in D.Net enthält. Vielleicht noch eine weitere Mini-Konsolen App um die Funktion zu testen.
Auf die Art kannst du prima erst durch die funktionnierende (siehe mein C# Code oben :zwinker: ) C# Lib debuggen. Jetzt passt du deine Delphi.Net Klasse solange an, bis sie genau das gleiche macht.
Nun brauchst du nur die Referenz auf die C# Lib gegen die D.Net Lib austauschen und färtsch. :)

Die Fast food Lösung wäre wohl duie C# Lib durch den Reflector zu scheuchen und den Code als D.Net rauszukopieren. :mrgreen: (aber das ist ja langweilig ;) )

Edit: da hatte ich doch glatt "Ich gleich aufgeben" getippt. :lol:

[FragKing]

So, man sollte sich immer genug Zeit lassen mit solchen experimenten, den code eine Woche lang nicht anschauen, dann in die Badewanne hüpfen und das ganze innerhalb von 5 Minuten lösen.
:cheers:

Hier noch mein Code, falls es jemanden interessiert:
(hab ihn nicht bereinigt, hat also noch den einen oder anderen schrott drin *g*)

Danke nochmals für die Hilfe!!

Delphi-Quellcode:

unit Unit1;

{$UNSAFECODE ON}
interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, System.Text, System.Runtime.InteropServices;

  type
  SE_OBJECT_TYPE = (
    SE_UNKNOWN_OBJECT_TYPE,
    SE_FILE_OBJECT,
    SE_SERVICE,
    SE_PRINTER,
    SE_REGISTRY_KEY,
    SE_LMSHARE,
    SE_KERNEL_OBJECT,
    SE_WINDOW_OBJECT,
    SE_DS_OBJECT,
    SE_DS_OBJECT_ALL,
    SE_PROVIDER_DEFINED_OBJECT,
    SE_WMIGUID_OBJECT
  );

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);

  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

function GetNamedSecurityInfoW(pObjectName: String; ObjectType: SE_OBJECT_TYPE; SecurityInfo: SECURITY_INFORMATION; var ppsidOwner: PSID; var ppsidGroup: PSID; var ppDacl: IntPtr; ppSacl: IntPtr; ppSecurityDescriptor: PSecurity_Descriptor): DWord; stdcall;
function ConvertSidToStringSidW(Sid: PSID; var StringSid: String): Bool; stdcall;
function LookupAccountSid(systemName: string; psid: IntPtr; Out accountName: StringBuilder; var cbAccount: Integer; Out domainName: StringBuilder; var cbDomainName: Integer; out use: Integer): Integer; stdcall;

var
  Form1: TForm1;

implementation

const advapi32 = 'advapi32.dll';

function GetNamedSecurityInfoW(pObjectName: String; ObjectType: SE_OBJECT_TYPE; SecurityInfo: SECURITY_INFORMATION; var ppsidOwner: PSID; var ppsidGroup: PSID; var ppDacl: IntPtr; ppSacl: IntPtr; ppSecurityDescriptor: PSecurity_Descriptor): DWord; stdcall;
external advapi32 name 'GetNamedSecurityInfo';

function ConvertSidToStringSidW(Sid: PSID; var StringSid: String): Bool; stdcall;
external advapi32 name 'ConvertSidToStringSid';

function LookupAccountSid(systemName: string; psid: PSID; Out accountName: StringBuilder; var cbAccount: Integer; Out domainName: StringBuilder; var cbDomainName: Integer; out use: Integer): Integer; stdcall;
external advapi32 name 'LookupAccountSid';

{$R *.nfm}

procedure TForm1.FormCreate(Sender: TObject); unsafe;
var ssid: PSID;
    dir, mystringsid: string;
    dirchar: Char;
    charsid: PWideChar;
    sspointer: PSecurity_Descriptor;
    pZero, pSid, psd, nulll : IntPtr;
    accountLength, domainLength, sidNameUse, bufferSize, errorReturn, error, sbuffer: Integer;
    buffer, account, domain, stringsid: StringBuilder;

begin
dir := ('c:\test.txt');
nulll := nil;

error := GetNamedSecurityInfoW(dir, SE_FILE_OBJECT, OWNER_SECURITY_INFORMATION, ssid, nulll, nulll, nulll, sspointer);

if error <> 0 then
begin
  ShowMessage('ERROR');
  ShowMessage(SysErrorMessage(error));
  ShowMessage(SysErrorMessage(System.Runtime.InteropServices.Marshal.GetLastWin32Error));
end;
//ShowMessage(ssid.ToString);

//sbuffer := 128;
//stringsid := StringBuilder.Create(sbuffer);

if ConvertSidToStringSidW(ssid, mystringsid) = false then
ShowMessage('Error: ' + SysErrorMessage(error));

//stringsid.Capacity := stringsid.length;
ShowMessage(SysErrorMessage(error));
ShowMessage(SysErrorMessage(System.Runtime.InteropServices.Marshal.GetLastWin32Error));
//ShowMessage(stringsid.ToString);
ShowMessage(mystringsid);

(*
  bufferSize    := 64;
  accountLength := bufferSize;
  domainLength  := bufferSize;
  sidNameUse    := 0;

  buffer  := StringBuilder.Create(bufferSize);
  account := StringBuilder.Create(bufferSize);
  domain  := StringBuilder.Create(bufferSize);
    try
  errorReturn := LookupAccountSid(nil, ssid ,account, accountLength, domain, domainLength, sidNameUse);
  except
  on ex: Exception do
  ShowMessage(ex.Message);
  end;
  if (errorReturn = 0) then
  begin
  ShowMessage(SysErrorMessage(errorReturn));
  ShowMessage(SysErrorMessage(System.Runtime.InteropServices.Marshal.GetLastWin32Error));

//  buffer.Append(domain);
//  buffer.Append('\');
//  buffer.Append(account);
  ShowMessage(domain.ToString);
  ShowMessage(account.ToString);
  ShowMessage(buffer.ToString);
  end;

  ShowMessage('failure');
  *)

end;

end.