Passwort automatisch eingeben

[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;

[KodeZwerg]

Zitat von Moombas:

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.