Passwort automatisch eingeben

[lukdelphias]

Hallo liebes Forum,

mal wieder eine Frage.
Ich möchte ein Programm als Administrator und mittels runAs starten. Windows fordert mich daraufhin automatisch auf das Administratorpasswort einzugeben.
Gibt es hier eine Möglichkeit das Passwort automatisch eingeben zu lassen?
Ich habe eine Batch geschrieben, und mit der funktioniert das ganz einwandfrei. Hier der Code falls den jemand benötigt:

Code:

@if (@CodeSection == @Batch) @then
@echo off
start runas /user:administrator C:\temp\...
CScript //nologo //E:JScript "%~F0"
goto :EOF
@end
WScript.CreateObject("WScript.Shell").SendKeys("password{ENTER}");

Für Delphi habe ich mir erstmal den Programmaufruf mit ShellExecute geschrieben. Das funktioniert soweit. Nur für die automatische Passworteingabe habe ich keine Lösung.
Jemand eine Idee?

Viele Grüße

[Delphi.Narium]

Suchmaschine: runas password

https://www.google.com/search?q=runas+password&oq=&aqs=

Zweiter Treffer: https://blog.friedlandreas.net/2015/...wort-mitgeben/

Abgeleitet von: https://stackoverflow.com/questions/...rom-batch-file

Von mir ausprobiert? Nö ;-) Aber eventuell was in Richtung Problemlösung.

[lukdelphias]

Hallo Danke erstmal. Das entspricht aber 1:1 meine Lösung von oben und ist für eine Batch vorgesehen. Ich suche allerdings nur noch eine Lösung für die Weitergabe des Passworts unter Delphi.
Grüße

[KodeZwerg]

Meinst Du so etwas?

Delphi-Quellcode:

procedure RunAsExec(hWnd: HWND; aFile: string; aParameters: string);
var
  SEI: TShellExecuteInfo;
begin
  FillChar(SEI, SizeOf(SEI), 0);
  SEI.cbSize       := sizeof(SEI);
  SEI.Wnd          := hWnd;
  SEI.fMask        := SEE_MASK_NOCLOSEPROCESS;
  SEI.lpVerb       := 'runas';
  SEI.lpFile       := PChar(aFile);
  SEI.lpParameters := PChar(aParameters);
  SEI.nShow        := SW_SHOWNORMAL;
  if not ShellExecuteEx(@SEI) then
    RaiseLastOSError;
end;

Beispiel-Aufruf:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  DateiName: string;
  Parameter: string;
begin
  DateiName := 'Programm.exe';
  Parameter := ' ' + 'Benutzername' + ' ' + 'Passwort';
  RunAsExec(Application.Handle, DateiName, Parameter);
end;

[Dalai]

Mit UAC-Dialogen kann man aus guten Gründen nicht interagieren. Aber es gibt natürlich andere Möglichkeiten, Prozesse als anderer Nutzer mit Passwort zu starten: CreateProcessAsUser in Kombination mit LogonUser bzw. gleich CreateProcessWithLogon.

Regards
Dalai

[lukdelphias]

Nein sowas meine ich nicht.
Mit Batch rufe ich zuerst mein Programm als Administrator auf. Das ganze funktioniert in Delphi ganz einfach mit ShellExecute.
Danach öffnet die Windows Konsole ein Fenster in dem ich das Administratorpasswort eingeben soll.
In der Batch kann ich mit SendKey das Passwort automatisch eingeben lassen und danach auch automatisch mit {ENTER} bestätigen lassen.
In Delphi öffnet es mir ebenfalls die Konsole mit der Aufforderung das Administratorpasswort einzugeben. Hier finde ich allerdings keine Möglichkeit das Passwort automatisch einzugeben und zu bestätigen. Hast du verstanden wie ich das meine? Ziemlich schwer hier ordentlich zu erklären...

Gruß

[KodeZwerg]

