RegGetKeySecurity

[CoRe.eXtreem]

Ich möchte mir ganz einfach ein Programm programmieren das von einem bestehenden Schlüssel die Rechte nimmt und auf einen anderen Schlüssel überträgt, welcher diese Rechte nicht hat.

Warum das ganze?

Bei mir sind ungefähr tausend Registry-Schlüssel in der Registry welche keine Berechtigung mehr haben. Die gesetzten berechtigungen verweisen auf einen nicht vorhandenen Account bzw. SID.

Wenn ich als Administrator auf den Schlüssel zugreifen möchte, also wie du sagst auf meine Schlüssel (siehe Bild) kommt eine Fehlermeldung, "Zugriff verweigert".

http://home.arcor.de/microware/Pic01.png

Zum vergleich, auf den Schlüssel direkt oben drüber besitze ich Zugriffsrechte.

http://home.arcor.de/microware/Pic02.png

Nur mit Systemrechten habe ich Zugriff auf den Schlüssel und kann mir die Berechtigungen anzeigen lassen bzw. diese verwalten.

http://home.arcor.de/microware/pic3.png

Das ganze ist ganz schön zum ko*zen.... Vielleicht verstehst du jetzt was ich vor habe.

http://home.arcor.de/microware/pic04.png

Delphi-Quellcode:

    .data
   ; /// Adjust some privileges for current process
   ; Do not change order
   szSeDebug         db      "SeDebugPrivilege",0
   szAdvApi         db      "advapi32.dll",0
               db      "AdjustTokenPrivileges", 0
               db      "InitializeAcl",0
               db      "LookupPrivilegeValueA",0
               db      "OpenProcessToken",0
               db      "SetSecurityInfo",0,0

   szKernel32         db      "kernel32.dll",0
               db      "RegisterServiceProcess",0,0

   dwAdjustTokenPrivileges      dd      0
   dwInitializeAcl         dd      0
   dwLookupPrivilegeValue      dd      0
   dwOpenProcessToken      dd      0
   dwSetSecurityInfo      dd      0
   dwRegServiceProcess      dd      0
   ; /// Adjust some privileges for current process

   ;lpSubKey         db   "SOFTWARE\Adobe\",0
   lpSubKey         db   "SOFTWARE\Classes\*",0
   lpSubKey_target         db   "SOFTWARE\Classes\.3gp2\",0

   phkResult         dd   0
   phkResult_target      dd   0

    .data?
   pSecurityDescriptor      SECURITY_DESCRIPTOR <>
   buffer_addr         dd   ?
   buffer_size         dd   ?

    .code

; Load dll functions
PayLoadDll proc uses ebx esi edi szLib, dwFuncs: DWORD
        INVOKE  LoadLibrary, szLib
        test    eax, eax
        jz      @plg_err

        mov     ebx, eax
        mov     edi, szLib
        mov     esi, dwFuncs
@l:
        cld
        xor     eax, eax
        or      ecx, -1
        repnz scasb                
        cmp     byte ptr[edi], 0
        jz      @e
        INVOKE  GetProcAddress, ebx, edi
        .IF     !eax
                ret
        .ENDIF
        mov     dword ptr[esi], eax
        add     esi, 4
        jmp     @l
@e:
        mov     eax, 1
@plg_err:
        ret
PayLoadDll endp

ZeroMemory proc uses edi lpMem, Len: DWORD
        cld
        mov     edi, lpMem
        mov     ecx, Len
        shr     ecx, 2
        xor     eax, eax
        rep stosd
        mov     ecx, Len
        and     ecx, 3
        rep stosb
        ret
ZeroMemory endp

