LDAP SID ermitteln

[cst_07]

Hallo,

ich habe folgendes Problem. Ich möchte die SID, beispielsweise eines Benutzers, via LDAP auslesen.

Die LDAP Abfrage wird via ADO durchgeführt mit folgendem Statement:
SELECT objectSid, distinguishedName, displayname FROM 'LDAP://SERVERNAME'

Die Werte werden mittels "FieldByName" ausgelesen.

Die "objectSid" wollte ich so "ADOQuery1.FieldByName('objectSid').AsVariant
" auslesen. Leider ist der Rückgabewert laut ADO "VarBytes",... wie kann ich aus diesem die SID herausbekommen? :wall:

Es gibt eine Funktion "ConvertSidToStringSid" leider benötigt diese aber einen Pointer,...

Über jede Info würde ich mich sehr freuen!

[nahpets]

Hallo,

schau mal hier: http://www.delphipraxis.net/internal...t.php?p=471470, da hat Luckie schonmal was zu geschrieben, eventuell hilft es Dir weiter.

Eventuell ist auch dasda was: http://www.delphipraxis.net/internal...=708116#708116

Ansonsten mal Google bemühen mit +ConvertSidToStringSid +delphi +source

[cst_07]

Hallo,

vielen dank für die schnelle Antwort. Die Funktion von Luckie habe ich mir schon angeschaut, nur benötigt diese als Parameter einen Pointer.

Wie bekomme ich via LDAP-Abfrage einen brauchbaren Pointer?

Der Rückgabewert ist laut ADO "VarBytes". Gibts irgendeine Routine um daraus einen Pointer zu bekommen?

[nahpets]

Hallo,