Ich hoffe ich habe Dich richtig verstanden: Ein Programm unter Angabe eines Logonnames plus Password starten, ohne das UAC erscheint.

Ich teste das heute Abend mal durch, mein Schnippsel lief zumindest unter XP noch so wie beschrieben, Programm startet ohne Aufforderungen seitens Windows.

[Delphi.Narium]

Also:

Nachdem meine erste Antwort nach genauerem Lesen eigentlich überflüssig war (ist halt doch irgendwie zu warm hier bei 39,3° im Schatten), derweil ich einfach mal etwas genauer hätte lesen sollen, bevor ich antworte. Sorry, versuche mich zu bessern ;-)

Mal langsam:

Batch funktioniert wie gewünscht von der Konsole.

Code:

WScript.CreateObject("WScript.Shell").SendKeys("password{ENTER}");

gibt das Passwort wie gewünscht weiter.

Beim ShellExecute aus Delphi heraus scheint dies aber nicht zu funktionieren.

Wunsch ist es:

Batchdatei weiterhin aus Delphi aufrufen und das Passwort wird nicht von WScript im Batch selbst "übergeben", sondern dieser Teil wird von Delphi übernommen.

Keine Ahnung, ob es hilft und wie das mit 'nem ShellExecute zusammenpassen könnte:

Stöbere bitte mal bitte im Umfeld von https://stackoverflow.com/questions/...n-using-winapi herum, eventuell kann ich Dir ja damit jetzt doch noch was zielführendes anbieten ;-)

Eventuell kannst Du die Batchdatei aber auch erweitern:

Schau mal bitte hier: https://docs.microsoft.com/en-us/pre...ectedfrom=MSDN

Jetzt nur als absolut ungetestete Idee:

Code:

@if (@CodeSection == @Batch) @then
@echo off
:: Parameter %1 der Batchdatei enthält dass Passwort des Administrators für den Server 01 und wird hier gespeichert.
cmdkey /add:server01 /user:administrator /pass:%1
start runas /user:administrator C:\temp\...
CScript //nologo //E:JScript "%~F0"
:: Die gespeicherte Anmeldung für den Administrator wird wieder gelöscht.
cmdkey /delete:server01
goto :EOF
@end

Mit etwas Glück musst Du dann in Deinem bisherigen ShellExecute nur das Administratorpasswort als ersten Parameter übergeben.

[lukdelphias]

Hallo Delphi.Narium immer noch nicht ganz. Das mit der Batch hast du richtig verstanden. Allerdings soll die Batch Datei komplett entfallen und alles soll aus Delphi herraus passieren.
Das Delphi Projekt siht bis jetzt so aus. Nicht von den ganzen uses verwirren lassen das ich noch vom vorherign Projekt ;)

Delphi-Quellcode:

program Project3;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.ComCtrls, Vcl.StdCtrls, Vcl.ExtCtrls, SHELLAPI, System.IOUtils,
  Registry, ShlObj, WinInet, System.UITypes,
  TlHelp32, WinSock;

begin
  try
    Shellexecute(0, 'open', PChar('runas'), PChar('/user:administrator C:\temp\...'), nil, SW_SHOW);
  except

  end;
end.

Hier soll einfach nur noch eine Funktion implementiert werden die die Aufgabe von SendKey aus der Batch übernimmt da auch hier nach dem ausführen die Eingabe des Adminpassworts geforder wird.
Wenn ich aber KodeZwerg richtig verstanden habe geht das leider nicht oder wie?

Gruß

[KodeZwerg]

Teste doch einfach mal meinen Code, ich kann es erst heut abend. Etwaige sonder-parameter habe ich bei mir nicht berücksichtigt.
Mein Schnippsel bezieht sich nur darauf: Ein Programm.exe unter dem Kontext von Benutzername plus Passwort starten ohne UAC.

//edit
Ps: Nicht die Leerzeichen beim Namen+Passwort vergessen! Deshalb auch mein kriminelles Beispiel für Code :-)

