Beenden eines Prozesses mittels ACL verhindern

[Zacherl]

Hallo,
da ich mir den Code zum Verstecken eines Prozesses vor dem Taskmanager angeguckt habe, wurde ich darauf verwiesen lieber das Beenden eines Prozesses mit den ACLs zu verhindern.

Meine Fragen: Geht dies mit eingeschränkten Rechten? Hat vielleicht jemand eine Beispiel Anwendung? Ich kenne mich in diesem Anwendungsgebiet nicht gut aus, daher wäre ein Beispiel halt sinnvoll.

Florian

[Olli]

Es geht immer. Auch mit eingeschränkten Rechten. Allein, es hilft nur bedingt, weil sich ein Admin oder das System die nötigen Rechte besorgen kann ;)

Verbieten kannst du den Zugriff im ACL aber schonmal für alle außer dem Benutzer in dessen Kontext du läufst. Absolutismen gibt es eben nicht ;)

[Zacherl]

Gut. Es geht nämlich auch nicht um die Admins, die das Programm nicht beenden sollen.
Hast du vielleicht einen kleinen Quelltext? Wie gesagt, in dem Gebiet kenne ich mich nicht sehr gut aus ...

Florian

[Olli]

Dann wühle dich mal von SetKernelObjectSecurity aus durch die Funktionen. Auf NT4 gibt's ein paar Fallgruben, aber das ist ja möglicherweise nicht zu akut. Ansonsten ist die einzige nichtkommerzielle Seite, die ich zum Thema Sicherheit mit Delphi kannte, irgendwann im letzten Jahr in den Tiefen des WWW begraben worden :| ... die gibt's also nicht mehr. Aber o.g. Funktion sollte dich schon weiterbringen.

Unter http://jedi-apilib.sf.net solltest du eigentlich auch die Deklarationen der entsprechenden Funktionen und Strukturen finden.

[Zacherl]

Ich komme nicht klar mit der SetKernelObjectSecurity Funktion.
Bitte nennt mir ein Aufrufbeispiel wie man das Beenden des eigenen Prozesses verhindert.

Der 1. Parameter ist schonmal die ProcessID, denke ich.

Florian

[Zacherl]

Habe diesen Source gefunden:

Delphi-Quellcode:

var 
      lpSecDesc: pointer; 
      lpACL: PACL; 
      dwSecurityInfo: DWORD; 
begin 
      GetMem(lpSecDesc, SECURITY_DESCRIPTOR_MIN_LENGTH); 
      InitializeSecurityDescriptor(lpSecDesc, 1); 
      GetMem(lpACL, SizeOf(TACL)); 
      InitializeACL(lpACL^, SizeOf(TACL), 2); 
      SetSecurityDescriptorDACL(lpSecDesc, True, lpACL, False); 
      dwSecurityInfo:= DACL_SECURITY_INFORMATION; 
      SetKernelObjectSecurity(GetCurrentProcess, dwSecurityInfo, lpSecDesc); 
      FreeMem(lpACL); 
      FreeMem(lpSecDesc); 
end;

Und hier noch eine Beschreibung, wie man seinen Prozess unbeendbar macht, die ich auch nicht verstehe:

Zitat:

Get a handle to the process you want to protect (GetCurrentProcess for the
current process).
Pass the handle to GetKernelObjectSecurity to get its DACL. Add a Denied
ACE to it specifying the current user's SID (or better yet, the well-known
SID for "Everyone"), and the PROCESS_TERMINATE right. Call
SetKernelObjectSecurity to update the process' DACL.

Nur was bewirkt dieser?

[Zacherl]

*push*

Tut mir Leid, musste sein ...

[Zacherl]

Kann wirklich keiner helfen?
Ich habe jetzt bestimmt schon 2 Stunden in etlichen Suchmaschienen gesucht, aber nichts außer die schon geposteten Sachen gefunden.
Alle meine Delphi Bücher gehen auch nicht näher auf die API ein.

[Zacherl]

Jetzt habe ich noch AddDeniedACE gefunden. Nur die ganze Struktur ist umständlich. Da gibt es _ACL oder PACL, welcher ein Pointer auf _ACL ist, oder so ähnlich.
Wie kann ich das anwenden?
Ich hab überhaupt keine Ahnung.

[Alexander Roth]

Hi Leute,

ich habe genau das gleiche Problem.

Zitat:

Zitat von Florian Bernd