ich kann Dir Deine Frage nicht beantworten. :(

Versuche doch mal sowas:

Delphi-Quellcode:

var
  Sid : Windows.PSID;
begin
... Dein bisheriger Code
  Sid := ADOQuery1.FieldByName('objectSid').AsVariant; 
...

Und das übergibst Du dann an diese http://www.delphipraxis.net/internal...=708762#708762 Funktion.

[cst_07]

Hi,

danke für die Info. Leider kann ich den Typ "AsVariant" nicht in einen Pointer umwandeln :wall:

[nahpets]

Hallo,

schau mal, ob Dir das hilft:

Delphi-Quellcode:

Var
          i      : integer;
          sField : String;
          sSid   : String;
begin
  sField := ADOQuery1.FieldByName('objectSid').AsString;
  for i := 1 to length(sField) do sSid := sSid + IntToHex(Ord(Copy(sField,i,1)[1]),2) + ' ';
  showmessage(sSid);
end;

[cst_07]

Hi,

vielen vielen Dank für die guten Ratschläge. Leider haut das noch nicht so ganz hin. Ich habe aber eine Funktion bei msdn gefunden, die das macht was ich brächte :-D . Leider ist diese jedoch in c++ geschrieben. Kann das vielleicht jemand in delphi konvertieren?

Hier der Code

Code:

HRESULT VariantArrayToBytes(VARIANT Variant, 
                            LPBYTE *ppBytes, 
                            DWORD *pdwBytes);

/********************************************************************

    GetLDAPSidBindStringFromVariantSID()

    Converts a SID in VARIANT form, such as an objectSid value,  
    and converts it into a bindale string in the form:

    LDAP://<SID=xxxxxxx...>

    The returned string is allocated with AllocADsMem and must  
    be freed by the caller with FreADsMem.

*******************************************************************/

LPWSTR GetLDAPSidBindStringFromVariantSID(VARIANT vSID)
{
    LPWSTR pwszReturn = NULL;

    if(vSID.vt != VT_EMPTY) 
    {
        HRESULT hr;
        LPBYTE pByte;
        DWORD dwBytes = 0;

        hr = VariantArrayToBytes(vSID, &pByte, &dwBytes);
        if(S_OK == hr)
        {
            // Convert the BYTE array into a string of 
            // hex characters.
            CComBSTR sbstrTemp = "LDAP://<SID=";

            for(DWORD i = 0; i < dwBytes; i++)
            {
                WCHAR wszByte[3];

                swprintf_s(wszByte, L"%02x", pByte[i]);
                sbstrTemp += wszByte;
            }

            sbstrTemp += ">";
            pwszReturn = 
              (LPWSTR)AllocADsMem((sbstrTemp.Length() + 1) * 
                                   sizeof(WCHAR));
            if(pwszReturn)
            {
                wcscpy_s(pwszReturn, sbstrTemp.m_str);
            }

            FreeADsMem(pByte);
        }
    }

    return pwszReturn;
}

/******************************************************************

    VariantArrayToBytes()

    This function converts a VARIANT array into an array of BYTES.  
    This function allocates the buffer using AllocADsMem. The caller 
    must free this memory with FreeADsMem when it is no longer 
    required.

******************************************************************/

HRESULT VariantArrayToBytes(VARIANT Variant, 
                            LPBYTE *ppBytes,  
                            DWORD *pdwBytes)
{
    if(!(Variant.vt & VT_ARRAY) ||
        !Variant.parray ||
        !ppBytes ||
        !pdwBytes)
    {
        return E_INVALIDARG;
    }

    *ppBytes = NULL;
    *pdwBytes = 0;

    HRESULT hr = E_FAIL;
    SAFEARRAY *pArrayVal = NULL;
    CHAR HUGEP *pArray = NULL;
    
    // Retrieve the safe array.
    pArrayVal = Variant.parray;
    DWORD dwBytes = pArrayVal->rgsabound[0].cElements;
    *ppBytes = (LPBYTE)AllocADsMem(dwBytes);
    if(NULL == *ppBytes) 
    {
        return E_OUTOFMEMORY;
    }

    hr = SafeArrayAccessData(pArrayVal, (void HUGEP * FAR *) &pArray);
    if(SUCCEEDED(hr))
    {
        // Copy the bytes to the safe array.
        CopyMemory(*ppBytes, pArray, dwBytes);
        SafeArrayUnaccessData( pArrayVal );
        *pdwBytes = dwBytes;
    }
    
    return hr;
}

Hier gibts nochmal eine Beschreibung zu dem Artikel bei msdn
http://msdn.microsoft.com/en-us/library/ms676319(VS.85).aspx

[nahpets]

Hallo,

in welcher Form willst Du denn jetzt die SID haben?
Ob Du den String jetzt nun zeichenweise mit IntToHex(Ord(Copy(sField,i,1)[1]),2) verarbeitest oder in ein ByteArray steckst, sollte an der von mir geposteten Routine keine allzu großen Änderungen erfordern.
Das Ergebnis der Routine stimmt zumindest mit den per LDAP-Browser ausgelesenen SID überein. Die Darstellungsform dürfte hier ja dann eigentlich eher als Chromleiste zu betrachten sein.

Wenn ich die Routine aus der MSDN halbweg richtig verstehe, macht die auch nichts anderes, als zeichenweise die SID in ein Char zu packen und die Chars dann an einen String zu hängen.

[cst_07]

Ich brauche einfach nur die Sid als String. Genau wie du schon sagtest, vielen Dank für die schnelle Rückmeldung!

[cst_07]

Sorry, ich bekomme es irgendwie nicht gebacken. Bei der Sid kommt irgendwie nichts g'scheids heraus...

Codeschnipsel ;)

Code:

Var 
          i      : integer; 
          sField : String; 
          sSid   : String; 
begin 
  sField := ADOQuery1.FieldByName('objectSid').AsString; 
  for i := 1 to length(sField) do sSid := sSid + IntToHex(Ord(Copy(sField,i,1)[1]),2) + ' '; 
  showmessage(sSid); 
end;

Zum Umwandeln der HexWerte in Strings habe ich folgende Funktion verwendet:

Code:

Function HexToStr(s: String): String;
Var i: Integer;
Begin
  Result:=''; i:=1;
  While i<Length(s) Do Begin
    Result:=Result+Chr(StrToIntDef('$'+Copy(s,i,2),0));
    Inc(i,2);
  End;
End;

Mit deinem Beispiel bekomme ich irgendwelche HexWertke heraus, welche aber leider keinen lesbaren String ergeben, sondern irgendwelche Sonderzeichen. Ich vermute, dass der Rückgabeparameter "AsString" nicht funktioniert :wall:

Wie bekomme ich den Wert der ObjectSid in ein ByteArray und dieses dann in ein String umgewandelt?

[nahpets]

Hallo,

Du musst den Inhalt von ADOQuery1.FieldByName('objectSid').AsString byteweise lesen und nicht jeweils zwei Byte.
Der String ist 28 Zeichen lang. Die Art, wie ich es gelesen habe führt zum gleichen Ergebnis, das ich auch erhalte, wenn ich mir die ObjectSid per LDAP-Browser ausgeben lasse.
Bei Deiner Methode gehst Du her und nimmst jeweils zwei Byte um daraus eine "Hexwert" zu machen, dies ist in dem Zusammenhang nicht zielführend. Wenn Du die SID als Hexwert haben möchtest, musst Du jedes Byte in einen Hexadezimalwert umwandeln.

Also, was musst Du machen?

Code:

Die Sid zeichenweise lesen: Copy(sField,i,1)[1]
von jedem Zeichen benötigst Du den Ordinalwert: Ord(Copy(sField,i,1)[1])
Den Ordinalwert wandelst Du mit IntToHex(Ord(Copy(sField,i,1)[1]),2) in einen zwei Zeichen langen Hexadezimalwert um.

Eventuell wird es im folgenden Quelltext ja etwas deutlicher:

Delphi-Quellcode:

Var
          i      : integer;
          b      : Byte;
          ch     : Char;
          sField : String;
          sHex   : String;
          sSid   : String;
begin
  sField := ADOQuery1.FieldByName('objectSid').AsString; 
  sSid := '';
  for i := 1 to Length(sField) do begin
    ch := Copy(sField,i,1)[1];
    // ch := sField[i]; // <-- wäre auch eine Möglichkeit.
    b := Ord(ch);
    sHex := IntToHex(b,2);
    sSid := sSid + sHex + ' ';
    // sSid := sSid + '$' + sHex; // <-- wenn's denn mit $ vorneweg sein soll.
  end;
  showmessage(sSid);
end;

[cst_07]

Hi,

also ich habe deinen Code jetzt so eingebaut...

Code:

      sField := ADOQuery1.FieldByName('objectSid').AsString;
      sSid := '';
      sSID2 := '';
      for i := 1 to Length(sField) do begin
        ch := Copy(sField,i,1)[1];
        sSID2 := sSID2 + ch;
        // ch := sField[i]; // <-- wäre auch eine Möglichkeit.
        b := Ord(ch);
        sHex := IntToHex(b,2);
        sSid := sSid + sHex + ' ';
        // sSid := sSid + '$' + sHex; // <-- wenn's denn mit $ vorneweg sein soll.
      end;
      // showmessage(sSid);
      Memo1.Lines.Add('FName: ' + lsi.FName + #13#10+
                      'SID:   ' + sSID + #13#10+
                      'SID2:  ' + sSID2 + #13#10);

Irgendwas mache ich noch falsch,... bei mir kommt anstelle der SID immernoch irgendwelche Zeichen. Ich habe dir einen Screen angefügt, damit du siehst was ich meine.

[nahpets]

Hallo,

wenn ich das richtig sehe, ist das, was hinter Sid in Deinem LDAP-Browser steht, die korrekte ObjectSID.
Das, was Du mit SID2 machst, geht nicht. Hex 00, Hex 01 ... sind zwar auch in einem String gültige Werte, diese können aber nicht angezeigt werden, da es sich um nicht darstellbare Zeichen handelt.
Obwohl Du die SID als String bekommst, kannst Du nicht davon ausgehen, dass Du die Werte als Zeichenfolge ausgeben kannst. Du musst sie Dir umwandeln, was Du ja bereits mit dem IntToHex machst.

Schau bitte mal in diese Ascii-Tabelle. Erst die Werte ab Hex 20 (Leerzeichen) kannst Du in einem String problemlos darstellen, die Werte darunter nicht. Die SID enthält aber Asciiwerte aus dem Bereich von 0 bis 255.

Auch wenn wir hier auf die ObjectSID zugreifen, als wäre sie ein String, solltest Du Dir sie lieber als einen 28 Byte langen Binärwert vorstellen.

[cst_07]

Danke für die schnelle Antwort :)

