PowerShell: uruchamianie polecenia jako Administrator

Oto dodatek do sugestii shaya Leviego (wystarczy dodać te linie na początku skryptu):

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
}

Powoduje to, że bieżący skrypt jest przekazywany do nowego procesu powershell w trybie administratora (Jeśli bieżący użytkownik ma dostęp do trybu administratora i skrypt nie jest uruchomiony jako Administrator).

Własny skrypt PowerShell

Windows 8.1 / PowerShell 4.0 +

Jedna linijka:)

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

Benjamin Armstrong opublikował doskonały artykuł na temat samonastawnych skryptów PowerShell . Jest kilka drobnych problemów z jego kodem; zmodyfikowana wersja oparta na poprawkach sugerowanych w komentarzu jest poniżej.

Zasadniczo pobiera tożsamość powiązaną z bieżącym procesem, sprawdza, czy jest administratorem, a jeśli nie, tworzy nowy proces PowerShell z uprawnieniami administratora i kończy stary proces.

# 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");

Możesz utworzyć plik wsadowy (*.bat), który uruchamia skrypt powershell z uprawnieniami administracyjnymi po dwukrotnym kliknięciu. W ten sposób nie musisz niczego zmieniać w skrypcie powershell.aby to zrobić, utwórz plik wsadowy o tej samej nazwie i lokalizacji skryptu powershell, a następnie umieść w nim następującą treść:

@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"

To jest to!

Oto Wyjaśnienie:

Zakładając, że skrypt powershell znajduje się w ścieżce C:\Temp\ScriptTest.ps1, plik wsadowy musi mieć ścieżkę C:\Temp\ScriptTest.bat. Gdy ktoś wykona ten plik wsadowy, zostaną wykonane następujące kroki:

1. Cmd wykona polecenie

   powershell -Command "Start-Process powershell \"-ExecutionPolicy Bypass -NoProfile -NoExit -Command `\"cd \`\"C:\Temp\`\"; & \`\".\ScriptTest.ps1\`\"`\"\" -Verb RunAs"
   

2. Otworzy się nowa sesja powershell i zostanie wykonane następujące polecenie:

   Start-Process powershell "-ExecutionPolicy Bypass -NoProfile -NoExit -Command `"cd \`"C:\Temp\`"; & \`".\ScriptTest.ps1\`"`"" -Verb RunAs
   

3. W folderze system32 otworzy się kolejna nowa sesja powershell z uprawnieniami administracyjnymi i zostaną do niej przekazane następujące argumenty:

   -ExecutionPolicy Bypass -NoProfile -NoExit -Command "cd \"C:\Temp\"; & \".\ScriptTest.ps1\""
   

4. Następujące polecenie będzie wykonywane z uprawnieniami administracyjnymi:

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

   Gdy argumenty ścieżki skryptu i nazwy są dwukrotnie cytowane, mogą zawierać spacje lub pojedyncze znaki cudzysłowu (').

5. Bieżący folder zmieni się z system32 na C:\Temp i zostanie uruchomiony skrypt ScriptTest.ps1. Po podaniu parametru -NoExit okno nie zostanie zamknięte, nawet jeśli skrypt powershell wyrzuci jakiś wyjątek.

Możesz łatwo dodać kilka wpisów rejestru, aby uzyskać menu kontekstowe "Uruchom jako administrator" dla plików .ps1:

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"'

(zaktualizowany do prostszego skryptu z @Shay)

Zasadniczo w HKCR:\Microsoft.PowershellScript.1\Shell\runas\command Ustaw domyślną wartość, aby wywołać skrypt za pomocą Powershell.

Użycie

#Requires -RunAsAdministrator

Nie zostało jeszcze powiedziane. Wydaje się, że jest tam dopiero od PowerShell 4.0.

Http://technet.microsoft.com/en-us/library/hh847765.aspx

Gdy parametr switch zostanie dodany do instrukcji requires, określa, że sesja Windows PowerShell, w której jesteś uruchomienie skryptu musi być uruchomione z podwyższonymi uprawnieniami użytkownika (Uruchom jako Administrator).

Gdy skrypt jest uruchamiany jako nie-administrator, pojawia się następujący błąd:

Skrypt 'StackOverflow. ps1' nie może zostać uruchomiony, ponieważ zawiera Instrukcja "# requires " do pracy jako Administrator. Prąd Sesja Windows PowerShell nie jest uruchomiona jako Administrator. Start Windows PowerShell za pomocą Run jako opcja administratora, a następnie spróbuj ponownie uruchomić skrypt.

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

Kod wysłany przez Jonathana i Shay 'a Levy' ego nie zadziałał dla mnie.

Proszę znaleźć kod roboczy poniżej:

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"

Musisz ponownie uruchomić skrypt z uprawnieniami administracyjnymi i sprawdzić, czy skrypt został uruchomiony w tym trybie. Poniżej napisałem skrypt, który posiada dwie funkcje: Doelevatedoperations oraz DoStandardOperations . Powinieneś umieścić swój kod, który wymaga uprawnień administratora w pierwszym, a standardowe operacje w drugim. Zmienna IsRunAsAdmin służy do identyfikacji trybu administratora.

Mój kod jest uproszczonym wyciągiem ze skryptu Microsoft jest ona generowana automatycznie podczas tworzenia pakietu aplikacji dla aplikacji Sklepu Windows.

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
}