Habe diesen Source gefunden:

Delphi-Quellcode:

var 
      lpSecDesc: pointer; 
      lpACL: PACL; 
      dwSecurityInfo: DWORD; 
begin 
      GetMem(lpSecDesc, SECURITY_DESCRIPTOR_MIN_LENGTH); 
      InitializeSecurityDescriptor(lpSecDesc, 1); 
      GetMem(lpACL, SizeOf(TACL)); 
      InitializeACL(lpACL^, SizeOf(TACL), 2); 
      SetSecurityDescriptorDACL(lpSecDesc, True, lpACL, False); 
      dwSecurityInfo:= DACL_SECURITY_INFORMATION; 
      SetKernelObjectSecurity(GetCurrentProcess, dwSecurityInfo, lpSecDesc); 
      FreeMem(lpACL); 
      FreeMem(lpSecDesc); 
end;

Ok compilieren tut er das. Doch funktionieren tut es nicht.
Bei mir kann ich das Programm sowohl über das X als auch über den Taskmanager killen. :cry:

PS: @Florian Bernd: Es gibt ein edit Feld rechts oben bei jedem Beitrag. Da muss man nicht immer einen neuen schreiben. :wink:

[Christian Seehase]

Moin Alexander,

die Funktionen haben in der Regel einen Rückgabewert.
Den solltest Du mal auswerten.
Was der jeweilige bedeutet kannst Du ja im MSDN bzw. PSDK nachschlagen.

Ausserdem solltest Du auch mal Resourcenschutzblöcke einbauen.

[himitsu]

@Alexander Roth:
läßt du es auch unter einen anderem Account laufen?

für den aktuellen Benutzer soll es ja dennoch möglich sein das zu beenden

Zitat:

Zitat von Olli

Verbieten kannst du den Zugriff im ACL aber schonmal für alle außer dem Benutzer in dessen Kontext du läufst. Absolutismen gibt es eben nicht ;)

[Alexander Roth]

Upss... :duck:
probiere es sofort aus.

[Zacherl]

Zitat:

@Florian Bernd: Es gibt ein edit Feld rechts oben bei jedem Beitrag. Da muss man nicht immer einen neuen schreiben.

Ist mir bekannt ;) Ein bisschen pushen muss sein :mrgreen:

Die Frage ist übrigens immer noch offen ...

Florian

[Timi-loader]

immernoch offen.. njo... und ich würs auch gernmal wissen. habe nämöich vor sone art lehrer-schüler-anwensung zu schreiben.
mfg

[Zacherl]

Ja, wollte ich auch mal machen so in der Art, bzw will ich noch machen, leider wurde ich immer auf Services verwiesen.
Die ACL Frage interessiert mich aber weiterhin brennend.

Florian

[Zacherl]

Und nochmal ein *push* nach längerer Zeit ... irgendwar wirds doch wohl wissen ...

[Zacherl]

Nochmal ein Versuch ;) Irgendwann kommt schon eine Antwort :D

Kann es sein, dass man zu dem Code, den ich gefunden habe:

Delphi-Quellcode:

var 
      lpSecDesc: pointer; 
      lpACL: PACL; 
      dwSecurityInfo: DWORD; 
begin 
      GetMem(lpSecDesc, SECURITY_DESCRIPTOR_MIN_LENGTH); 
      InitializeSecurityDescriptor(lpSecDesc, 1); 
      GetMem(lpACL, SizeOf(TACL)); 
      InitializeACL(lpACL^, SizeOf(TACL), 2); 
      SetSecurityDescriptorDACL(lpSecDesc, True, lpACL, False); 
      dwSecurityInfo:= DACL_SECURITY_INFORMATION; 
      SetKernelObjectSecurity(GetCurrentProcess, dwSecurityInfo, lpSecDesc); 
      FreeMem(lpACL); 
      FreeMem(lpSecDesc); 
end;

irgendwas mitt AddACL oder AddDeniedACL machen muss?

[Olli]

So, der Florian hat mich breitgeschlagen nochmal zu gucken. Und obwohl wir erstmal den Admin nicht davon abhalten können unseren Prozeß zu killen (resistance is futile? :mrgreen: ), hier mal die aktuelle Lösung.

Die Kernfunktion ist folgende:

Delphi-Quellcode:

function ForbidProcessAccess(hProcess: THandle): Boolean;
var
  lpSecDesc: PSECURITY_DESCRIPTOR;
  lpACL: PACL;
  dwAclLength: DWORD;
  lpWorldSid: Pointer;