Ich habe das überprüft, komme aber auch beim Vergleich nicht auf die orginal SID, wie im folgenden Beispiel.

SID des Benutzers Jens Maler:

S-1-5-21-2730868873-810845422-3379721866-1146

Der ermittelter HEX-Wert lautet:
01 05 00 00 00 00 00 05 15 00 00 00 89 C0 C5 A2 EE 84 54 30 8A 76 72 C9 7A 04 00 00


Wie komme ich vom HEX-Wert auf die SID oben?
HEX ASCII
01 = 1 -> OK
05 = 5 -> OK
00 = falsch
00 = falsch
00 = falsch
00 = falsch
00 = falsch
05 = 5 -> falsch
15 = 21 -> OK aber an der Stelle bereits falsch
... leider lässt sich die SID so nicht korrekt darstellen.

[nahpets]

Hallo,

befürchte, da haben wir wohl ein bisserl aneinander vorbeigepostet.

Ich gehe mal forschen und melde mich später noch mal.

[nahpets]

Hallo,

so könnte es aufgebaut sein, damit müsstest Du Dir dann eine passende Funktion zum "Aufbröseln" schreiben können.

Code:

S-1-5-21-2730868873-810845422-3379721866-1146

Dez: 21 = Hex: 15
Hex: 15 rückwärts -> 15 00 00 00 -> Byte 9 bis 12
01 05 00 00 00 00 00 05 15 00 00 00 89 C0 C5 A2 EE 84 54 30 8A 76 72 C9 7A 04 00 00

Dez: 2730868873 = Hex: A2C5C089
Hex: A2C5C089 rückwärts -> 89 C0 C5 A2 -> Byte 13 bis 16
01 05 00 00 00 00 00 05 15 00 00 00 89 C0 C5 A2 EE 84 54 30 8A 76 72 C9 7A 04 00 00

Dez: 810845422 = Hex: 305484EE
Hex: 305484EE rückwärts -> EE 54 84 EE -> Byte 17 bis 20
01 05 00 00 00 00 00 05 15 00 00 00 89 C0 C5 A2 EE 84 54 30 8A 76 72 C9 7A 04 00 00

Dez: 3379721866 = Hex: C972768A
Hex: C972768A rückwärts -> 8A 76 72 C9 -> Byte 21 bis 24
01 05 00 00 00 00 00 05 15 00 00 00 89 C0 C5 A2 EE 84 54 30 8A 76 72 C9 7A 04 00 00

Dez: 1146 = Hex: 47A
Hex: 47A rückwärts -> 7A 04 00 00 -> Byte 25 bis 28
01 05 00 00 00 00 00 05 15 00 00 00 89 C0 C5 A2 EE 84 54 30 8A 76 72 C9 7A 04 00 00

Für die ersten 8 Byte habe ich keine eindeutige Zuordnung gefunden, dass scheint aber auf allen Systemen immer S-1-5- zu sein.

[Luckie]

Zitat:

Zitat von nahpets

Für die ersten 8 Byte habe ich keine eindeutige Zuordnung gefunden, dass scheint aber auf allen Systemen immer S-1-5- zu sein.

Kann sich aber auch mal ändern: http://www.michael-puff.de/Artikel/SID.shtml

[cst_07]