[himitsu]

Ebenso, wie man mit dem UAC-Dialogen nicht interagieren kann, gibt es auch bei RUNUS aus Sicherheitsgründen keinen Paramter, womit man das Passwort reingeben kann.
Aber es lässt sich via PIPE übergeben. https://stackoverflow.com/questions/...-line/16116329

Beim CreateProcess kann man auch so eine PIPE einrichten, siehe lpStartupInfo.hStdInput
auch wenn es hier sinnlos wäre, da man auch direkt CreateProcessAsUser/CreateProcessWithLogonW verwenden kann.

[lukdelphias]

Also KodeZwerg,
habe deinen Code mal probiert.
Fehler gibt es mir keine aus allerdings wird das Programm nicht ausgeführt...leider.
Hier der Code dazu:

Delphi-Quellcode:

unit Unit2;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, ShellAPI;

type
  TForm2 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure RunAsExec(hWnd: HWND; aFile: string; aParameters: string);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form2: TForm2;

implementation


{$R *.dfm}

procedure TForm2.RunAsExec(hWnd: HWND; aFile: string; aParameters: string);
var
  SEI: TShellExecuteInfo;
begin
  FillChar(SEI, SizeOf(SEI), 0);
  SEI.cbSize := sizeof(SEI);
  SEI.Wnd := hWnd;
  SEI.fMask := SEE_MASK_NOCLOSEPROCESS;
  SEI.lpVerb := 'runas';
  SEI.lpFile := PChar(aFile);
  SEI.lpParameters := PChar(aParameters);
  SEI.nShow := SW_SHOWNORMAL;
  if not ShellExecuteEx(@SEI) then
    RaiseLastOSError;
end;

procedure TForm2.Button1Click(Sender: TObject);
var
  DateiName: string;
  Parameter: string;
begin
  DateiName := 'C:\temp\test.exe';
  Parameter := ' ' + 'administrator' + ' ' + 'password';
  RunAsExec(Application.Handle, DateiName, Parameter);
end;

end.

