it-swarm.com.de

PowerShell: Ausführen eines Befehls als Administrator

Sie wissen, wie Sie als Administrator eines Systems arbeiten und einfach mit der rechten Maustaste auf ein Stapelskript klicken und es als Administrator ausführen können, ohne das Administratorkennwort einzugeben?

Ich frage mich, wie man dies mit einem PowerShell-Skript macht. Ich möchte mein Passwort nicht eingeben. Ich möchte nur die Rechtsklick-Methode Als Administrator ausführen nachahmen.

Für alles, was ich bisher gelesen habe, müssen Sie das Administratorkennwort angeben.

207
Chrips

Wenn die aktuelle Konsole nicht angehoben ist und für den Vorgang, den Sie ausführen möchten, erhöhte Berechtigungen erforderlich sind, können Sie Powershell mit der Option "Als Administrator ausführen" starten 

PS> Start-Process powershell -Verb runAs
230
Shay Levy

Hier ist eine Ergänzung zu Shay Levis Vorschlag (fügen Sie einfach diese Zeilen am Anfang eines Skripts hinzu):

If (-NOT ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator"))

{   
$arguments = "& '" + $myinvocation.mycommand.definition + "'"
Start-Process powershell -Verb runAs -ArgumentList $arguments
Break
}

Dies führt dazu, dass das aktuelle Skript im Administratormodus an einen neuen Powershell-Prozess übergeben wird (wenn der aktuelle Benutzer Zugriff auf den Administratormodus hat und das Skript nicht als Administrator gestartet wird).

86
pgk

Selbst anhebendes PowerShell-Skript

Windows 8.1/PowerShell 4.0 +

Eine Linie :)

