Ausführen eines Befehls als Administrator mit PowerShell?

Question

Wenn Sie der administrative Benutzer eines Systems sind, können Sie mit der rechten Maustaste auf ein Batch-Skript klicken und es als Administrator ausführen, ohne das Administratorkennwort eingeben zu müssen.

Ich frage mich, wie ich dies mit einem PowerShell-Skript erreichen kann. Ich möchte mein Kennwort nicht eingeben müssen; ich möchte nur den Rechtsklick nachahmen Als Administrator ausführen Methode.

Nach allem, was ich bisher gelesen habe, müssen Sie das Administratorkennwort angeben.

Answer 1

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

Erstellen Sie eine Batch-Datei, um Ihr Skript zu öffnen:

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

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

Fügen Sie diese dann an der entsprechenden Stelle 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. Dann wird es im Windows-Anmeldeinformationsmanager gespeichert.

Danach sollten Sie in der Lage sein, als Administrator zu arbeiten, ohne einen Benutzernamen oder ein Passwort eingeben zu müssen.

Answer 2

C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell ist der Ort, an dem die Abkürzung von PowerShell befindet. Auch sie geht an einen anderen Ort, um die eigentliche "exe" aufzurufen ( %SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe ).

Da PowerShell in Bezug auf Berechtigungen benutzerprofilgesteuert ist, wenn Ihr Benutzername/Profil die Berechtigungen hat, etwas zu tun, dann können Sie es in PowerShell unter diesem Profil im Allgemeinen auch tun. Daher wäre es sinnvoll, wenn Sie die Verknüpfung unter Ihrem Benutzerprofil ändern würden, C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell .

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

Aktivieren Sie das Kontrollkästchen "Als Administrator ausführen". Klicken Sie auf OK dann Apply y OK . Klicken Sie erneut mit der rechten Maustaste auf das Symbol mit der Bezeichnung "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 nun auf dieses Symbol klicken, wird das Programm UAC für die Eskalation. Nachdem Sie "JA" ausgewählt haben, 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 Windows PowerShell-Profil klicken und eine Tastaturverknüpfung zuweisen, die genau dasselbe tut, als ob Sie auf das kürzlich hinzugefügte Symbol klicken würden. Geben Sie also an der Stelle, an der "Shortcut Key" steht, eine Tastenkombination ein, z. B: Ctrl + Alt + P P (für PowerShell) . Klicken Sie auf Apply y OK .

Jetzt müssen Sie nur noch die von Ihnen zugewiesene Tastenkombination drücken, und Sie werden sehen, dass die UAC aufgerufen wird. Nachdem Sie "JA" ausgewählt haben, wird eine PowerShell-Konsole angezeigt und in der Titelleiste erscheint "Administrator".

Answer 3

Ich verwende die unten stehende Lösung. Sie behandelt stdout/stderr über die Transkriptfunktion und übergibt den Exit-Code korrekt an den übergeordneten Prozess. Sie müssen den Pfad/Dateinamen des Transkripts 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

Answer 4

Das Problem mit dem @pgk y @Andrew Odri Die Antworten des Programms sind Skriptparameter, insbesondere wenn sie obligatorisch sind. Sie können dieses Problem mit dem folgenden Ansatz lösen:

1. Der Benutzer klickt mit der rechten Maustaste auf die .ps1 Datei und wählt 'Run with PowerShell': fragt ihn über Eingabefelder nach den Parametern (dies ist eine viel bessere Option als die Verwendung der HelpMessage Parameter-Attribut);
2. Der Benutzer führt das Skript über die Konsole aus: Er kann die gewünschten Parameter übergeben und die Konsole zwingt ihn, die obligatorischen Parameter anzugeben.

So würde der Code aussehen, wenn das Skript die ComputerName y Hafen obligatorische Parameter:

[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

Answer 5

Ich habe dies vor kurzem benötigt, um eine Umgebung auf Ansible zu erstellen. Ich sage sofort - die Entscheidung ist nicht meine, aber ich erinnere mich nicht, wo ich es bekam. Sieht so aus:

powershell.exe -NoProfile -ExecutionPolicy Unrestricted -Command "& {Start-Process PowerShell -ArgumentList '-NoProfile -ExecutionPolicy Unrestricted -Command Get-Service -Name ssh-agent | Set-Service -StartupType Automatic' -Verb RunAs}";

Dieses Beispiel aktiviert den Autostart von ssh-agent. Der erforderliche Befehl wird nach -Command angegeben. Das einzige Problem ist, dass der Start auf einer neuen PS-Instanz erfolgt, aber bisher ist dies der einzige Weg, den ich kenne, um den Befehl als Administrator ohne zusätzliche Schritte auszuführen.