TShutDown komponente

[NikoMitDaMacht]

Als mir mal wieder langweilig war, habe ich mir gedacht dass ich doch mal eine kompo
fürs runterfahren einens rechners schreiben könnte:

Man kann mit ihr ganz einfach den rechner

-Runterfahren
-Ausschalten
-Neustarten
-In den StandBy-Mode versetzten
-In den Ruhezustand verstezten
-Und sich abmelden

Bitte jedem fehler melden!

Danke.

[NikoMitDaMacht]

Ja ihr habt vollkommen recht dass das eigektliich nur eine zusammenfassung von vielen Code-Sniplsenl ist. Aber der sinn ist einfach dass man nun leichter shutdownen kann.

zum Else-block ...ja habbich halt vergessen wegzumachen weil mir nicht engefalen ist was ich da rein machen sollte.

[Aike]

Einfacher geht's so (Zusammenfassung):

Delphi-Quellcode:

type
  TExit=(Reboot,Shutdown,Logoff,Hibernate,Standby);

Delphi-Quellcode:

procedure GetShutdownPrivileges;
 //Urheber: Daniel B.
var vi      : TOSVersionInfo;
    hToken  : THandle;
    tp      : TTokenPrivileges;
    h       : DWord;
begin
  vi.dwOSVersionInfoSize:=SizeOf(vi);
  GetVersionEx(vi);
  if vi.dwPlatformId = VER_PLATFORM_WIN32_NT then
  begin
    OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES,hToken);
    LookupPrivilegeValue(nil,'SeShutdownPrivilege',tp.Privileges[0].Luid);
    tp.PrivilegeCount := 1;
    tp.Privileges[0].Attributes := SE_PRIVILEGE_ENABLED;
    h := 0;
    AdjustTokenPrivileges(hToken,False,tp,0,PTokenPrivileges(nil)^,h);
    CloseHandle(hToken);
  end;
end;

Delphi-Quellcode:

procedure ExitWin(Exit:TExit;Force:boolean);
var Flags:integer;
begin
  GetShutdownPrivileges;

  if Exit=Shutdown then
    ExitWindowsEx(EWX_ShutDown,0);

  if Exit=Hibernate then
    SetSystemPowerState(false,Force);

  if Exit=Standby then
    SetSystemPowerState(true,Force);

  if Exit=Logoff then
  begin
    Flags:=EWX_LOGoff;
    if Force then
      flags:=flags+EWX_FORCE;
    ExitWindowsEx(flags,0);
  end;

  if Exit=Reboot then
  begin
    flags:=EWX_REBOOT;
    if Force then
      flags:=flags+EWX_FORCE;
    ExitWindowsEx(flags,0);
  end;
end;

greetz ...

[Luckie]

Warum ist GetShutdownPrivilege keine Funktion deren Rückgabewert man auswerten könnte? Was passiert, wenn es fehl schlägt? Dann rennst du muit dem restlichen Code in ein offenes Messer.

[Aike]

Ich kann mir keinen Grund vorstellen, warum GetShutdownPrivileges einen negativen Wert zurückgeben sollte.

[Luckie]

Weil ein Benutzer das Privileg nicht hat und somit nicht aktiviert werden kann?

Zitat:

Ich kann mir keinen Grund vorstellen,

Das sind immer sehr gefährliche Annahmen. "Ich kann mir keinen Grund vorstellen, warum der String länger als 1024 Zeichen wird."
Waren übrigens die letzten Worte des Programmierers bevor der Bufferoverflow seinen Computer zum Absturz brachte.

[Aike]

Entschuldige, wenn meine Programmierkünste und -erfahrungen nicht den deinigen entsprechen, Luckie. Deine Kritik kann trotzdem etwas freundlicher formuliert werden.

Wenn du etwas konstruktive Kritik abgeben willst, dann sag mir doch, wie es besser geht.

[Luckie]