begin
  // Default result is FALSE
  Result := False;
  // Allocate memory for the security descriptor
  lpSecDesc := PSECURITY_DESCRIPTOR(GlobalAlloc(GPTR, SECURITY_DESCRIPTOR_MIN_LENGTH));
  // Sanity check
  if (Assigned(lpSecDesc)) then
  try
    // Init the structure
    InitializeSecurityDescriptor(lpSecDesc, SECURITY_DESCRIPTOR_REVISION);
    // Sanity check the creation of the World/Everyone SID
    if (AllocateAndInitializeSid(SECURITY_WORLD_SID_AUTHORITY, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, lpWorldSid)) then
    try
      // Calculate the ACL size required
      dwAclLength := sizeof(ACL) + sizeof(ACCESS_DENIED_ACE) * 1 + {number of ACEs} GetLengthSid(lpWorldSid);
      // Allocate a buffer for the ACL
      lpACL := PACL(GlobalAlloc(GPTR, dwAclLength));
      // Sanity check
      if (Assigned(lpACL)) then
      try
        // Initialize it, telling the size available
        InitializeACL(lpAcl^, dwAclLength, ACL_REVISION);
        // Add a "Deny ACE" to it
        if (AddAccessDeniedAce(lpAcl^, ACL_REVISION, PROCESS_ALL_ACCESS, lpWorldSid)) then
          // Set the ACL as part of the SD
          if (SetSecurityDescriptorDacl(lpSecDesc, True, lpACL, False)) then
          begin
            // Set the new SD
            // OWNER_SECURITY_INFORMATION should be given in the flags if the owner was set
            // using SetSecurityDescriptorOwner()
            Result := SetKernelObjectSecurity(hProcess, DACL_SECURITY_INFORMATION, lpSecDesc);
          end;
      finally
        // Clean up after us
        GlobalFree(HGLOBAL(lpACL));
      end;
    finally
      // Clean up after us
      FreeSid(lpWorldSid);
    end;
  finally
    // Clean up after us
    GlobalFree(HGLOBAL(lpSecDesc));
  end;
end;

Man sieht wiedermal meine Vorliebe für GlobalAlloc (das nullt mir nämlich den Puffer auch gleich aus :P ... und ich mag es richtig schön ausgenullt). Aus Globalisierungsgründen wie immer auf Englisch dokumentiert ;)

So, diese Funktion ruft man nun auf und schon kann der unprivilegierte Benutzer den Prozess nicht mehr killen. Allerdings sollte vermutlich am Owner noch gefeilt werden?!

Im Anhang das komplette Projekt (getestet auf BDS2K6) als DPR. Es enthält auch die benötigten und nicht von Delphi bereitgestellten Typendeklarationen usw.!

Daß es funzt kann man hier nachvollziehen: http://assarbad.net/de/stuff/temp/KillMeSoftly/

Es existiert auch noch eine weitere Funktion, die ursprünglich dazu gedacht war das Problem zu lösen, aber das Weglassen von "Allow ACEs" hat es eben nicht gebracht, so daß wir auf "Deny ACEs" ausweichen mußten.

Lizenz: keine! (PUBLIC DOMAIN, keine Garantien oder Haftung meinerseits) - Namensnennung erwünscht.
License: none! (PUBLIC DOMAIN, no guarantees or liability from my side) - Attribution appreciated.

Guten Rutsch (nur nicht auf der Straße, so wie ich vor zwei Wochen -> Gehirnerschütterung),

[nitschchedu]

Wie sieht es eigentlich aus? Habt ihr es geschaft den Bösen Admin davon abzuhalten den Process zu Beenden ?

Könnte man auch einen Bestimmten Benutzer nur noch die rechte zum Beenden geben ?

[Dezipaitor]

Ein Admin kann mit den richtigen Werkzeugen IMMER Prozesse beenden. Das geht sogar mit Systemprozessen. Jedoch kann das schön in einen BSOD enden.
Es wird nur dann etwas schwerer, wenn mehrere Prozesse auf sich gegenseitig acht geben und sich gegenseitig neu starten.

[Zacherl]

Das allerdings geht stark auf die Resourcen ..

[DGL-luke]

Zitat:

Zitat von Florian Bernd

Das allerdings geht stark auf die Resourcen ..

Hm, man kann auch die entsprechenden APIs hooken.