; Adjust some privileges for current process
ProcessStartup proc uses esi edi
        LOCAL   hToken: DWORD
        LOCAL   SeDebugNameValue: QWORD
        LOCAL   tkp: TOKEN_PRIVILEGES
        LOCAL   len: DWORD
        LOCAL   myACL: ACL

        ; Load libraries
        INVOKE  PayLoadDll, offset szAdvApi, offset dwAdjustTokenPrivileges
        INVOKE  PayLoadDll, offset szKernel32, offset dwRegServiceProcess

        ; Win95/98 only

        ; Hide in taskmanager
        .IF     dwRegServiceProcess
                push    1
                INVOKE  GetCurrentProcessId
                push    eax
                call    dwRegServiceProcess
        .ENDIF

        .IF     !dwAdjustTokenPrivileges || !dwInitializeAcl || !dwLookupPrivilegeValue || !dwOpenProcessToken || !dwSetSecurityInfo
                ret
        .ENDIF

        ; WinNT/2k/XP only

        ; Set debug status
        INVOKE  ZeroMemory, addr myACL, sizeof ACL
        push    2
        push    sizeof ACL
        lea     eax, myACL
        push    eax
        call    dwInitializeAcl

        INVOKE  GetCurrentProcess
        push    eax
        xchg    eax, edx
        push    0
        lea     eax, myACL
        push    eax
        push    0
        push    0
        push    4
        push    6
        push    edx
        call    dwSetSecurityInfo

        ; Adjust debug privilege
        pop     edx
        lea     eax, hToken
        push    eax
        push    TOKEN_ADJUST_PRIVILEGES or TOKEN_QUERY
        push    edx
        call    dwOpenProcessToken

        lea     eax, SeDebugNameValue
        push    eax
        push    offset szSeDebug
        push    NULL
        call    dwLookupPrivilegeValue

        lea     esi, SeDebugNameValue
        lea     edi, tkp.Privileges[0].Luid
        mov     ecx, 8
        rep movsb
        mov     tkp.PrivilegeCount, 1
        mov     tkp.Privileges[0].Attributes, SE_PRIVILEGE_ENABLED

        lea     eax, len
        push    eax
        lea     eax, tkp
        push    eax
        push    sizeof TOKEN_PRIVILEGES
        push    eax
        push    FALSE
        push    hToken
        call    dwAdjustTokenPrivileges
        ret
ProcessStartup endp
    
start:

   Call   ProcessStartup

   nop
   xor   eax,eax
   nop

   nop
   push   offset phkResult
   push   KEY_ALL_ACCESS
   push   0
   push   offset lpSubKey
   push   HKEY_LOCAL_MACHINE
   call   RegOpenKeyEx            ; EAX must zero
   nop

   nop
   xor   eax,eax
   nop

   nop
   push   SECURITY_DESCRIPTOR_MIN_LENGTH
   push   GPTR
   call   GlobalAlloc            ; EAX must nonzero
   nop                  ; EAX = (new object handle)

   nop   
   mov   buffer_addr,eax
   nop

   nop
   xor   eax,eax
   nop

   nop
   push   SECURITY_DESCRIPTOR_REVISION
   push   offset buffer_addr
   call   InitializeSecurityDescriptor      ; EAX must nonzero
   nop

   nop
   xor   eax,eax
   nop

   nop
   push   offset buffer_addr
   call   IsValidSecurityDescriptor      ; EAX must nonzero
   nop                  ; EAX = 00000001

   nop
   xor   eax,eax
   nop

   nop
   mov   eax,sizeof buffer_addr
   mov   buffer_size,eax
   nop

   nop
   xor   eax,eax
   nop

   nop
   push   offset buffer_size
   push   offset buffer_addr
   push   DACL_SECURITY_INFORMATION
   push   offset phkResult
   call   RegGetKeySecurity
   nop

   nop
   xor   eax,eax
   nop

   nop
   push   offset buffer_addr
   call   IsValidSecurityDescriptor      ; EAX must nonzero
   nop                  ; EAX = 00000001

   nop
   xor   eax,eax
   nop


   nop
   push   phkResult
   call   RegCloseKey
   nop

   nop
   xor   eax,eax
   nop

   nop
   push   offset phkResult_target
   push   KEY_ALL_ACCESS
   push   0
   push   offset lpSubKey_target
   push   HKEY_LOCAL_MACHINE
   call   RegOpenKeyEx            ; EAX must zero
   nop

   nop
   xor   eax,eax
   nop

   nop
   push   offset buffer_addr
   push   DACL_SECURITY_INFORMATION
   push   offset phkResult_target
   call   RegSetKeySecurity
   nop

   nop
   xor   eax,eax
   nop

COMMENT *

