C# Prozess mit einem Admin Konto starten. Wie?
Moin,
Ich habe nun sehr lange im Internet gegoogelt und habe immer noch keine Antwort auf mein Problem gefunden.
Aber nun zu meinem Problem:
Ich habe eine Anwendung geschrieben, die ich gerne als Administrator mit erhöhten Rechten starten möchte(mit Hilfe eines neuen Programms). Mein Problem ist nun, dass Visual Studio mir die ganze Zeit bei dem Programm, welches die Anwendung starten soll, die folgende Fehlermeldung bringt: "System.ComponentModel.Win32Exception: "Der angeforderte Vorgang erfordert erhöhte Rechte"".
Im Internet finde ich leider nicht viel darüber, wie man diese Meldung umgehen kann.
Wie ich mein Prozess starte, der die Admin Rechte benötigt:
SecureString securestring = new SecureString();
string Passwort = "[Admin-Password]";
foreach (char char in Passwort)
{
securestring.AppendChar(char);
}
ProcessStartInfo processstartinfo = new ProcessStartInfo();
processstartinfo.UserName = "[Admin-Account]";
processstartinfo.Password = securestring;
processstartinfo.Verb = "runas";
processstartinfo.FileName = @"[App, die Admin Rechte braucht]";
processstartinfo.UseShellExecute = false;//wird von VS so verlangt
Process.Start(processstartinfo);// Hier taucht die Fehlermeldung auf
Und nun ist meine Frage, wie ich das ganze mache....
Oder bin ich auf ein Problem gestoßen, welches ein Sicherheits-Feature von Windows ist?
Edit: Die Aufgabenplanung unter Windows ist leider auch keine Möglichkeit, da das Programm leider nicht angezeigt wird...
Danke schon mal im Vorhinein!
5 Antworten
Du könntest dir noch das anschauen:
https://www.codeproject.com/articles/105506/getting-elevated-privileges-on-demand-using-c
Vor allem bei den Remarks sind ein paar interessante Anmerkungen:
"ProcessStartInfo.Verb will only have an effect if the process is started by ShellExecuteEx() which requires UseShellExecute = true "
Also nix mit UseShellExecute = false, weil "wird von VS so verlangt". ;)
Das Problem daran ist, dass ich dann nicht mehr das Programm mit dem Admin Account starten kann, sondern der User die Admin-Daten eingeben muss, da dieser keine Admin Rechte besitzt. Aber trotzdem danke für deine Antwort...
Jetzt nochmal an alle: es gibt eine Möglichkeit von Windows ein Programm ohne UAC-Abfrage zu starten. Dafür muss man in die Aufgabenplanung und die Aufgabe einrichten. Danach ist man in der Lage den TaskScheduler anzuweisen, die Aufgabe auszuführen.
Hier steht, Du musst ShellExecute verwenden, da es sonst nicht geht.
Abschmieren kann die Anwendung ja nur, weil Du irgendeine Exception nicht abfängst. Was ist diese Exception?
System.ComponentModel.Win32Exception ist die Exception
Also bei mir funktioniert folgender Code völlig ohne Probleme. Es kommt der Prompt, ob ich die Rechteerweiterung zulassen will, dann startet CMD als Administrator:
var proc = new ProcessStartInfo();
proc.UseShellExecute = true;
proc.WorkingDirectory = @"C:\Windows\System32";
proc.FileName = @"C:\Windows\System32\cmd.exe";
proc.Verb = "runas";
try
{
Process.Start(proc);
Console.WriteLine("Successfully elevated!");
}
catch (Exception)
{
Console.WriteLine("Failed to elevate.");
}
Ich habe deswegen keine catch Methode eingebaut, da wenn eine Exception ausgeworfen wird, startet das Programm leider immer noch nicht mit den Admin Rechten
Die Frage ist doch: Was passiert, wenn Du obigen Code ausführst als User ohne Admin-Rechte? Bekommst Du dann einen Prompt angezeigt oder nicht?
Im zweiten Schritt kann man darüber reden, wie man ggf. die Credentials des Admins übergibt.
Leider habe ich vergessen zu erwähnen, dass die Anwendung, welche zu erst gestartet wird, nicht von einem User mit Admin Rechten gestartet wird.
Ja ich bekomme die Frage von windows gestellt ob ich das Programm als Admin ausführen will....
Hab das Ganze jetzt mal verknüpft mit dem Ansatz den ich hatte aber Windows will es einfach nicht mit Admin Rechten starten, weder die CMD noch mein eigenes Programm. Denke das ist eine Sicherheitslücke....
Das ist sogar das Gegenteil einer Sicherheitslücke! Eine Sicherheitslücke wäre, wenn es einfach so funktionierte.
Sry ich meinte wenn es so funktionieren würde wie wir es wöllten... 😅
Gut. Und wo liegt dann das Problem?
Falls du den Subprozess als Admin starten willst, aber das zu 100% unsichtbar und ohne irgendwelche Meldungen ablaufen soll:
"Is it possible to create process with elevated privileges and bypass the UAC prompt programmatically?"
"No, because the virus you're trying to write would be able to install itself on my computer without my knowledge.
And that's not allowed.
Plus, i don't want my four-year-old installing your crapware."
Das Problem liegt daran, dass ich trotz Admin-Daten, die ich habe, den Prozess nicht starten kann...
Danke, lesen aus deinem Link kann ich auch... ;)
Ok, du hattest oben geschrieben - auf die Frage, was passiert, wenn du den Lösungsvorschlag von ohwehohach ausführst - :
"Ja ich bekomme die Frage von windows gestellt ob ich das Programm als Admin ausführen will...."
Damit funktioniert dann doch alles, oder?
Denn ich kenne diese Frage nur als kleines Fensterchen mit gelber Warnfarbe und da muss nichts mit Benutzername oder Passwort eingegeben werden.
Oder bekommst du einen anderen Prompt?
Wenn er Admin-Rechte hat, dann kommt (zumindest unter Windows 10) sogar nur ein Ja/Nein Prompt mit der Frage, ob das ausgeführt werden soll. So zumindest bei mir im oben durchgeführten Test mit einer Anwendung, die als normaler User läuft.
Ja bekomme ich, wenn der User keine Admin Rechte hat....
Ok, und dann muss nur mit "Ok" oder "Weiter" bestätigt werden und das aufgerufene Programm läuft dann, oder?
Nein der User wird dazu aufgefordert die Admin-Daten einzugeben....
Aha.
Ok, ich habe mich jetzt ein wenig eingelesen in das Thema. So, wie es aussieht, gibt es drei Möglichkeiten:
- Du fügst der Anwendung eine Manifest-Datei hinzu und die ganze Anwedung läuft mit Admin-Rechten. Klingt jetzt für mich nicht so prickelnd, scheint aber eine der von MSDN empfohlenen Methoden zu sein.
- Du gibt in den ProcessStartInfos den UserName und das Password an und stellst UseShellExecute auf false. Dann wird auch das Verb ("runas") ignoriert. Das ist das, was du ursprünglich hattest.
- Du gibt in den ProcessStarTInfos keinen UserName und kein Password an, setzt aber dafür Verb auf "runas" und UseShellExecute auf true. Das scheint das zu sein, wo der Benutzer dann zur Eingabe der Admindaten aufgefordert wird.
Ich bastel mal noch etwas an Variante 2 herum, mal schauen, ob ich da noch etwas finde.
Also, so weit ich das bisher gesehen habe:
- Du lässt dein gesamtes Programm mit Adminrechten laufen, dann ist die Nutzung von Process und ProcessStartInfo kein Problem mittels "runas".
- Du machst es immer noch mit "runas", aber der Benutzer muss sich dann halt als Admin einloggen.
- Du siehst dir mal das hier an, da sieht mir recht vielversprechend aus: https://stackoverflow.com/questions/125341/how-do-you-do-impersonation-in-net
Aber für eine Programmierübung (das stellt es für mich dar, denn in der Praxis würde ich so ein Problem gänzlich anders angehen und auf gar keinen Fall mit irgendwelchen Credentials im Sourcecode) ist mir das dann tatsächlich zu viel Aufwand, mich komplett in das Impersonation-Zeug reinzuknien.
Viel Erfolg.
ok erstmal vielen dank...
Wie würdest du denn das Problem angehen, da es nur mein Ziel ist, dass ich eine Anwendung mit Admin Rechten starten kann?
Ich würde zuerst einmal prüfen, warum die Anwendung mit Admin-Rechten gestartet werden soll.
Wenn es sich um ein reguläres Programm für Benutzer handelt, dann sollten dafür eigentlich überhaupt keine Admin-Rechte notwendig sein. Falls doch, liegt der Fehler irgendwo ziemlich tief in der Architektur des Programms selbst vergraben.
ok weil ich habe solangsam keine Lust mehr mich anzumelden, wenn mein kleiner Bruder an meinem PC Fortnite spielen will.
Lust ihm ein Admin Konto zu geben habe ich ebenfalls nicht....
O_o Und Fortnite braucht Adminrechte zum Laufen?
Falls ja, dann kannst du ihm gleich einen Adminaccount einrichten. Das macht den Bock dann auch nicht mehr fett.
ich versuche es mal weiter vlt klappt es irgendwann ja mal... xD
aber ja theorethisch schon
Hab jetzt eine Möglichkeit gefunden einen Prozess als Administrator auszuführen.
Man muss erst in der Aufgabenplanung die Aufgabe dort einrichten und dann sagen, dass der Prozess mit den höchsten Privilegien ausgeführt werden soll. Danach ist man in der Lage den Prozess über eine Verknüpfung zu starten (sogar ohne UAC Abfrage oder etc.)!
Probier mal
ProcessStartInfo proc = new ProcessStartInfo();
proc.UseShellExecute = true;
proc.WorkingDirectory = Environment.CurrentDirectory;
proc.FileName = Application.ExecutablePath;
proc.Verb = "runas";
try
{
Process.Start(proc);
}
catch
{
// The user refused the elevation.
// Do nothing and return directly ...
return;
}
Application.Exit(); // Quit itself
Hallo, leider habe ich vergessen in die Frage mit rein zuschreiben, dass der User der die Anwendung startet keine Admin-Rechte hat und auch nicht die Anmeldedaten des Admins weiß... Aber trotzdem danke für deine Hilfe
Nein will ich nicht, da ich eine Konsole schreiben will, die mit Admin rechten laufen soll (immer)...
Ich kann sie im Programm verankern, aber der User der das Programm ausführt kennt die nicht....
Ich denke mal mit requestesExecutionLevel level=requireAdministrator im Manifest
https://docs.microsoft.com/en-us/previous-versions/bb756929(v=msdn.10)
Funktioniert leider nicht... Aber danke für die Antwort ;)
Das erfordert Elevated Rights für die aktuell ausgeführte Anwendung. Aber nicht für die, die per ShellExecute gestartet wird (außer die hat das auch im Manifest stehen - dann natürlich schon).
Jo...ich würd halt das ganze Teil als Admin aufrufen.
Ansonsten irgendwas wie (Netzfund)
ProcessStartInfo psi = new
ProcessStartInfo(strDateiPfad);
psi.Arguments = strParameter;
psi.Verb = "runas"
;
psi.WorkingDirectory = System.IO.Path.GetDirectoryName(strDateiPfad);
psi.UseShellExecute = true
;
Process.Start(psi);
Das Problem ist, dass er die Credentials im Code angeben will, weil der User die Admin Credentials nicht weiß. Daher verlagert das nur das Problem.
Ich eigentlich auch, aber das Problem ist trotzdem spannend ;-)
Hab jetzt eine Möglichkeit gefunden den Prozess mit Admin Rechten zu starten.
- Aufgabe bei der Aufgabenplanung einrichten
- mit einer Verknüpfung die Aufgabe starten
Das Problem ist, dass der User der die Anwendung startet leider keine Administrator Rechte hat.
Wenn ich die UseShellExecute auf true setze habe ich zum einen das Problem dass meine Anwendung abschmiert als auch dass der User die Admin-Daten eingeben muss.. Trotzdem Danke für deine Antwort ;)