@himitsu
Da schon viele von CreateProcessWithLogonW geredet haben. Hast du dafür irgendein Beispiel. Ich weiß nicht wie ich das auf meinen Fall anwenden muss, sodass es funktioniert:(

[lukdelphias]

Nur das habe ich bisher probiert:

Delphi-Quellcode:

program runadmin;

{$APPTYPE CONSOLE}

uses
  System, SysUtils, JwaWinBase;

var
  si: STARTUPINFOW;
  pif: PROCESS_INFORMATION;
  res: Boolean;
  s: string;
  cmd: PWideChar;
begin
  if Length(ParamStr(1)) = 0 then
    WriteLn(
      'RunAdmin - Kommando unter Administrator-Konto ausführen' + #13#10 +
      'Usage: runadmin <command>')
  else
  try
    si.cb := SizeOf(startupinfow);
    si.dwFlags := STARTF_USESHOWWINDOW;
    si.wShowWindow := 1;
    si.lpReserved := nil;
    si.lpDesktop := nil;
    si.lpTitle := 'Konsole';
    getmem(cmd,Length(ParamStr(1))*2);
    cmd := StringToWideChar(ParamStr(1),cmd,Length(ParamStr(1))*2);
    res := CreateProcessWithLogonW('Administrator', '', 'password', LOGON_WITH_PROFILE,
      nil,cmd,CREATE_DEFAULT_ERROR_MODE, nil, nil, si, pif);
    if booltostr(res) = '0' then
    begin
      str(GetLastError, s);
      WriteLn('Beim Ausfuehren des Befehls "' + ParamStr(1) + '"');
      WriteLn('ist der Fehler ' + s + ' aufgetreten.');
      Halt(1);
    end;
  except
    on E: Exception do
    begin
      WriteLn('Beim Ausfuehren des Befehls "' + ParamStr(1) + '"');
      WriteLn('ist der Fehler ' + E.Message + ' aufgetreten.');
      Halt(1);
    end;
  end;

end.

Das ist ein angeblich lauffähiges Beispiel aus einem anderen Thema. Funktioniert bei mir leider nicht.:(

[KodeZwerg]

Existiert ein Benutzerkonto namens "Administrator" ?

[lukdelphias]

Ja das gibt es:wink:

[KodeZwerg]

Okay, ich wollte nur sichergehen das man das als Fehler schonmal ausschließen kann. Zu morgen sollte ich was funktionierendes gebastelt bekommen.

[lukdelphias]

Das kling ja schonmal ganz gut. Vielen Dank erstmal für die Mühe.

[Moombas]

Also ich mache da aktuell so (allerdings in Lazarus):

Delphi-Quellcode:

//Oberhalb des "implementation" Bereichs
function CreateProcessWithLogonW(lpUsername, lpDomain, lpPassword: LPWSTR; dwLogonFlags: dword; lpApplicationName,
  lpCommandLine: LPWSTR; dwCreationFlags: dword; lpEnvironment: pointer; lpCurrentDirectory: LPWSTR; lpStartupInfo:
  PStartUpInfoW; lpProcessInfo: PProcessInformation): boolean; stdcall; external 'advapi32.dll';

Delphi-Quellcode:

//Im "implementatrion" Bereich
//Prozess als bestimmten Benutzer starten
function CreateProcessAsLogon(const User, PW, Application, param, CmdLine: WideString): DWORD;
var
  ws  : WideString;
  si  : TStartupInfoW;
  pif : TProcessInformation;
begin
  ZeroMemory(@si, sizeof(si));
  si.cb := sizeof(si);
  si.dwFlags := STARTF_USESHOWWINDOW;
  si.wShowWindow := 1;

  if CmdLine = '' then
  begin
    ws := Application;
  end else
  begin
    ws := Application + ' "' + CmdLine + '"';
  end;

  SetLastError(0);
  SI.cb  := SizeOf(TStartupInfo);
  if CreateProcessWithLogonW(PWideChar(User), nil, PWideChar(PW), 0, nil, PWideChar(ws), CREATE_DEFAULT_ERROR_MODE, nil, PWideChar(param), @si, @pif) then
  begin
    sleep(500);
    if PIf.dwProcessId > 0 then
    begin
      AppPID := PIf.dwProcessId;
      CloseHandle(PIf.hProcess);
      CloseHandle(PIf.hThread);
    end;
  end;
  Result := GetLastError;
end;

[lukdelphias]

Zitat:

Zitat von KodeZwerg (Beitrag 1471532)

Meinst Du so etwas?

Delphi-Quellcode:

procedure RunAsExec(hWnd: HWND; aFile: string; aParameters: string);
var
  SEI: TShellExecuteInfo;
begin
  FillChar(SEI, SizeOf(SEI), 0);
  SEI.cbSize       := sizeof(SEI);
  SEI.Wnd          := hWnd;
  SEI.fMask        := SEE_MASK_NOCLOSEPROCESS;
  SEI.lpVerb       := 'runas';
  SEI.lpFile       := PChar(aFile);
  SEI.lpParameters := PChar(aParameters);
  SEI.nShow        := SW_SHOWNORMAL;
  if not ShellExecuteEx(@SEI) then
    RaiseLastOSError;
end;

Beispiel-Aufruf:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  DateiName: string;
  Parameter: string;
begin
  DateiName := 'Programm.exe';
  Parameter := ' ' + 'Benutzername' + ' ' + 'Passwort';
  RunAsExec(Application.Handle, DateiName, Parameter);
end;

Hallo KodeZwerg,

um nochmal darauf einzugehen. Das läuft jetzt teilweise bei mir. Heißt wenn ich den Parameter-String frei lasse funktioniert es. Sobald ich in den Parameter-String Benutzername und Passwort eintrage, öffnet er mir das Programm nicht mehr. Bringt aber auch keinen Fehler....:(

[himitsu]

Jetzt könnte man den ExitCode des Programms noch prüfen.

Zitat:

SEE_MASK_NOCLOSEPROCESS

Und was soll dieses Handle-Leck in dem Code?

SEI.pHandle wird zuückgegeben, aber niemals geschlossen.

[lukdelphias]

Tut mir leid aber ich verstehe nicht so richtig was du meinst Himitsu. Bin leider kein Profi:|

[KodeZwerg]

Moin moin,

also mir war es nicht möglich ohne das UAC dazwischen funkt.
Ich habe sehr viele Winapi methoden ausprobiert die eigentlich an ein gutes Ziel führen sollten, jedoch ohne erfolg.

Ich kann zwar Programme im Kontext eines Users ausführen lassen, aber nicht mit Administrative Rechte.

Mein Workaround greift wieder auf deinen Schnippsel aus Post #0.
(Ich erstelle im temp Ordner eine Batch die dann wiederum Deinen Code ausführt)


In der JCL ist ein gutes Beispiel vorhanden aber es scheitert auch.

[KodeZwerg]

Zitat:

Zitat von Moombas (Beitrag 1471571)

Also ich mache da aktuell so (allerdings in Lazarus): ...dein code...

Fast gleiches habe ich auch erfolglos probiert.
Öffnet dein Lazaurs-Project damit die target.exe tatsächlich im Admin-Modus?
Bei mir mit Rio leider nicht.

//edit
Ps, so schaut der Code bei mir aus:

Delphi-Quellcode:

unit Unit1;

interface

uses
 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
 Dialogs, StdCtrls, ExtCtrls, Buttons;

type
 TForm1 = class(TForm)
   Button1: TButton;
   E1: TLabeledEdit;
   E2: TLabeledEdit;
   E3: TLabeledEdit;
   E4: TLabeledEdit;
   SpeedButton1: TSpeedButton;
   OpenDialog1: TOpenDialog;
   procedure Button1Click(Sender: TObject);
   procedure SpeedButton1Click(Sender: TObject);
 private
   { Private declarations }
 public
   { Public declarations }
 end;

const
    LOGON_WITH_PROFILE  = $00000001;
    LOGON_NETCREDENTIALS_ONLY  = $00000002;

var
 Form1: TForm1;

implementation

{$R *.dfm}

function CreateProcessWithLogonW
                               (
                                 lpUsername, // user"s name
                                 lpDomain, // user"s domain
                                 lpPassword: PWideChar; // user"s password
                                 dwLogonFlags: DWORD; // logon option
                                 lpApplicationName: PWideChar; // executable module name
                                 lpCommandLine: PWideChar; // command-line string
                                 dwCreationFlags: DWORD; // creation flags
                                 lpEnvironment: Pointer; // new environment block
                                 lpCurrentDirectory: PWideChar; // current directory name
                                 const lpStartupInfo: TStartupInfo; // startup information

 

                                 var lpProcessInformation: TProcessInformation //process inf
                                ): Bool; stdcall;external "advapi32.dll";

procedure TForm1.Button1Click(Sender: TObject);

var
  UserName,
  UserDomain,
  Password,
  CmdLine:Pwidechar;
  si: TStartupInfo;
  ProcInfo: TProcessInformation;

begin
 FillChar(si,sizeof(si), 0);
 si.cb:=sizeof(si);
 GetMem(UserName, 512);
 GetMem(UserDomain, 512);
 GetMem(Password, 512);
 GetMem(CmdLine, 512);
 try
   UserName:=StringToWideChar(E2.Text,UserName,512);
   UserDomain:=StringToWideChar(E4.Text,UserDomain,512);
   Password:=StringToWideChar(E3.Text,Password,512);
   cmdline:=StringToWideChar(E1.Text,cmdline,512);
   if not CreateProcessWithLogonW(
                                   UserName,
                                   UserDomain,
                                   Password,
                                   LOGON_WITH_PROFILE,
                                   nil,
                                   CmdLine,
                                   CREATE_DEFAULT_ERROR_MODE,
                                   //CREATE_NEW_CONSOLE or CREATE_NEW_PROCESS_GROUP,
                                   nil, nil, si, ProcInfo) then
   begin
      MessageDlg(SysErrorMessage(GetLastError)+#10#13+inttostr(GetLastError), mtError, [mbOK], 0);
   end else
   begin
     WaitForSingleObject(procinfo.hProcess, INFINITE);
     CloseHandle(procinfo.hProcess);
     CloseHandle(procinfo.hThread);
     ShowMessage("Success !!!");
   end;
 finally
   FreeMem(UserName, 512);
   FreeMem(UserDomain, 512);
   FreeMem(Password, 512);
   FreeMem(CmdLine, 512);
 end;
end;

procedure TForm1.SpeedButton1Click(Sender: TObject);
begin
 if OpenDialog1.Execute then
 begin
   E1.Text:=OpenDialog1.FileName;
 end;
end;

end.

[Moombas]

Er öffnet den Prozess als den angegebenen Benutzer. Wir benötigen das für Remote-Prozesse und läuft. Hab folgendes in meinem Delphi Ordner noch gefunden, was funktionierte, bevor ich auf Lazarus geschwenkt bin:

Delphi-Quellcode:

type
  function  CreateProcessAsLogon(const User, PW, Application, param, CmdLine: WideString): DWORD;
//...
  
  function CreateProcessWithLogonW(lpUsername, lpDomain, lpPassword: LPWSTR; dwLogonFlags: dword; lpApplicationName,
  lpCommandLine: LPWSTR; dwCreationFlags: dword; lpEnvironment: pointer; lpCurrentDirectory: LPWSTR; lpStartupInfo:
  PStartUpInfoW; lpProcessInfo: PProcessInformation): boolean; stdcall; external 'advapi32.dll';

implementation

//Prozess als bestimmten Benutzer starten (Hilfsaufruf)
procedure startasUser(exe, param : string);
var
  User              : WideString;
  PW                : WideString;
  err               : DWORD;
begin
  User := 'Benutzer';
  PW   := 'Passwort';
  err  := CreateProcessAsLogon(User, PW, exe, param, '');
  if err <> 0 then
    ShowMessage(SysErrorMessage(err));
end;  

//Prozess als bestimmten Benutzer starten
function CreateProcessAsLogon(const User, PW, Application, param, CmdLine: WideString): DWORD;
var
  ws   : WideString;
  si  : TStartupInfoW;
  pif : TProcessInformation;
begin
  ZeroMemory(@si, sizeof(si));
  si.cb := sizeof(si);
  si.dwFlags := STARTF_USESHOWWINDOW;
  si.wShowWindow := 1;

  if CmdLine = '' then
    ws := Application
  else
    ws := Application + ' "' + CmdLine + '"';

  SetLastError(0);
  SI.cb  := SizeOf(TStartupInfo);
  if CreateProcessWithLogonW(PWideChar(User), nil, PWideChar(PW), 0, nil, PWideChar(ws), CREATE_DEFAULT_ERROR_MODE, nil, PChar(param), @si, @pif) then
  begin
    sleep(500);
    if PIf.dwProcessId > 0 then
    begin
      AppPID := PIf.dwProcessId;
      CloseHandle(PIf.hProcess);
      CloseHandle(PIf.hThread);
    end;
  end;
  Result := GetLastError;
end;

[KodeZwerg]

Frage an Moombas, all meine Varianten die ich getestet habe sind im Kontext des angegebenen Users und starten auch.
Aber keine Variante startet mir 'ne .exe mit Admin-Rechten wie es ein "Als Administrator ausführen" macht, selbst wenn der User Administrator-Rechte hat.

Auch per Winapi "LogonUser" und darauf folgendem "CreateProcessAsUser" bleibt das Resultat das gleiche, .exe startet ohne Admin-Rechte.


Frage: Öffnet der in Lazarus die .exe mit Admin-Rechte?

Ich kann morgen eine Test.exe hochladen die einem den Status anzeigt mit was für Rechte sie gestartet wurde, wenn das weiterhilft.

[Moombas]

In wie fern das generell "Admin-Rechte" betrifft, weiß ich nicht genau.
Ich öffne damit Programme mit einem Benutzer (diesen gibt es bei mir auf dem lokalen System nicht), der auf den Remotesystemen Administrator ist um Änderungen am dortigen System durchzuführen.
Das funktionierte bisher nur über den oben angegebenen Weg, jedoch einwandfrei.

Mir fällt gerade noch ein: Es kann sein, das du Recht hast. Die Programme müssen bei uns nur unter diesem Benutzer ausgeführt werden, es kann dabei jedoch sein, das dieser (auf dem startenden System) keine Adminrechte hat. Das übersteigt jedoch nun meine Kenntnisse.

[Sherlock]

Ganz streng genommen ist doch alles korrekt, so wie es läuft. Ohne Anwenderinteraktion darf es gar nicht möglich sein, höhere Rechte zu erlangen. Sollte es doch gehen, handelt es sich entweder um ein extrem nachlässig konfiguriertes Windows, einen Bug oder eine Sicherheitslücke. Auf nichts davon darf man als seriöser Entwickler bauen.

Sherlock

[KodeZwerg]

Für Tester die es mal versuchen wollen ist im Anhang eine .exe enthalten die einem den Status anzeigt was für Rechte Sie besitzt.

[lukdelphias]

Hallo,

ich hab es nun selber hinbekommen. Kann jetzt eine EXE mit Adminrechten aufrufen.
Die Methode von Cherry aus diesem Thema https://www.delphipraxis.net/140391-...arameters.html funktioniert bei mir einwandfrei.
Grüße

[KodeZwerg]

Zitat:

Zitat von lukdelphias (Beitrag 1471758)

Hallo,

ich hab es nun selber hinbekommen. Kann jetzt eine EXE mit Adminrechten aufrufen.
Die Methode von Cherry aus diesem Thema https://www.delphipraxis.net/140391-...arameters.html funktioniert bei mir einwandfrei.
Grüße

Das teste ich heute abend mal, so viel anders wird da auch nicht gemacht als wie hier gepostet wurde... hmmm... bin gespannt ob die ElevChk.exe "IsAdministrator" und "IsElevated" gechecked hat.

[KodeZwerg]

An lukdelphias und den Rest der Welt :)

Also ich habe es auch mit der Datei aus Deinem Link nicht geschafft das eine Datei wie "Als Administrator ausführen" geöffnet wird.
Wenn mein Programm mit solchen Rechten gestartet wurde, weitere mit gleichen Rechten zu starten ist kein Problem.

Im Anhang ist eine Weiterentwicklung meines Test-Programmes, abgesehen das die Datei-Größe nochmal stark gesunken ist sind intern mehr features verbaut als vorher.
Nun eignet sich mein Programm automatisch auch alle Privilegien an die zur Verfügung stehen und zwei verschiedene "mach ein Programm auf" funktionen.

"Execute File" nutzt CreateProcess() um sich selbst extern nochmal zu öffnen.
"Open URL" nutzt ShellExecute() um eine URL extern zu öffnen.

//edit
Ps: "Execute" und "Open" RadioButtons steuern was passiert wenn man auf's Bild klickt.
Im Anhang sind nun auch zwei Bilder, das erste zeigt einem den Normal-User,
das zweite zeigt "Als Administrator ausführen" vom Normal-User.