Home | Chi sono | Contattami
 

Progr. lineare

Delphi
  Componenti
  Database
  Miei articoli

Windows

Miei articoli 

Elencare i privilegi di un utente diverso da quello corrente
 

Nell' articolo Privilegi Utente è stata definita un procedura per elencare (con relativo stato di abilitazione) tutti i privilegi dell' utente corrente. Ora andremo a definire una procedura per elencare tutti i privilegi (con relativo stato di abilitazione) di un qualsiasi utente diverso da quello corrente.

Passiamo ora a descrivere le api che utilizzeremo
  


function LsaOpenPolicy(SystemName: PLSA_UNICODE_STRING;
                       var ObjectAttributes: LSA_OBJECT_ATTRIBUTES;
                       DesiredAccess: Cardinal;
                       var PolicyHandle: pointer): integer; stdcall;
Apre un oggetto Policy restituendo un Handle (parametro PolicyHandle) al medesimo: il codice restituito è 0 in caso di successo, <> 0 altrimenti.
 
SystemName<nome computer>
oppure
\\<nome computer>

nil per il computer locale

 

 
  PLSA_UNICODE_STRING = ^LSA_UNICODE_STRING;
  LSA_UNICODE_STRING = record
    Length: Word;
    MaximumLength: Word;
    Buffer: pWideChar;
  end;
ObjectAttributesAttributi di connessione 
		
  PLSA_OBJECT_ATTRIBUTES = ^LSA_OBJECT_ATTRIBUTES;
  LSA_OBJECT_ATTRIBUTES = record
    Length: Cardinal;
    RootDirectory: Cardinal;
    ObjectName: PLSA_UNICODE_STRING;
    Attributes: Cardinal;
    SecurityDescriptor: Pointer; // Points to type SECURITY_DESCRIPTOR
    SecurityQualityOfService: Pointer; // Points to type SECURITY_QUALITY_OF_SERVICE
  end;
I singoli membri del record vanno inizializzati a 0 o nil a seconda del tipo
DesiredAccessDiritti di accesso richiesti

Nel nostro caso useremo:

POLICY_LOOKUP_NAMES ($00000800) or POLICY_VIEW_LOCAL_INFORMATION ($00000001)

PolicyHandleHandle dell' oggetto policy che abbiamo aperto 

 


function LsaEnumerateAccountRights(PolicyHandle: Pointer; AccountSid: PSID;
                                   var UserRights: PLSA_UNICODE_STRING;
                                   var CountOfRights: Cardinal): Integer; stdcall;

Enumera i privilegi dell' account il cui SID è specificato dal parametro AccountSid;il codice restituito è 0 in caso di successo, <> 0 altrimenti
 
PolicyHandleHandle all' oggetto Policy ottenuto chiamamdo la funzione LsaOpenPolicy 
AccountSidSid dell' account di cui si vogliono enumerare i privilegi 
  PSid = ^SID;
  SID = record
    Revision: Byte;
    SubAuthorityCount: Byte;
    IdentifierAuthority: SID_IDENTIFIER_AUTHORITY;
    SubAuthority: array [0..0] of cardinal;
  end;
con 
  SID_IDENTIFIER_AUTHORITY = record
    Value: array [0..5] of Byte;
  end;
UserRightsElenco dei privilegi

E' un array di elementi del tipo LSA_UNICODE_STRING:

per ogni elemento dell' array, il campo Buffer contiene il nome del privilegio

 
PLSA_UNICODE_STRING = ^LSA_UNICODE_STRING;
LSA_UNICODE_STRING = record
 Length: Word;
 MaximumLength: Word;
 Buffer: pWideChar;
end;
CountOfRights Numero dei privilegi 


function LsaFreeMemory(Buffer: pointer): Integer; stdcall;
Libera la memoria occupata dall' array di record LSA_UNICODE_STRING; il codice restituito è 0 in caso di successo, <> 0 altrimenti 

function LsaClose(ObjectHandle: pointer): Integer; stdcall;
Chiude l' Handle all' oggetto policy restituito da LsaOpenPolicy;il codice restituito è 0 in caso di successo, <> 0 altrimenti

Per ottenere il valore del parametro AccountSid dal nome dell' account (nella funzione LsaEnumAccountRights) possiamo usare la seguente procedura


function Nome_SID(
                  const NomeSistema,
                  Nome: string;
                  var Sid: PSID): Boolean;
var
  DimensioneDominio, DimensioneSid: Longword;
  R: LongBool;
  Dominio: string;
  TipoSid: DWORD;
