lpEnvironment-Parameter bei CreateProcessWithLogonW

[ringli]

Ich hoffe das ich meine Frage im richtigen Bereich gepostet habe. :gruebel:

Jedenfalls habe ich da mal eine Frage zu CreateProcessWithLogonW.

Delphi-Quellcode:

function CreateProcessWithLogonW(lpUsername, lpDomain, lpPassword: LPCWSTR;
  dwLogonFlags: DWORD; lpApplicationName: LPCWSTR; lpCommandLine: LPWSTR;
  dwCreationFlags: DWORD; lpEnvironment: LPVOID; lpCurrentDirectory: LPCWSTR;
  const lpStartupInfo: STARTUPINFOW; var lpProcessInformation: PROCESS_INFORMATION): BOOL; stdcall;

Und zwar gibt es da ja den Parameter lpEnvironment. Meine Vermutung geht dahin das ich damit beim Start eines Prozesses ein bestimmtes Profil bzw. eine bestimmte Umgebung vorgeben kann. Leider habe ich bis jetzt noch nichts brauchbares gefunden wie ich diesen Parameter verwenden oder gar ermitteln kann.

Kann mir da jemand mal ein bisschen Hilfestellung zur Verwendung & Ermittlung dieses Parameters geben?

[Daniel G]

Das PSDK, dein Freund und Helfer :thumb:

Zitat:

Zitat von Das PSDK

lpEnvironment
[in] Pointer to an environment block for the new process. If this parameter is NULL, the new process uses the environment of the specified user instead of the environment of the calling process.
An environment block consists of a null-terminated block of null-terminated strings. Each string is in the form:

name=value

Because the equal sign is used as a separator, it must not be used in the name of an environment variable.

An environment block can contain Unicode or ANSI characters. If the environment block pointed to by lpEnvironment contains Unicode characters, be sure that dwCreationFlags includes CREATE_UNICODE_ENVIRONMENT.

Note that an ANSI environment block is terminated by two zero bytes: one for the last string, one more to terminate the block. A Unicode environment block is terminated by four zero bytes: two for the last string, two more to terminate the block.

To retrieve a copy of the environment block for a given user, use the CreateEnvironmentBlock function.

Und dann brauchst du das:

CreateEnvironmentBlock

[ringli]

Danke Daniel, das hatte ich in der OH auch schon gelesen. Das Problem ist das ich nicht so wirklich weiss wie ich das verarbeiten kann (absolut miserable Englischkenntnisse), zumal ich mit Pointern sowieso auf Kriegsfuss stehe. :-(

[Daniel G]

Ah, ok. Ich friemel mal im Laufe des Tages was für dich zusammen.

[ringli]

Das wäre wirklich super. Vielen Dank. :-)

[Daniel G]

So... Hab's endlich geschafft. Rein von der Syntax her ist es völlig in Ordnung. Obs auch tatsächlich funktioniert, konnte ich natürlich nicht testen. Wenn du Fragen hast, einfach Posten.

:party:

[ringli]

Vielen Dank für deine Mühe :-D das Problem war die Verwendung des lpEnvironment-Parameters wenn er nicht auf nil gesetzt wird.

Hast du da vielleicht auch noch eine Idee?

[Olli]

Wo liegt denn dein Problem? Entweder du benutzt AnsiString oder du benutzt WideString. Bei WideString mußt du CREATE_UNICODE_ENVIRONMENT bei den Flags setzen.

Dann setzt du deine Variablen zB so wie du willst:

Delphi-Quellcode:

var s : WideString;
// ^--- kann auch AnsiString sein, der Code bleibt gleich!
// Bis auf CREATE_UNICODE_ENVIRONMENT natürlich ;)
begin
  s := 'PATH=C:\Programme';
  s := s + #0; // Aktuelle Variable abschließen
  // Nächste Variable
  s := s + 'BLA=BLUBB';
  s := s + #0; // Aktuelle Variable abschließen
  // Zuguterletzt den Block abschließen ...
  s := s + #0;
end;

Wichtig, am Ende muß immer 2mal #0 stehen!!!