if (!([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator")) { Start-Process powershell.exe "-NoProfile -ExecutionPolicy Bypass -File `"$PSCommandPath`"" -Verb RunAs; exit }

# Your script here
73
Jayowend

Benjamin Armstrong hat einen ausgezeichneten Artikel über selbsthebende PowerShell-Skripts veröffentlicht . Es gibt ein paar kleinere Probleme mit seinem Code; Eine modifizierte Version basiert auf den im Kommentar vorgeschlagenen Korrekturen.

Grundsätzlich erhält es die Identität, die dem aktuellen Prozess zugeordnet ist, prüft, ob es sich um einen Administrator handelt, und erstellt, falls nicht vorhanden, einen neuen PowerShell-Prozess mit Administratorrechten und beendet den alten Prozess.

# Get the ID and security principal of the current user account
$myWindowsID = [System.Security.Principal.WindowsIdentity]::GetCurrent();
$myWindowsPrincipal = New-Object System.Security.Principal.WindowsPrincipal($myWindowsID);

# Get the security principal for the administrator role
$adminRole = [System.Security.Principal.WindowsBuiltInRole]::Administrator;

# Check to see if we are currently running as an administrator
if ($myWindowsPrincipal.IsInRole($adminRole))
{
    # We are running as an administrator, so change the title and background colour to indicate this
    $Host.UI.RawUI.WindowTitle = $myInvocation.MyCommand.Definition + "(Elevated)";
    $Host.UI.RawUI.BackgroundColor = "DarkBlue";
    Clear-Host;
}
else {
    # We are not running as an administrator, so relaunch as administrator

    # Create a new process object that starts PowerShell
    $newProcess = New-Object System.Diagnostics.ProcessStartInfo "PowerShell";

    # Specify the current script path and name as a parameter with added scope and support for scripts with spaces in it's path
    $newProcess.Arguments = "& '" + $script:MyInvocation.MyCommand.Path + "'"

    # Indicate that the process should be elevated
    $newProcess.Verb = "runas";

    # Start the new process
    [System.Diagnostics.Process]::Start($newProcess);

    # Exit from the current, unelevated, process
    Exit;
}

# Run your code that needs to be elevated here...

Write-Host -NoNewLine "Press any key to continue...";
$null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown");
35
Andrew Odri

Sie können eine Batchdatei (*.bat) erstellen, die Ihr Powershell-Skript mit Administratorrechten ausführt, wenn Sie darauf doppelklicken. Auf diese Weise müssen Sie Sie müssen nichts an Ihrem Powershell-Skript ändern . Erstellen Sie dazu eine Batchdatei mit demselben Namen und Speicherort wie Ihr Powershell-Skript, und fügen Sie den folgenden Inhalt hinzu:

@echo off

set scriptFileName=%~n0
set scriptFolderPath=%~dp0
set powershellScriptFileName=%scriptFileName%.ps1

powershell -Command "Start-Process powershell \"-ExecutionPolicy Bypass -NoProfile -NoExit -Command `\"cd \`\"%scriptFolderPath%\`\"; & \`\".\%powershellScriptFileName%\`\"`\"\" -Verb RunAs"

Das ist es!

Hier ist die Erklärung:

Wenn sich Ihr Powershell-Skript im Pfad C:\Temp\ScriptTest.ps1 befindet, muss Ihre Batchdatei den Pfad C:\Temp\ScriptTest.bat haben. Wenn jemand diese Batchdatei ausführt, werden die folgenden Schritte ausgeführt:

  1. Die cmd führt den Befehl aus

    powershell -Command "Start-Process powershell \"-ExecutionPolicy Bypass -NoProfile -NoExit -Command `\"cd \`\"C:\Temp\`\"; & \`\".\ScriptTest.ps1\`\"`\"\" -Verb RunAs"
    
  2. Eine neue Powershell-Sitzung wird geöffnet und der folgende Befehl wird ausgeführt:

    Start-Process powershell "-ExecutionPolicy Bypass -NoProfile -NoExit -Command `"cd \`"C:\Temp\`"; & \`".\ScriptTest.ps1\`"`"" -Verb RunAs
    
  3. Eine weitere neue Powershell-Sitzung mit Administratorrechten wird im Ordner system32 geöffnet, und die folgenden Argumente werden an ihn übergeben:

    -ExecutionPolicy Bypass -NoProfile -NoExit -Command "cd \"C:\Temp\"; & \".\ScriptTest.ps1\""
    
  4. Der folgende Befehl wird mit Administratorrechten ausgeführt:

    cd "C:\Temp"; & ".\ScriptTest.ps1"
    

    Wenn der Skriptpfad und die Namensargumente in doppelte Anführungszeichen gesetzt werden, können sie Leerzeichen oder einfache Anführungszeichen (') enthalten.

  5. Der aktuelle Ordner wechselt von system32 zu C:\Temp und das Skript ScriptTest.ps1 wird ausgeführt. Sobald der Parameter -NoExit übergeben wurde, wird das Fenster nicht geschlossen, auch wenn Ihr Powershell-Skript eine Ausnahme auslöst.

15

Sie können ganz einfach einige Registrierungseinträge hinzufügen, um ein Kontextmenü "Als Administrator ausführen" für .ps1-Dateien aufzurufen:

New-Item -Path "Registry::HKEY_CLASSES_ROOT\Microsoft.PowershellScript.1\Shell\runas\command" `
-Force -Name '' -Value '"c:\windows\system32\windowspowershell\v1.0\powershell.exe" -noexit "%1"'

(auf ein einfacheres Skript von @Shay aktualisiert)

Grundsätzlich bei HKCR:\Microsoft.PowershellScript.1\Shell\runas\command setzen Sie den Standardwert, um das Skript mit Powershell aufzurufen.

13
manojlds

Verwenden

#Requires -RunAsAdministrator

wurde noch nicht angegeben. Es scheint nur seit PowerShell 4.0 da zu sein.

http://technet.Microsoft.com/en-us/library/hh847765.aspx

Wenn dieser switch-Parameter zu Ihrer required-Anweisung hinzugefügt wird, wird Es gibt an, in welcher Windows PowerShell-Sitzung Sie sich befinden. Das Ausführen des Skripts muss mit erhöhten Benutzerrechten gestartet werden (Als Administrator ausführen).

Für mich scheint dies ein guter Weg zu sein, aber ich bin mir noch nicht sicher, was man vor Ort macht. PowerShell 3.0-Laufzeiten ignorieren dies wahrscheinlich oder geben einen Fehler ab.

Wenn das Skript als Nicht-Administrator ausgeführt wird, wird der folgende Fehler angezeigt:

Das Skript 'StackOverflow.ps1' kann nicht ausgeführt werden, da es eine .__ enthält. "#requires" -Anweisung für die Ausführung als Administrator. Die jetzige Die Windows PowerShell-Sitzung wird nicht als Administrator ausgeführt. Start Windows PowerShell mithilfe der Option Als Administrator ausführen und dann Führen Sie das Skript erneut aus.

+ CategoryInfo          : PermissionDenied: (StackOverflow.ps1:String) [], ParentContainsErrorRecordException
+ FullyQualifiedErrorId : ScriptRequiresElevation
12
akauppi

Der Code von Jonathan und Shay Levy funktionierte nicht für mich.

Den Arbeitscode finden Sie unten:

If (-NOT ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator"))
{   
#"No Administrative rights, it will display a popup window asking user for Admin rights"

$arguments = "& '" + $myinvocation.mycommand.definition + "'"
Start-Process "$psHome\powershell.exe" -Verb runAs -ArgumentList $arguments

break
}
#"After user clicked Yes on the popup, your file will be reopened with Admin rights"
#"Put your code here"
9
John

Sie müssen das Skript mit Administratorrechten erneut ausführen und prüfen, ob das Skript in diesem Modus gestartet wurde. Ich habe unten ein Skript geschrieben, das zwei Funktionen hat: DoElevatedOperations und DoStandardOperations . Sie sollten Ihren Code, für den Administratorrechte erforderlich sind, in den ersten und Standardvorgänge in den zweiten Code einfügen. Die Variable IsRunAsAdmin wird zur Identifizierung des Verwaltungsmodus verwendet.

Mein Code ist ein vereinfachter Auszug aus dem Microsoft-Skript, der automatisch erstellt wird, wenn Sie ein App-Paket für Windows Store-Apps erstellen. 

param(
    [switch]$IsRunAsAdmin = $false
)

# Get our script path
$ScriptPath = (Get-Variable MyInvocation).Value.MyCommand.Path

#
# Launches an elevated process running the current script to perform tasks
# that require administrative privileges.  This function waits until the
# elevated process terminates.
#
function LaunchElevated
{
    # Set up command line arguments to the elevated process
    $RelaunchArgs = '-ExecutionPolicy Unrestricted -file "' + $ScriptPath + '" -IsRunAsAdmin'

    # Launch the process and wait for it to finish
    try
    {
        $AdminProcess = Start-Process "$PsHome\PowerShell.exe" -Verb RunAs -ArgumentList $RelaunchArgs -PassThru
    }
    catch
    {
        $Error[0] # Dump details about the last error
        exit 1
    }

    # Wait until the elevated process terminates
    while (!($AdminProcess.HasExited))
    {
        Start-Sleep -Seconds 2
    }
}

function DoElevatedOperations
{
    Write-Host "Do elevated operations"
}

function DoStandardOperations
{
    Write-Host "Do standard operations"

    LaunchElevated
}


#
# Main script entry point
#

if ($IsRunAsAdmin)
{
    DoElevatedOperations
}
else
{
    DoStandardOperations
}
8
Rython

In C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell befindet sich die Verknüpfung von PowerShell. Es geht auch noch an einen anderen Ort, um die eigentliche 'exe' (%SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe) aufzurufen.

Da PowerShell von Benutzerprofilen gesteuert wird, wenn Berechtigungen betroffen sind. Wenn Ihr Benutzername/Profil die Berechtigung hat, etwas zu tun, können Sie dies in PowerShell im Allgemeinen auch unter diesem Profil tun. Abgesehen davon ist es sinnvoll, die Verknüpfung unter Ihrem Benutzerprofil zu ändern, z. B. C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell.

Klicken Sie mit der rechten Maustaste und klicken Sie auf Eigenschaften. Klicken Sie auf die Schaltfläche "Erweitert" unter der Registerkarte "Verknüpfung", die sich direkt unter dem Textfeld "Kommentare" rechts neben den beiden anderen Schaltflächen "Dateispeicherort öffnen" und "Symbol ändern" befindet.

Aktivieren Sie das Kontrollkästchen "Als Administrator ausführen". Klicken OK, dann Apply und OK. Klicken Sie erneut mit der rechten Maustaste auf das Symbol 'Windows PowerShell' in C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell und wählen Sie "An Startmenü/Taskleiste anheften".

Wenn Sie jetzt auf dieses Symbol klicken, wird UAC zur Eskalation aufgerufen. Nach Auswahl von "JA" wird die PowerShell-Konsole geöffnet und oben auf dem Bildschirm mit "Administrator" gekennzeichnet.

Um noch einen Schritt weiter zu gehen ... Sie können mit der rechten Maustaste auf dieselbe Symbolverknüpfung in Ihrem Profilverzeichnis von Windows PowerShell klicken und eine Tastenkombination zuweisen, die genau dasselbe bewirkt, als hätten Sie auf das kürzlich hinzugefügte Symbol geklickt. Also, wo es heißt "Shortcut Key" in einer Tastaturtaste/Tastenkombination wie: Ctrl + Alt + PP (für PowerShell) . Klicken Apply und OK.

Jetzt müssen Sie nur noch die von Ihnen zugewiesene Tastenkombination drücken und die Benutzerkontensteuerung wird aufgerufen. Nach Auswahl von "JA" wird eine PowerShell-Konsole angezeigt und in der Titelleiste "Administrator" angezeigt.

4
ittechandres

Sie können auch das Öffnen der Anwendung als Administrator erzwingen. Wenn Sie einen Administrator-Account haben.

 enter image description here

Suchen Sie die Datei, klicken Sie mit der rechten Maustaste auf> Eigenschaften> Verknüpfung> Erweitert, und aktivieren Sie die Option Als Administrator ausführen

Klicken Sie dann auf OK.

3
raphie

Meine 2 Cent hinzufügen. Meine einfache Version basiert auf einer Netzsitzung, die bisher unter Windows 7/Windows 10 immer funktioniert. Warum zu kompliziert?

if (!(net session)) {$path =  "& '" + $myinvocation.mycommand.definition + "'" ; Start-Process powershell -Verb runAs -ArgumentList $path ; exit}

füge einfach oben im Skript hinzu und es wird als Administrator ausgeführt.

3
Rakha

Einige der Antworten hier sind nah, aber etwas mehr Arbeit als nötig.

Erstellen Sie eine Verknüpfung zu Ihrem Skript und konfigurieren Sie es auf "Als Administrator ausführen":

  • Erstellen Sie die Verknüpfung.
  • Klicken Sie mit der rechten Maustaste auf die Verknüpfung und öffnen Sie Properties....
  • Target von <script-path> zu powershell <script-path> bearbeiten
  • Klicken Advanced... und Run as administrator aktivieren
3
Disillusioned

Dieses Verhalten ist beabsichtigt. Es gibt mehrere Sicherheitsebenen, da Microsoft wirklich nicht wollte, dass .ps1-Dateien der neueste E-Mail-Virus sind. Einige Leute finden, dass dies der Vorstellung der Automatisierung von Aufgaben widerspricht, was fair ist. Das Vista + -Sicherheitsmodell besteht darin, die Dinge zu "de-automatisieren", damit der Benutzer sie akzeptiert.

Ich vermute jedoch, wenn Sie Powershell selbst als erhöht starten, sollte es in der Lage sein, Batchdateien auszuführen, ohne das Kennwort erneut anzufordern, bis Sie Powershell schließen.

2
VoidStar

Ich verwende die Lösung unten. Er verarbeitet stdout/stderr über die Transkriptionsfunktion und übergibt den Exit-Code korrekt an den übergeordneten Prozess. Sie müssen den Transkriptpfad/Dateinamen anpassen.

If (-NOT ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator"))
{ 
  echo "* Respawning PowerShell child process with elevated privileges"
  $pinfo = New-Object System.Diagnostics.ProcessStartInfo
  $pinfo.FileName = "powershell"
  $pinfo.Arguments = "& '" + $myinvocation.mycommand.definition + "'"
  $pinfo.Verb = "RunAs"
  $pinfo.RedirectStandardError = $false
  $pinfo.RedirectStandardOutput = $false
  $pinfo.UseShellExecute = $true
  $p = New-Object System.Diagnostics.Process
  $p.StartInfo = $pinfo
  $p.Start() | Out-Null
  $p.WaitForExit()
  echo "* Child process finished"
  type "C:/jenkins/transcript.txt"
  Remove-Item "C:/jenkins/transcript.txt"
  Exit $p.ExitCode
} Else {
  echo "Child process starting with admin privileges"
  Start-Transcript -Path "C:/jenkins/transcript.txt"
}

# Rest of your script goes here, it will be executed with elevated privileges
2

Das Problem mit den Antworten in @pgk und @Andrew Odri ist, wenn Sie Skriptparameter haben, insbesondere wenn diese obligatorisch sind. Sie können dieses Problem auf folgende Weise lösen:

  1. Der Benutzer klickt mit der rechten Maustaste auf die Datei .ps1 und wählt 'Mit PowerShell ausführen' aus: Fragen Sie ihn über die Eingabefelder nach den Parametern (dies ist eine viel bessere Option als das Parameterattribut HelpMessage).
  2. Der Benutzer führt das Skript über die Konsole aus: Erlauben Sie ihm, die gewünschten Parameter zu übergeben, und lassen Sie die Konsole die obligatorischen informieren.

So würde der Code aussehen, wenn das Skript die obligatorischen Parameter ComputerName und Port hätte:

[CmdletBinding(DefaultParametersetName='RunWithPowerShellContextMenu')]
param (
    [parameter(ParameterSetName='CallFromCommandLine')]
    [switch] $CallFromCommandLine,

    [parameter(Mandatory=$false, ParameterSetName='RunWithPowerShellContextMenu')]
    [parameter(Mandatory=$true, ParameterSetName='CallFromCommandLine')]
    [string] $ComputerName,

    [parameter(Mandatory=$false, ParameterSetName='RunWithPowerShellContextMenu')]
    [parameter(Mandatory=$true, ParameterSetName='CallFromCommandLine')]
    [UInt16] $Port
)

function Assert-AdministrativePrivileges([bool] $CalledFromRunWithPowerShellMenu)
{
    $isAdministrator = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)

    if ($isAdministrator)
    {
        if (!$CalledFromRunWithPowerShellMenu -and !$CallFromCommandLine)
        {
            # Must call itself asking for obligatory parameters
            & "$PSCommandPath" @script:PSBoundParameters -CallFromCommandLine
            Exit
        }
    }
    else
    {
        if (!$CalledFromRunWithPowerShellMenu -and !$CallFromCommandLine)
        {
            $serializedParams = [Management.Automation.PSSerializer]::Serialize($script:PSBoundParameters)

            $scriptStr = @"
                `$serializedParams = '$($serializedParams -replace "'", "''")'

                `$params = [Management.Automation.PSSerializer]::Deserialize(`$serializedParams)

                & "$PSCommandPath" @params -CallFromCommandLine
"@

            $scriptBytes = [System.Text.Encoding]::Unicode.GetBytes($scriptStr)
            $encodedCommand = [Convert]::ToBase64String($scriptBytes)

            # If this script is called from another one, the execution flow must wait for this script to finish.
            Start-Process -FilePath 'powershell' -ArgumentList "-ExecutionPolicy Bypass -NoProfile -EncodedCommand $encodedCommand" -Verb 'RunAs' -Wait
        }
        else
        {
            # When you use the "Run with PowerShell" feature, the Windows PowerShell console window appears only briefly.
            # The NoExit option makes the window stay visible, so the user can see the script result.
            Start-Process -FilePath 'powershell' -ArgumentList "-ExecutionPolicy Bypass -NoProfile -NoExit -File ""$PSCommandPath""" -Verb 'RunAs'
        }

        Exit
    }
}