begin
  Result := False;
  DimensioneSid := 0;
  DimensioneDominio := 0;
  R := LookupAccountName(
                        PChar(NomeSistema),
                        PChar(Nome),
                        nil,
                        DimensioneSid,
                        nil,
                        DimensioneDominio,
                        TipoSid);
  if (not R) and (GetLastError = ERROR_INSUFFICIENT_BUFFER) then
  begin
    SetLength(Dominio, DimensioneDominio);
    Sid := AllocMem(DimensioneSid);
    Result := LookupAccountName(
                               PChar(NomeSistema),
                               PChar(Nome),
                               Sid,
                               DimensioneSid,
                               PChar(Dominio),
                               DimensioneDominio,
                               TipoSid);
    if not Result then
    begin
      FreeMem(Sid);
      Sid := nil;
    end
  end
  else
    raise Exception.Create(SysErrorMessage(GetLastError));

end;

ed ora la procedura per elencare i privilegi di un account 


procedure ElencoPrivilegi(AccountName: string);
var
  PolicyHandle: Pointer;
  ObjectAttr: LSA_OBJECT_ATTRIBUTES;
  DesiredAccess: DWORD;
  AccountSid: PSID;
  UserRight, UserRights: PLSA_UNICODE_STRING;
  Count: Cardinal;
  I: Integer;
begin
  AccountSid := nil;
  Nome_Sid('', AccountName, AccountSid);

  //POLICY_LOOKUP_NAMES or POLICY_VIEW_LOCAL_INFORMATION
  DesiredAccess := $00000800 or $00000001;
  FillChar(ObjectAttr, SizeOf(ObjectAttr), 0);
  LsaOpenPolicy(nil, ObjectAttr, DesiredAccess, PolicyHandle);

  LsaEnumerateAccountRights(PolicyHandle, AccountSid, UserRights, Count);
  UserRight := UserRights;
  I := 0;
  Form1.Memo1.Lines.Add('');
  Form1.Memo1.Lines.Add(AccountName + ' ' + 'Numero privilegi=' + IntToStr(Count));

  while I < Integer(Count) do
    begin
      Form1.Memo1.Lines.Add('  ' + string(WideString(UserRight.Buffer)));
      Inc(I);
      Inc(UserRight);//passo al privilegio successivo
    end;
  LsaFreeMemory(UserRights);
  FreeMem(AccountSid);
  LsaClose(PolicyHandle);
end;
 

A seguire la unit con la dichiarazione delle funzioni e la definizione dei tipi


unit uTypes;

interface

const

  advapi32 = 'advapi32.dll';

type

  PSID_IDENTIFIER_AUTHORITY = ^SID_IDENTIFIER_AUTHORITY;
  SID_IDENTIFIER_AUTHORITY = record
    Value: array [0..5] of Byte;
  end;

  PSid = ^SID;
  SID = record
    Revision: Byte;
    SubAuthorityCount: Byte;
    IdentifierAuthority: SID_IDENTIFIER_AUTHORITY;
    SubAuthority: array [0..0] of Cardinal; //array di qualsiasi dimensione
  end;

  PLSA_UNICODE_STRING = ^LSA_UNICODE_STRING;
  LSA_UNICODE_STRING = record
    Length: Word;
    MaximumLength: Word;
    Buffer: PWideChar;
  end;

  PLSA_OBJECT_ATTRIBUTES = ^LSA_OBJECT_ATTRIBUTES;
  LSA_OBJECT_ATTRIBUTES = record
    Length: Cardinal;
    RootDirectory: Cardinal;
    ObjectName: PLSA_UNICODE_STRING;
    Attributes: Cardinal;
    //puntatore a  SECURITY_DESCRIPTOR
    SecurityDescriptor: Pointer;
    //puntatore a SECURITY_QUALITY_OF_SERVICE
    SecurityQualityOfService: Pointer;
  end;


function LsaOpenPolicy(SystemName: PLSA_UNICODE_STRING;
                       var ObjectAttributes: LSA_OBJECT_ATTRIBUTES;
                       DesiredAccess: Cardinal;
                       var PolicyHandle: pointer): integer; stdcall;

function LsaEnumerateAccountRights(PolicyHandle: Pointer;
                                   AccountSid: PSID;
                                   var UserRights: PLSA_UNICODE_STRING;
                                   var CountOfRights: Cardinal): Integer; stdcall;

function LsaFreeMemory(Buffer: pointer): Integer; stdcall;

function LsaClose(ObjectHandle: pointer): Integer; stdcall;

implementation

function LsaOpenPolicy; external advapi32 name 'LsaOpenPolicy';

function LsaEnumerateAccountRights; external advapi32 name 'LsaEnumerateAccountRights';

function LsaFreeMemory; external advapi32 name 'LsaFreeMemory';
function LsaClose; external advapi32 name 'LsaClose';


end.

 

 

 
 
Your Ad Here