Hoppala, das wichtigste vergessen: Danach übergibst du auf diesen String einen Pointer (genauergesagt auf das erste Zeichen!)

Delphi-Quellcode:

lpEnvironment := Pointer(@s[1]);

vermutlich geht auch

Delphi-Quellcode:

lpEnvironment := @s[1];

(also ohne Pointer-Typecast)

Noch'n Nachtrag: Wenn du eine Kopie eines anderen Environment Blocks machen willst, benutzt du, wie oben schon gesagt, CreateEnvironmentBlock()!

EDIT4: Sorry, hatte einen Bug, natürlich werden die nächsten Variablen an den String angehangen ;)

[ringli]

Ich habe jetzt mal versucht es mit CreateEnvironmentBlock hinzubekommen. Leider erhalte ich beim Versuch die Anwendung zu starten lauter Zugriffsverletzungen. Ich habe das Testprojekt mal angehangen, vielleicht kann mir jemand sagen was ich da falsch mache :gruebel:

[marabu]

Versuche doch erst einmal CreateProcessWithLogonW() überhaupt zum Laufen zu bringen. Achte dabei auf den Typ der Parameter und verwende wo es geht defaults. Wenn der Code dann läuft, dann können wir über deine Vorstellungen zum Environment diskutieren. Ich glaube nämlich nicht, dass der Basiscode schon funktioniert.

Grüße vom marabu

[Daniel G]

Zitat:

Zitat von marabu

Ich glaube nämlich nicht, dass der Basiscode schon funktioniert.

Wessen? ringli's oder meiner?

[marabu]

Hallo Daniel,

alles Gute noch zu deinem Geburtstag.

Ich hatte mich auf den Post direkt vor meinem bezogen. Jetzt habe ich mir auch mal deine Demo runtergeladen und die meldet Fehler 1326 - egal was ich probiere. Also habe ich auch mal in die Quelle geschaut und auch bei deinem Code habe ich den Eindruck, er kann eigentlich nicht funktionieren - abgesehen davon, dass er sich auf meiner Maschine nicht übersetzen lässt. Es fängt damit an, dass auch du das W am Ende des Funktionsnamens missachtest, aber da sind wohl noch mehr Ungereimtheiten.

Grüße vom marabu

[ringli]

Zitat:

Zitat von marabu

Versuche doch erst einmal CreateProcessWithLogonW() überhaupt zum Laufen zu bringen. Achte dabei auf den Typ der Parameter und verwende wo es geht defaults. Wenn der Code dann läuft, dann können wir über deine Vorstellungen zum Environment diskutieren. Ich glaube nämlich nicht, dass der Basiscode schon funktioniert.

Grüße vom marabu

Wenn du LogonUser(), CreateEnvironmentBlock() und DestroyEnvironmentBlock() auskommentierst und bei CreateProcessWithLogonW() das lpEnv durch nil ersetzt funktioniert der Code. Zumindest bei mir. :gruebel:

[EDIT]
Meine Vorstellungen zum Environment gehen dahin, das ein Programm trotz des Ausführens unter Adminrechten die komplette Umgebung des aktuell angemeldeten Benutzers nutzen soll. Im Prinzip dasselbe was der Befehl

Code:

runas /env

von Windows macht. Wenn also jemand einen besseren Weg kennt bin ich für Vorschläge offen. :-)

[EDIT2]
@Daniel G:
Auch von mir noch nachträglich alles Gute zum Geburtstag. :party:

[Olli]

Hi ringli, dann lerne doch bitte Englisch, wenn du es noch nicht kannst. Ein Forum ist nicht dazu da dir die Doku zu übersetzen.

Auf Englisch steht dort:

If the lpEnvironment parameter is NULL, the new process inherits the environment of the calling process.

Auf Deutsch heißt das:

Wenn der lpEnvironment-Parameter NULL ist, erbt der neue Prozeß die Umgebung des aufrufenden Prozesses.

[Olli]

@marabu: Fehler 1326 bedeutet ERROR_LOGON_FAILURE, also daß der Logon fehlschlug. Dies kann zB daran liegen, wenn du einen falschen Benutzernamen und/oder ein falsches Paßwort angibst. Ansonsten passiert das nicht. Außerdem wäre die Domain noch wichtig. Rein von der Semantik gehört die aber eher zum Benutzernamen (DOMAIN\USER), wird in dieser API aber getrennt übergeben.