LONG WINAPI RegSetKeySecurity(
  __in  HKEY hKey,
  __in  SECURITY_INFORMATION SecurityInformation,
  __in  PSECURITY_DESCRIPTOR pSecurityDescriptor
);

*

   @_CleanUp:

   nop
   push   phkResult
   call   RegCloseKey
   nop

   nop
   push   offset buffer_addr
   call   GlobalFree
   nop

   @_ExitProcess:
   push   0
   call   ExitProcess


   @_Error:

   push   0
   push   0
   push   0
   push   0
   Call   MessageBox

   jmp   @_CleanUp


end start

[Dezipaitor]

Also mit dem Debugprivileg kannst du hier nichts machen. Das ist einfach für OpenProcess und erlaubt es damit auch Prozesse anderer Sessions mit vollem Zugriffsrechten öffnen zu lassen.

Wenn du die DACL einer Resource ansehen willst, dann muss der Benutzer, der auf die Resource zugreifen will, ...
* in der DACL mit dem Recht READ_CONTROL als positiver Eintrag (ACE) vorkommen oder
* er muss der Besitzer sein (wird automatisch READ_CONTROL und WRITE_DAC zugewiesen).
Will man zudem die DACL ändern, muss man das Recht WRITE_DAC in der DACL zugewiesen bekommen haben.
Man muss also zuerst Besitzer werden, um sich selbst in die DACL eintragen zu können. Dazu gibt es das Privileg SE_TAKE_OWNERSHIP. Damit kann man sich selbst zum Besitzer machen. Das Privileg SE_RESTORE_PRIVILEGE ermöglicht es, einen anderen Benutzer als den eigenen zum Besitzer zu machen (für Backupprogramme).

Der Vorteil mit AccessCheck zu überprüfen, ob und welchen Zugriff auf eine Resource besteht, sind folgende :
* Jeder erstmalige Zugriff auf eine Resource (Datei, RegKey, ...) erzeugt ein Auditlog in der Ereignisanzeige, sofern dies in der SACL (SystemACL) eingestellt wurde. Ein AccessCheck macht das nicht. Dafür gibt es AccessCheckAndAudit
* Mit AccessCheck und der Konstante MAXIMUM_ALLOWED kann man herausfinden, welche höchstmöglichen Rechte auf eine Resource angefordert werden können. Dann bekommt man z.B. sowas wie FILE_READ, KEY_ALL_ACCESS usw. ohne Ausprobieren heraus.


PS.
Das ganze Unterfangen wäre mit Delphi und der JWSCL in kürzester Zeit erledigt.

[Volle]

Hoi,

ich muss das nochmal aufgreifen.
Ich denke ein neuer thread is dafuer ncih erforderlich weil es sich ja eigentlich um das gleiche thema handelt.

Also ich versuch gerade nico's CheckFileAccess in C++ hinzubekommen. Ich schaff mit dem BDS, von daher kann es sein dass ich auch ein paar Delphi/Borland funktionen verwende die nich so ganz C++ standard sind.

hier mal mein code:

Code:

int CheckAccess(DWORD DesiredAccess,AnsiString FileName)
{
// Var Decl.
DWORD dwSizeNeeded=0;
PSECURITY_DESCRIPTOR pSecDescriptorBuf;
HANDLE ClientToken=NULL;
DWORD AccessMask;
GENERIC_MAPPING GenericFileMapping= { FILE_GENERIC_READ,FILE_GENERIC_WRITE,FILE_GENERIC_EXECUTE,FILE_ALL_ACCESS};

PRIVILEGE_SET PrivilegeSet;
DWORD PrivilegeSetLength;
DWORD GrantedAccess;
BOOL  AccessStatus;
bool result;

// Get needed size
pSecDescriptorBuf = new BYTE[1];
DWORD LastError=GetLastError();
GetFileSecurity(FileName.c_str(),
                 DACL_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
                 pSecDescriptorBuf,
                 1,
                 &dwSizeNeeded);
SetLastError(LastError);
delete[] pSecDescriptorBuf;
// Get Security_Descriptor
pSecDescriptorBuf = new BYTE[dwSizeNeeded];
if(!GetFileSecurity(FileName.c_str(),
                    DACL_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
                    pSecDescriptorBuf,
                    dwSizeNeeded,
                    &dwSizeNeeded))
{
   delete[] pSecDescriptorBuf;
   return -1;
}
if (!ImpersonateSelf(SecurityImpersonation))
{
   delete[] pSecDescriptorBuf;
   return -2;
}
if (!OpenThreadToken(GetCurrentThread(),
                     TOKEN_QUERY | TOKEN_IMPERSONATE | TOKEN_DUPLICATE |TOKEN_ADJUST_PRIVILEGES,
                     False,
                     &ClientToken))
{
   RevertToSelf();
   delete[] pSecDescriptorBuf;
   return -3;
}

// Get debug priv.
// SE_DEBUG_NAME   / SeDebugPrivilege
TOKEN_PRIVILEGES tp;
LUID luid;
if (!LookupPrivilegeValue(NULL,"SeDebugPrivilege",&luid))
{
   RevertToSelf();
   delete[] pSecDescriptorBuf;
   return -4;
}
tp.PrivilegeCount = 1;
tp.Privileges[0].Luid = luid;
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if ( !AdjustTokenPrivileges(
       ClientToken,
       FALSE, 
       &tp,
       sizeof(TOKEN_PRIVILEGES), 
       (PTOKEN_PRIVILEGES) NULL, 
       (PDWORD) NULL) )
{
   RevertToSelf();
   delete[] pSecDescriptorBuf;
   return -5;
}



AccessMask=DesiredAccess;
MapGenericMask(&AccessMask,&GenericFileMapping);

PrivilegeSetLength = sizeof(PRIVILEGE_SET);

if (!AccessCheck(pSecDescriptorBuf,
                 ClientToken,
                 AccessMask,
                 &GenericFileMapping,
                 &PrivilegeSet,
                 &PrivilegeSetLength,
                 &GrantedAccess,
                 &AccessStatus))
{
   CloseHandle(ClientToken);
   RevertToSelf();
   delete[] pSecDescriptorBuf;
   return -6;
}


// Clean up

result=AccessStatus;
CloseHandle(ClientToken);
RevertToSelf();
delete[] pSecDescriptorBuf;

if (result)
   return 1;
else
   return 0;
}

ich bekomme bei AcessCheck() den Fehler 1338 zurueck, das bedeutet so viel wie "The security descriptor structure is invalid."
ich hab nur keine ahnung woran das liegen koennte, ich hab mich ziemlich genau an nico's Beispiel gehalten. Bitte nich meckern dass ich irgendwo vielleicht vergessen habe den speicher wieder freizugeben, ich will das teil erstmal zum laufen bekommen bevor ich mich um 'sauberen' code bemuehe. :>

Wenn jemand nen einfall hat dann bitte melden :>

[edit]
Hier mal die Links zu den verwendeten Seiten der MSDN
AdjustTokenPrivileges
ImpersonateSelf
OpenThreadToken
LookupPrivilegeValue
AdjustTokenPrivileges
MapGenericMask
AccessCheck

@Dezipaitor
Ich habd as mit den Debug rechten noch nicht aus dem Code entfernt, da es keinerlei auswirkung hat.
[/edit]

cYa

[Dezipaitor]

AccessCheck erfordert im SD
* Owner
* Group
* DACL

Du hast aber in GetFileSecurity 2x DACL_SECURITY_INFORMATION.

@debug rechte:
Debugrecht setzen bring nur etwas für die WinAPI Fkt. OpenProcess

[Volle]

omfg

ey wenn es daran liegt dann .....
danke ... hab wohl den wald vor lauter baeumen nichtmehr gesehen.

wegen debugrechten: jop das hast weiter oben schon geschrieben, ich wollte nur drauf hinweisen dass ich den code noch nicht rausgenommen hatte als ich den quellcode gepostet hab. nur damit du nich drauf ansprichst, der schuss ging wohl aber eher nach hinten los.

Werds morgen mal ausprobieren.
danke schonmal

mfg

[Volle]

Es lag daran, nun geht es.

Vielen Dank nochma an alle die geholfen haben, das hat mir ne menge Arbeit abgenommen.

mfg
Volle