function Get-UserParameters()
{
    [string] $script:ComputerName = [Microsoft.VisualBasic.Interaction]::InputBox('Enter a computer name:', 'Testing Network Connection')

    if ($script:ComputerName -eq '')
    {
        throw 'The computer name is required.'
    }

    [string] $inputPort = [Microsoft.VisualBasic.Interaction]::InputBox('Enter a TCP port:', 'Testing Network Connection')

    if ($inputPort -ne '')
    {
        if (-not [UInt16]::TryParse($inputPort, [ref]$script:Port))
        {
            throw "The value '$inputPort' is invalid for a port number."
        }
    }
    else
    {
        throw 'The TCP port is required.'
    }
}

# $MyInvocation.Line is empty in the second script execution, when a new powershell session
# is started for this script via Start-Process with the -File option.
$calledFromRunWithPowerShellMenu = $MyInvocation.Line -eq '' -or $MyInvocation.Line.StartsWith('if((Get-ExecutionPolicy')

Assert-AdministrativePrivileges $calledFromRunWithPowerShellMenu

# Necessary for InputBox
[System.Reflection.Assembly]::Load('Microsoft.VisualBasic, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a') | Out-Null

if ($calledFromRunWithPowerShellMenu)
{
    Get-UserParameters
}

# ... script code
Test-NetConnection -ComputerName $ComputerName -Port $Port
2