Yeeehaaa, genial, super das wars. Jetzt kann ich schon mal die SID ermitteln :hello:

Vielen vielen Dank für die super Unterstützung!!!!

:dancer2:

[hsg]

Hi,

auch wenn dieses Thema bereits älter ist, klinke ich mich mal hier ein. Ich hatte in den letzten Tagen genau das selbe Problem. Nach langen Forschen und experimentieren habe ich die folgende Lösung gefunden. Ich poste sie mal hier, damit andere vielleicht schneller voran kommen :-D

Ein Teil der Lösung stammt aus entsprechenden Funktionen, die ich auf der Webseite selfADSI gefunden habe (wenn ich das richtig gesehen habe, stehen die Funktionen auch im MSDN, habe aber die Quelle nicht mehr dazu). Dort stehen sie als Funktionen für das Windows Scripting (WSH) zur Verfügung, ich habe sie nach Delphi transformiert und dabei versucht, sie so original wie möglich zu lassen :) Gerade bei den Funktionen Byte4ToLong und Byte6ToLong ist damit natürlich noch Optimierungs-Potential vorhanden.

Delphi-Quellcode:

//-----------------------------------------------------------------------------------------------
// Funktionen aus selfADSI.de: http://www.selfadsi.org/deep-inside/microsoft-sid-attributes.htm
// Autor: ??? übersetzt von Jo.Hoyer
// Datum: 14.07.2011 06:38:17
//----------------------------------------------------------------------------------------------
Function Byte4ToLong(b1, b2, b3, b4 : Byte) : Cardinal;
begin
  //'converts 4 bytes to the according lang integer value
  Result := b1;
  Result := Result * 256 + b2;
  Result := Result * 256 + b3;
  Result := Result * 256 + b4;
End;


Function Byte6ToLong(b1, b2, b3, b4, b5, b6 : Byte) : Cardinal;
begin
  // converts 6 bytes to the according lang integer value
    Result := b1;
    Result := Result * 256 + b2;
    Result := Result * 256 + b3;
    Result := Result * 256 + b4;
    Result := Result * 256 + b5;
    Result := Result * 256 + b6;
End;

Function HexStrToSID(strSid : WideString) : string;
var
  i           : Integer;
  data        : Array of Byte;
  offset      : Integer;
  blockCount  : Integer;
  nLen        : Integer;
begin
  //converts a raw SID hex string to the according SID string (SDDL)
  nLen      := Length(strSid);
  nLen      := nLen div 2 - 1;
  SetLength(data,nLen);
  For i := 0 To Length(data) do begin
    data[i] := StrToInt('$' + Copy(strSid, 2*i + 1, 2));
  end;
  Result    := 'S-' + IntToStr(data[0]) + '-' + IntToStr(Byte6ToLong(data[2], data[3], data[4], data[5], data[6], data[7]));

  blockCount := data[1];
  For i := 0 To blockCount - 1 do begin
    offset  := 8 + 4 * i;
    Result  := Result + '-' + IntToStr(Byte4ToLong(data[offset+3], data[offset+2], data[offset+1], data[offset]));
  end;
End;

//------------------------------------------------------------------------------------------------
// Übersetze SID aus LDAP-Verzeichnis
// Autor: jo.hoyer
// Datum: 08.07.2011 09:10:26
//------------------------------------------------------------------------------------------------
function GetSIDString(aObjectSID : OleVariant): WideString;
var
  i       : Integer;
  nMin    : Integer;
  nMax    : Integer;
  nDim    : Integer;
  cWStr   : WideString;
begin
  nDim      := VarArrayDimCount(aObjectSID);
  nMin      := VarArrayLowBound(aObjectSID, nDim);
  nMax      := VarArrayHighBound(aObjectSID,nDim);
  cWStr     := '';
  for i := nMin to nMax do begin
    cWStr   := cWStr + IntToHex(VarArrayGet(aObjectSID, i),2);
  end;
  Result    := HexStrToSID(cWStr);
end;