Hier ein funktionierendes Beispiel (Hinweise habe ich im Code in ROT verfaßt!):

Code:

function CreateEnvironmentBlock(
  var lpEnvironment: LPVOID; [color=red]// War falsch deklariert in deinem Code![/color]
  hToken: HANDLE;
  bInherit: Boolean
  ): Boolean; stdcall; external 'userenv.dll';

CODE WEITGEHEND ENTFERNT. BITTE ANHANG DES ÜBERNÄCHSTEN BEITRAGES BEACHTEN!

[Olli]

Hier noch 2 Funktionen um die Umgebung, von welcher wir den Pointer haben, zu dumpen:

Delphi-Quellcode:

procedure DumpEnvironmentW(lpEnvironment: LPVOID);
var
  Env: PWideChar;
begin
  Env := lpEnvironment;
  Writeln('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');
  while(lstrlenW(Env) > 0) do
  begin
    Writeln(String(WideString(Env)));
    Env := PWideChar(DWORD(Env) + DWORD(lstrlenW(Env) + 1) * DWORD(sizeof(Env^)));
  end;
  Writeln('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');
end;

procedure DumpEnvironmentA(lpEnvironment: LPVOID);
var
  Env: PAnsiChar;
begin
  Env := lpEnvironment;
  Writeln('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');
  while(lstrlenA(Env) > 0) do
  begin
    Writeln(String(Env));
    Env := PAnsiChar(DWORD(Env) + DWORD(lstrlenA(Env) + 1) * DWORD(sizeof(Env^)));
  end;
  Writeln('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');
end;

Wie sofort ersichtlich ist, dient eine für ANSI- und die andere für Unicode-Umgebungen!

EDIT: Anhang entfernt, bitte im nächsten Beitrag den Anhang beachten!

[Olli]

So, habe es jetzt nochmal "mundgerecht" aufgeteilt. Es gibt jetzt eine Wrapperfunktion, der man eine Untermenge der Parameter der ursprünglichen API übergibt. Optional übergibt man auch einen Environment-Block. Das mit dem optional funktioniert natürlich erst ab Delphi 4, wegen dem Default-Parameter.

Delphi-Quellcode:

(******************************************************************************
 Function to wrap around the CreateProcessWithLogon() API
 ******************************************************************************)

function CreateProcessWithLogonWrapper(
  lpUsername: LPCWSTR;
  lpDomain: LPCWSTR;
  lpPassword: LPCWSTR;
  lpApplicationName: LPCWSTR;
  lpCommandLine: LPWSTR;
  dwCreationFlags: DWORD;
  lpEnvironment: LPVOID = nil
  ): Boolean;
var
  sui: STARTUPINFOW;
  pi: PROCESS_INFORMATION;
begin
  Result := False;
  // Fill sui with zeroes
  ZeroMemory(@sui, sizeof(sui));
  // Fill size member
  sui.cb := sizeof(sui);
  // Create process
  if (CreateProcessWithLogonW(
    lpUsername,
    lpDomain, // Domain
    lpPassword,
    LOGON_WITH_PROFILE, // No special options
    lpApplicationName, // Module to execute
    lpCommandLine, // Activates extensions
    dwCreationFlags or CREATE_UNICODE_ENVIRONMENT, // Only these options for now
    lpEnvironment,
    nil, // Use current directory
    sui, // STARTUPINFO
    pi // PROCESS_INFORMATION
    )) then
    Result := True; // Return success
end;

(******************************************************************************
 Function to get a copy of the current environment.
 The returned pointer MUST BE DESTROYED using the DestroyEnvironmentBlock() API.
 ******************************************************************************)

function GetCurrentEnvironmentBlock(): LPVOID;
var
  hToken: HANDLE;
begin
  Result := nil;
  // Open process token of current process
  if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY or TOKEN_DUPLICATE, hToken)) then
  try
    // Create copy of current environment block
    if (not CreateEnvironmentBlock(Result, hToken, True)) then
      Result := nil;
  finally
    CloseHandle(hToken); // Close the token of the current process
  end;