C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell gdzie znajduje się Skrót programu PowerShell. To także nadal idzie do innej lokalizacji, aby wywołać rzeczywisty ' exe '(%SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe).

Ponieważ PowerShell jest oparty na profilu użytkownika, gdy chodzi o uprawnienia; jeśli Twoja nazwa użytkownika / profil ma uprawnienia, aby coś zrobić, to pod tym profilem, w PowerShell możesz to zrobić również. Mając to na uwadze, sensowne byłoby, gdybyś zmienił Skrót znajdujący się pod twoim profilem użytkownika, na przykład, C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell.

Kliknij prawym przyciskiem myszy i kliknij Właściwości. Kliknij przycisk "Zaawansowane" pod zakładką "Skrót" znajdującą się tuż pod polem tekstowym "Komentarze" przylegającym do dwóch innych przycisków, odpowiednio "Otwórz lokalizację pliku" i "Zmień ikonę".

Zaznacz pole wyboru "Uruchom jako Administrator". Kliknij OK, następnie Zastosuj i OK. Ponownie kliknij prawym przyciskiem myszy ikonę "Windows PowerShell" znajdującą się w C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell i wybierz " Pin, aby rozpocząć Menu / Pasek Zadań".

Teraz, gdy klikniesz tę ikonę, wywoła ona UAC w celu eskalacji. Po wybraniu "tak "zauważysz, że konsola PowerShell jest otwarta i zostanie oznaczona jako" Administrator " na górze ekranu.

Teraz wystarczy nacisnąć przypisaną kombinację przycisków, a zobaczysz wywołanie UAC, a po wybraniu "tak "zobaczysz konsolę PowerShell i" Administrator " na pasku tytułowym.

Możesz również wymusić otwarcie aplikacji jako administrator. Jeśli masz oczywiście konto administratora.

Znajdź plik, kliknij prawym przyciskiem myszy > Właściwości > Skrót > zaawansowane i sprawdź Uruchom jako Administrator

Następnie kliknij OK.

Kilka odpowiedzi tutaj jest bliskich, ale trochę więcej pracy niż potrzeba.

Utwórz skrót do skryptu i skonfiguruj go tak, aby działał jako Administrator:

• Utwórz skrót.
• Kliknij prawym przyciskiem myszy skrót i otwórz Properties...
• Edytuj Target od <script-path> do powershell <script-path>
• Kliknij Zaawansowane... i włącz Run as administrator

To zachowanie jest projektowane. Istnieje wiele warstw zabezpieczeń, ponieważ Microsoft naprawdę nie chciał, aby pliki. ps1 były najnowszym wirusem e-mail. Niektórzy uważają, że jest to sprzeczne z samym pojęciem automatyzacji zadań, co jest sprawiedliwe. Model bezpieczeństwa Vista+ ma na celu "de-automatyzację" rzeczy, dzięki czemu użytkownik je zgadza.

Jednak podejrzewam, że jeśli uruchomisz sam powershell jako podwyższony, powinien on być w stanie uruchamiać pliki wsadowe bez ponownego żądania hasła, dopóki nie zamkniesz powershell.

Innym prostszym rozwiązaniem jest to, że można również kliknąć prawym przyciskiem myszy na "C:\Windows\System32\cmd.exe "i wybierz" Uruchom jako Administrator", a następnie możesz uruchomić dowolną aplikację jako administrator bez podawania hasła.

Znalazłem na to sposób...

Utwórz plik wsadowy, aby otworzyć skrypt:

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

Następnie utwórz skrót, na pulpicie powiedz (kliknij prawym przyciskiem myszy New -> Skrót ).

Następnie wklej to do lokalizacji:

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

Przy pierwszym otwarciu, będziesz musiał wprowadzić hasło raz. Spowoduje to zapisanie go w Menedżerze poświadczeń systemu Windows.

Po tym powinieneś być w stanie uruchomić jako administrator bez konieczności wpisywania nazwa użytkownika lub hasło administratora.

Problem z odpowiedziami @pgk i @Andrew Odri jest wtedy, gdy masz parametry skryptu, szczególnie gdy są one obowiązkowe. Możesz rozwiązać ten problem używając następującego podejścia:

1. użytkownik kliknie prawym przyciskiem myszy plik . ps1 i wybierze 'Uruchom z PowerShell': poproś go o parametry poprzez pola wejściowe (jest to znacznie lepsza opcja niż użycie atrybutu parametru HelpMessage );
2. użytkownik wykonuje skrypt poprzez konsola: pozwól mu przekazać pożądane parametry i pozwól konsoli zmusić go do poinformowania obowiązkowych.

Oto jaki byłby kod, gdyby skrypt miał ComputerName i Port obowiązkowe parametry:

[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

W odpowiedzi Shay Levy, wykonaj poniższą konfigurację (tylko raz)

1. Uruchom PowerShell z uprawnieniami administratora.
2. Follow Stack Overflow question PowerShell mówi: "wykonywanie skryptów jest wyłączone w tym systemie.".
3. Umieść swój plik. ps1 w dowolnym z folderów PATH, Na przykład. Folder Windows\System32

Po ustawieniu:

1. Naciśnij Wygraj + R
2. Invoke powershell Start-Process powershell -Verb runAs <ps1_file>

TY teraz Można uruchomić wszystko w jednym wierszu poleceń. Powyższe działa na Windows 8 Basic 64-bit.

Najbardziej niezawodnym sposobem, jaki znalazłem, jest owinięcie go w samonapinającą się.plik bat:

@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

The .bat sprawdza, czy jesteś już administratorem i w razie potrzeby uruchamia ponownie skrypt jako Administrator. Zapobiega również otwieraniu zewnętrznych okien " cmd " z czwartym parametrem ShellExecute() ustawionym na 0.

Używam poniższego rozwiązania. Obsługuje stdout / stderr poprzez funkcję transcript i przekazuje kod wyjścia poprawnie procesowi macierzystemu. Musisz dostosować ścieżkę transkryptu/nazwę pliku.

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

Nie widziałem wcześniej swojego sposobu na zrobienie tego, więc wypróbuj to. Jest to o wiele łatwiejsze do naśladowania i ma znacznie mniejszy ślad:

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

Bardzo prosto, jeśli bieżąca sesja Powershell została wywołana z uprawnieniami administratora, znana grupa Sid administratora pojawi się w grupach po pobraniu bieżącej tożsamości. Nawet jeśli konto jest członkiem tej grupy, SID nie pojawi się, chyba że proces został wywołany z podwyższonymi poświadczeniami.

Prawie wszystkie te odpowiedzi są wariacją na temat niezwykle popularnej metody Ben Armstrong firmy Microsoft, Jak to osiągnąć, a jednocześnie nie chwytając, co tak naprawdę robi i jak inaczej naśladować tę samą rutynę.

Aby dodać wynik polecenia do pliku tekstowego zawierającego bieżącą datę, możesz zrobić coś takiego:

$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 }

To jest wyjaśnienie ...

Certyfikat PowerShell RUNAS / SAVECRED "nie jest bezpieczny", wypróbowany i dodaje tożsamość administratora i hasło do pamięci podręcznej poświadczeń i może być używany gdzie indziej UPS!. Jeśli to zrobiłeś, proponuję sprawdzić i usunąć wpis.

Przejrzyj swój program lub kod, ponieważ Zasady firmy Microsoft są takie, że nie możesz mieszać kodu użytkownika i Administratora w tym samym bloku kodu bez UAC (punktu wejścia), aby uruchomić program jako administrator. To byłoby sudo (to samo) na Linuksie.

UAC ma 3 typy, dont ' see, prompt lub punkt wejścia generowany w manifeście programu. Nie podnosi programu, więc jeśli nie ma UAC i potrzebuje admina to się nie powiedzie. UAC jako wymóg administratora jest dobry, uniemożliwia wykonywanie kodu bez uwierzytelniania i zapobiega scenariuszowi mieszanych kodów wykonywanemu na poziomie użytkownika.

Dodaję moje 2 centy. Moja prosta wersja oparta na sesji sieciowej, która działa cały czas do tej pory w Windows 7 / Windows 10. Po co to komplikować?

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

Po prostu dodaj do góry skryptu i będzie działać jako administrator.

Okazało się, że to było zbyt proste. Wszystko, co musisz zrobić, to uruchomić cmd jako administrator. Następnie wpisz explorer.exe i naciśnij enter. To otwiera Eksplorator Windows . Teraz kliknij prawym przyciskiem myszy na skrypcie PowerShell, który chcesz uruchomić, wybierz "Uruchom z PowerShell", który uruchomi go w PowerShell w trybie administratora.

Może poprosić o włączenie Zasady do uruchomienia, wpisz Y i naciśnij enter. Teraz skrypt będzie działał w PowerShell jako administrator. Na wypadek, gdyby wszystko było czerwone, oznacza to, że Twoja polisa nie / align = "left" / Następnie spróbuj ponownie i powinno działać dobrze.