Habe ich doch: Mach eine Funktion raus und überprüfe den Rückgabewert bevor du im Code fortfährst.

BTW bin ich der Meinung, dass meine Bemerkung emotional neutral und weder unfreundlich noch aggressiv oder gar beleidigend war.

[Aike]

Welche Stelle soll denn fraglich sein, dass funktioniert, was ausgeführt wird? So wie ich das sehe, holt sich die Prozedur einfach die Rechte (wenn'n ein Win NT ist).

[Daniel G]

Achim,

wenn Microsoft für den Fall, dass etwas schief geht, diesen drei Funktionen

• OpenProcessToken
• LookupPrivilegeValue
• AdjustTokenPrivileges

den Rückgabewert 0 gegeben hat, dann solltest du das als Programmierer der Sicherheit wegen doch einfach auch beachten und überprüfen.

[Luckie]

So habe ich es gemacht:

Delphi-Quellcode:

function EnablePrivilege(const Privilege: string; fEnable: Boolean; out
  PreviousState: Boolean): DWORD;
var
  Token        : THandle;
  NewState     : TTokenPrivileges;
  Luid         : TLargeInteger;
  PrevState    : TTokenPrivileges;
  Return       : DWORD;
begin
  PreviousState := True;
  if (GetVersion() > $80000000) then
    // Win9x
    Result := ERROR_SUCCESS
  else
  begin
    // WinNT
    if not OpenProcessToken(GetCurrentProcess(), MAXIMUM_ALLOWED, Token) then
      Result := GetLastError()
    else
    try
      if not LookupPrivilegeValue(nil, PChar(Privilege), Luid) then
        Result := GetLastError()
      else
      begin
        NewState.PrivilegeCount := 1;
        NewState.Privileges[0].Luid := Luid;
        if fEnable then
          NewState.Privileges[0].Attributes := SE_PRIVILEGE_ENABLED
        else
          NewState.Privileges[0].Attributes := 0;
        if not AdjustTokenPrivileges(Token, False, NewState,
          SizeOf(TTokenPrivileges), PrevState, Return) then
          Result := GetLastError()
        else
        begin
          Result := ERROR_SUCCESS;
          PreviousState :=
            (PrevState.Privileges[0].Attributes and SE_PRIVILEGE_ENABLED <> 0);
        end;
      end;
    finally
      CloseHandle(Token);
    end;
  end;
end;

Es wird der Wert von GetLastError zurückgegeben den man auswerten kann. Man könnte das noch etwas verbessern, die Zuweisung von Result ist etwas umständlich.

So ist es eventuell übersichtlicher:

Delphi-Quellcode:

function EnablePrivilege(const Privilege: string; fEnable: Boolean; out PreviousState: Boolean): DWORD;
var
  Token             : THandle;
  NewState          : TTokenPrivileges;
  Luid              : TLargeInteger;
  PrevState         : TTokenPrivileges;
  Return            : DWORD;
begin
  SetLastError(0);  // Clear last system error state
  PreviousState := True;
  if (GetVersion() > $80000000) then // Win9x
    Result := ERROR_SUCCESS
  else // WinNT
  begin
    if OpenProcessToken(GetCurrentProcess(), MAXIMUM_ALLOWED, Token) then
    begin
      try
        if LookupPrivilegeValue(nil, PChar(Privilege), Luid) then
        begin
          NewState.PrivilegeCount := 1;
          NewState.Privileges[0].Luid := Luid;
          if fEnable then
            NewState.Privileges[0].Attributes := SE_PRIVILEGE_ENABLED
          else
            NewState.Privileges[0].Attributes := 0;
          if AdjustTokenPrivileges(Token, False, NewState, SizeOf(TTokenPrivileges), PrevState, Return) then
          begin
            PreviousState := (PrevState.Privileges[0].Attributes and SE_PRIVILEGE_ENABLED <> 0);
          end;
        end;
      finally
        CloseHandle(Token);
      end;
    end;
    Result := GetLastError;
  end;
end;