end;

CreateProcessWithLogonWrapper() ist einfach der besagte Wrapper. Die Parameter entsprechen denen der Orginal-API insofern vorhanden.

GetCurrentEnvironmentBlock() gibt den Environment-Block des aktuellen Prozesses zurück. Dieser muß danach mit der API DestroyEnvironmentBlock() wieder zerstört werden. Wird nil zurückgegeben, so war der Aufruf nicht erfolgreich.

Anhang und ausführliche Beschreibung zum Code findet sich hier

[Olli]

Hier noch das Beispiel mit dem eigenen selbsterstellten Environment-Block (Unicode!):

Delphi-Quellcode:

(******************************************************************************
 Hier erstellen wir mal frisch fröhlich ein eigenes Environment, nur um zu
 zeigen wie das geht. Hier wird WideString benutzt, weil wir in unserem Wrapper
 *immer* Unicode-Environments erwarten ...
 ******************************************************************************)
  Writeln('-----------------------------------------------------------------------');
  Writeln('Mit Pfriemelei (eigenes Environment) ...');
  (* WICHTIG: Am Ende muß immer 2x die #0 stehen! Das ist quasi der END-Marker *)
  env:= 'USERNAME=SONSTWAS' + #0 + 'PATH=C:\Blabla\bla\blubb' + #0 + #0;
  lpEnvironment := @env[1];
  if (CreateProcessWithLogonWrapper(
      'ottokar',
      nil,
      'das fruechtchen',
      'cmd.exe',
      '/E:ON /K SET USERNAME',
      CREATE_NEW_CONSOLE,
      lpEnvironment
      )) then
      Writeln('Guck mal an, es funzt ja doch')
    else
      Writeln('FEHLER: Es ist ein Fehler aufgetreten (', GetLastError(), ')');
  // Wait for input
  Writeln('ENTER druecken um fortzufahren ...');
  Readln;

Werde das gleich im Anhang des Beitrags obendrüber ändern ...
Hier sieht man mal den Vorteil von Delphi-Strings ;)

[ringli]

Hi Olli,

erstmal vielen Dank für deine Mühe. Ich werde das nachher mal versuchen zu verstehen. ;-) Aber eine Anmerkung hätte ich noch:

Zitat:

Zitat von Olli

Hi ringli, dann lerne doch bitte Englisch, wenn du es noch nicht kannst. Ein Forum ist nicht dazu da dir die Doku zu übersetzen.

Auf Englisch steht dort:

If the lpEnvironment parameter is NULL, the new process inherits the environment of the calling process.

Auf Deutsch heißt das:

Wenn der lpEnvironment-Parameter NULL ist, erbt der neue Prozeß die Umgebung des aufrufenden Prozesses.

Bei mir steht in der Delphi Hilfe zu CreateProcessWithLogonW aber folgendes:

Code:

lpEnvironment
If this parameter is NULL, the new process uses the environment of the specified user instead of the environment of the calling process.

Wenn ich das mit meinen bescheidenen Englischkenntnissen richtig verstehe wird das Environment des übergebenen Benutzers verwendet. Wenn du mal mit CreateProcessWithLogonW die Eingabeaufforderung startest, und den Befehl "SET" eintippst wirst du sehen das auch wirklich das Environment des übergebenen Benutzers verwendet wird und nicht das des angemeldeten Benutzers.

[Olli]

Zitat:

Zitat von ringli

Bei mir steht in der Delphi Hilfe zu CreateProcessWithLogonW aber folgendes:
[...]

Wenn ich das mit meinen bescheidenen Englischkenntnissen richtig verstehe wird das Environment des übergebenen Benutzers verwendet. Wenn du mal mit CreateProcessWithLogonW die Eingabeaufforderung startest, und den Befehl "SET" eintippst wirst du sehen das auch wirklich das Environment des übergebenen Benutzers verwendet wird und nicht das des angemeldeten Benutzers.

:wall: *autsch* ... da hast du recht. Ich hatte fälschlicherweise bei CreateProcessWithTokenW nachgeschaut.