Hier ist ein selbstaufrufendes Snippet für Powershell-Skripte , das das Arbeitsverzeichnis beibehält:

if (!([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
    Start-Process PowerShell -Verb RunAs "-NoProfile -ExecutionPolicy Bypass -Command `"cd '$pwd'; & '$PSCommandPath';`"";
    exit;
}

# Your script here

Das Beibehalten des Arbeitsverzeichnisses ist wichtig für Skripts, die pfadbezogene Vorgänge ausführen. Bei fast allen anderen Antworten bleibt dieser Pfad nicht erhalten, was zu unerwarteten Fehlern im Rest des Skripts führen kann.

Wenn Sie lieber kein selbstaufrufendes Skript/Snippet verwenden und stattdessen einfach ein Skript als Administrator starten möchten (z. B. über das Explorer-Kontextmenü), finden Sie meine andere Antwort hier: https : //stackoverflow.com/a/57033941/2441655

2
Venryx

Ich habe einen Weg gefunden, dies zu tun ...

Erstellen Sie eine Batchdatei, um Ihr Skript zu öffnen:

@echo off
START "" "C:\Scripts\ScriptName.ps1"

Dann erstellen Sie eine Verknüpfung, sagen Sie auf Ihrem Desktop (Rechtsklick Neu -> Verknüpfung ).

Dann fügen Sie diese in den Ort ein:

C:\Windows\System32\runas.exe /savecred /user:*DOMAIN*\*ADMIN USERNAME* C:\Scripts\BatchFileName.bat

Beim ersten Öffnen müssen Sie Ihr Passwort einmal eingeben. Dadurch wird es im Windows-Anmeldeinformations-Manager gespeichert.

Danach sollten Sie als Administrator ausgeführt werden können, ohne einen Benutzernamen oder ein Kennwort für den Administrator eingeben zu müssen.

2
Jack

Eine andere einfachere Lösung besteht darin, dass Sie auch mit der rechten Maustaste auf "C:\Windows\System32\cmd.exe" klicken und "Als Administrator ausführen" wählen. Anschließend können Sie jede App als Administrator ausführen, ohne ein Kennwort anzugeben.

2
DupDup

Die zuverlässigste Methode, die ich gefunden habe, besteht darin, sie in eine selbsterhebende .bat-Datei zu packen:

@echo off
NET SESSION 1>NUL 2>NUL
IF %ERRORLEVEL% EQU 0 GOTO ADMINTASKS
CD %~dp0
MSHTA "javascript: var Shell = new ActiveXObject('Shell.application'); Shell.ShellExecute('%~nx0', '', '', 'runas', 0); close();"
EXIT

:ADMINTASKS

powershell -file "c:\users\joecoder\scripts\admin_tasks.ps1"

EXIT

Die .bat prüft, ob Sie bereits Administrator sind, und führt das Skript bei Bedarf als Administrator erneut aus. Außerdem wird verhindert, dass fremde "cmd" -Fenster geöffnet werden, wenn der vierte Parameter von ShellExecute() auf 0 eingestellt ist.

1
Joe Coder

Befolgen Sie neben der Antwort von Shay Levy das folgende Setup (nur einmal)

  1. Starten Sie eine PowerShell mit Administratorrechten.
  2. Befolgen Sie die Frage zum Stapelüberlauf PowerShell meldet, dass die Ausführung von Skripten auf diesem System deaktiviert ist..
  3. Legen Sie Ihre .ps1-Datei beispielsweise in einem der Ordner PATH ab. Windows\System32-Ordner

Nach dem Setup:

  1. Drücken Sie Win + R
  2. powershell Start-Process powershell -Verb runAs <ps1_file> aufrufen

Sie können jetzt alles in nur einer Befehlszeile ausführen. Das Obige funktioniert unter Windows 8 Basic 64-Bit.

1
Lee Chee Kiam

Ich habe noch nie meine eigene Art und Weise gesehen, also probieren Sie es aus. Es ist viel einfacher zu befolgen und hat einen wesentlich geringeren Platzbedarf:

if([bool]([Security.Principal.WindowsIdentity]::GetCurrent()).Groups -notcontains "S-1-5-32-544") {
    Start Powershell -ArgumentList "& '$MyInvocation.MyCommand.Path'" -Verb runas
    }

Wenn die aktuelle Powershell-Sitzung mit Administratorrechten aufgerufen wurde, wird die bekannte SID der Administratorgruppe in den Gruppen angezeigt, wenn Sie die aktuelle Identität abrufen. Selbst wenn das Konto Mitglied dieser Gruppe ist, wird die SID nur angezeigt, wenn der Prozess mit erhöhten Anmeldeinformationen aufgerufen wurde.

Nahezu alle diese Antworten sind eine Variation von Microsofts Ben Armstrong, einer äußerst beliebten Methode, um dies zu erreichen, ohne wirklich zu verstehen, was es tatsächlich tut und wie man dieselbe Routine nachahmen kann.

0
Rincewind

Um die Ausgabe des Befehls an einen Textdateinamen anzuhängen, der das aktuelle Datum enthält, können Sie Folgendes tun:

$winupdfile = 'Windows-Update-' + $(get-date -f MM-dd-yyyy) + '.txt'
if (!([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator")) { Start-Process powershell.exe "-NoProfile -ExecutionPolicy Bypass -Command `"Get-WUInstall -AcceptAll | Out-File $env:USERPROFILE\$winupdfile -Append`"" -Verb RunAs; exit } else { Start-Process powershell.exe "-NoProfile -ExecutionPolicy Bypass -Command `"Get-WUInstall -AcceptAll | Out-File $env:USERPROFILE\$winupdfile -Append`""; exit }
0
Travis R.

Dies ist eine Klarstellung ...

Der Powershell-RUNAS/SAVECRED-Berechtigungsnachweis "ist nicht sicher" hat es versucht, fügt die Administrator-Identität und das Kennwort zum Berechtigungsnachweiscache hinzu und kann an anderer Stelle verwendet werden. Wenn Sie dies getan haben, schlage ich vor, den Eintrag zu überprüfen und zu entfernen.

Überprüfen Sie Ihr Programm oder Ihren Code, da die Microsoft-Richtlinie lautet, dass Sie nicht Benutzer- und Verwaltungscode in demselben Code-Blob ohne die Benutzerkontensteuerung (den Einstiegspunkt) gemischt haben dürfen, um das Programm als Administrator auszuführen. Dies wäre Sudo (das gleiche) unter Linux.

Die Benutzerkontensteuerung verfügt über 3 Typen, dont'see, eine Eingabeaufforderung oder einen Einstiegspunkt, der im Manifest des Programms generiert wird. Es erhöht das Programm nicht, wenn also keine Benutzerkontensteuerung vorhanden ist und ein Administrator benötigt wird, schlägt das Programm fehl. Die UAC ist zwar als Administratoranforderung gut, verhindert jedoch die Codeausführung ohne Authentifizierung und verhindert, dass das Szenario mit gemischten Codes auf Benutzerebene ausgeführt wird.

0
mark deacon