PowerShell kullanarak bir komutu Yönetici olarak mı çalıştırıyorsunuz?

Bir sistemin yönetici kullanıcısıysanız ve bir toplu komut dosyasını sağ tıklatıp yönetici parolasını girmeden Yönetici olarak çalıştırabilirsiniz.

Bunu bir PowerShell betiğiyle nasıl yapacağımı merak ediyorum. Parolamı girmek istemiyorum; Yalnızca Yönetici Olarak Çalıştır yöntemini sağ tıklatıp taklit etmek istiyorum .

Şimdiye kadar okuduğum her şey için yönetici şifresini girmeniz gerekiyor.

Geçerli konsol yükseltilmemişse ve yapmaya çalıştığınız işlem yükseltilmiş ayrıcalıklar gerektiriyorsa, powershell Run as administratorseçeneğini şu seçenekle başlatabilirsiniz :

PS> Start-Process powershell -Verb runAs

İşte Shay Levi'nin önerisine bir ek (sadece bir komut dosyasının başına bu satırları ekleyin):

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
}

Bu, geçerli komut dosyasının Yönetici modunda yeni bir powershell işlemine geçirilmesine neden olur (geçerli Kullanıcının Yönetici moduna erişimi varsa ve komut dosyası Yönetici olarak başlatılmadıysa).

Kendiliğinden yükselen PowerShell betiği

Windows 8.1 / PowerShell 4.0 +

Tek çizgi :)

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 kendi kendine yükselen PowerShell senaryoları hakkında mükemmel bir makale yayınladı . Koduyla ilgili birkaç ufak sorun var; yorumda önerilen düzeltmelere dayanan değiştirilmiş bir sürüm aşağıdadır.

Temel olarak geçerli işlemle ilişkili kimliği alır, yönetici olup olmadığını kontrol eder ve değilse yönetici ayrıcalıklarıyla yeni bir PowerShell işlemi oluşturur ve eski işlemi sonlandırır.

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

*.batPowershell betiğinizi çift tıklattığınızda yönetimsel ayrıcalıklarla çalıştıran bir toplu iş dosyası ( ) oluşturabilirsiniz. Bu şekilde, powershell betiğinizdeki hiçbir şeyi değiştirmeniz gerekmez . Bunu yapmak için, powershell betiğinizle aynı ad ve konuma sahip bir toplu iş dosyası oluşturun ve ardından aşağıdaki içeriği içine yerleştirin:

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

Bu kadar!

İşte açıklama:

Powershell betiğinizin yolda olduğunu varsayarsak, C:\Temp\ScriptTest.ps1toplu iş dosyanızın yola sahip olması gerekir C:\Temp\ScriptTest.bat. Birisi bu toplu iş dosyasını yürüttüğünde, aşağıdaki adımlar gerçekleşir:

1. Cmd komutu yürütür

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

2. Yeni bir powershell oturumu açılır ve aşağıdaki komut yürütülür:

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

3. system32Klasörde yönetici ayrıcalıklarına sahip başka bir powershell oturumu açılacak ve bu dosyaya aşağıdaki bağımsız değişkenler aktarılacak:

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

4. Aşağıdaki komut yönetici ayrıcalıklarıyla yürütülecektir:

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

   Komut dosyası yolu ve ad bağımsız değişkenleri çift tırnak içine alındığında, boşluk veya tek tırnak işareti karakterleri ( ') içerebilir .

5. Geçerli klasör değişecektir system32için C:\Tempve komut ScriptTest.ps1çalıştırılacaktır. Parametre -NoExitgeçildikten sonra, powershell komut dosyanız bir istisna atsa bile pencere kapatılmaz.

İşte çalışma dizinini koruyan Powershell komut dosyaları için kendi kendine yükselen bir snippet :

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

Çalışma dizinini korumak, yola bağlı işlemler gerçekleştiren komut dosyaları için önemlidir. Diğer yanıtların neredeyse tamamı bu yolu korumaz, bu da komut dosyasının geri kalanında beklenmedik hatalara neden olabilir.

Kendi kendine yükselen bir komut dosyası / snippet kullanmak istemiyorsanız ve bunun yerine bir komut dosyasını yönetici olarak başlatmanın kolay bir yolunu istiyorsanız (örneğin, Explorer bağlam menüsünden), diğer cevabımı buradan görebilirsiniz: https: // stackoverflow com / a / 57033941/2441655

kullanma

#Requires -RunAsAdministrator

henüz ifade edilmedi. Sadece PowerShell 4.0'dan beri var gibi görünüyor.

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

Bu switch parametresi gerektiren ifadenize eklendiğinde, komut dosyasını çalıştırdığınız Windows PowerShell oturumunun yükseltilmiş kullanıcı haklarıyla (Yönetici olarak çalıştır) başlatılması gerektiğini belirtir.

Bana göre bu, bunun için iyi bir yol gibi görünüyor, ancak henüz saha deneyiminden emin değilim. PowerShell 3.0 çalışma zamanları muhtemelen bunu yoksayar veya daha da kötüsü bir hata verir.

Komut dosyası yönetici olmayan bir kullanıcı olarak çalıştırıldığında, aşağıdaki hata verilir:

Yönetici olarak çalıştırmak için bir "#requires" ifadesi içerdiğinden 'StackOverflow.ps1' komut dosyası çalıştırılamıyor. Geçerli Windows PowerShell oturumu Yönetici olarak çalışmıyor. Yönetici Olarak Çalıştır seçeneğini kullanarak Windows PowerShell'i başlatın ve komut dosyasını yeniden çalıştırmayı deneyin.

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

.ps1Dosyalar için "Yönetici olarak çalıştır" içerik menüsünü almak üzere bazı kayıt defteri girdilerini kolayca ekleyebilirsiniz :

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

(@Shay'dan daha basit bir komut dosyasına güncellendi)

Temelde HKCR:\Microsoft.PowershellScript.1\Shell\runas\commandPowershell kullanarak komut dosyasını çağırmak için varsayılan değeri ayarlayın.

Jonathan ve Shay Levy tarafından gönderilen kod benim için çalışmadı.

Lütfen aşağıdaki çalışma kodunu bulun:

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"

Komut dosyasını yönetimsel ayrıcalıklarla yeniden çalıştırmanız ve komut dosyasının bu modda başlatılıp başlatılmadığını kontrol etmeniz gerekir. Aşağıda iki işlevi olan bir komut dosyası yazdım: DoElevatedOperations ve DoStandardOperations . Yönetici hakları gerektiren kodunuzu birincisine, standart işlemleri ikincisine yerleştirmelisiniz. IsRunAsAdmin değişken yönetici modunu tanımlamak için kullanılır.

Kodum, Windows Mağazası uygulamaları için bir uygulama paketi oluşturduğunuzda otomatik olarak oluşturulan Microsoft komut dosyasından basitleştirilmiş bir alıntıdır.

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
}

2 sent ekliyorum. Windows 7 / Windows 10'da şimdiye kadar çalışan net oturuma dayalı basit sürümüm. Neden aşırı karmaşık?

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

komut dosyasının en üstüne ekleyin ve yönetici olarak çalışacaktır.

Bu davranış tasarım gereğidir. Microsoft, .ps1 dosyalarının en son e-posta virüsü olmasını istemediğinden çok sayıda güvenlik katmanı vardır. Bazı insanlar bunu adil bir görev otomasyonu kavramına karşı bulur. Vista + güvenlik modeli işleri "otomatikleştirmek", böylece kullanıcının onları iyi hale getirmektir.

Ancak, powershell kendisini yükseltilmiş olarak başlatırsanız, powershell'i kapatana kadar parola istemeden toplu iş dosyalarını çalıştırabilmelidir.

Elbette bir yönetici hesabınız varsa uygulamayı yönetici olarak açmaya da zorlayabilirsiniz.

Dosyayı bulun, sağ tıklayın> özellikler> Kısayol> Gelişmiş ve Yönetici Olarak Çalıştır'ı işaretleyin

Ardından Tamam'a tıklayın.

C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShellPowerShell kısayolunun bulunduğu yerdir . Gerçek 'exe'yi çağırmak için hala farklı bir yere gidiyor (%SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe ) .

PowerShell, izinler söz konusu olduğunda kullanıcı profiline dayalı olduğundan; kullanıcı adınızın / profilinizin o profil altında bir şey yapma izni varsa, PowerShell'de de genellikle bunu yapabilirsiniz. Bununla birlikte, kullanıcı profilinizin altında bulunan kısayolu değiştirmeniz mantıklı olacaktır C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell.

Sağ tıklayın ve özellikleri tıklayın. Diğer iki düğmenin sağında bulunan "Yorumlar" metin alanının hemen altında bulunan "Kısayol" sekmesinin altındaki "Gelişmiş" düğmesini tıklatın, "Dosya Konumunu Aç" ve "Simgeyi Değiştir".

"Yönetici Olarak Çalıştır" yazan onay kutusunu işaretleyin. Tıklayın OK, sonra Applyve OK. Bir kez daha 'Windows PowerShell' etiketli simgeye sağ tıklayın.C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell ve "Başlat Menüsüne / Görev Çubuğuna Sabitle" yi seçin.

Şimdi bu simgeye her tıkladığınızda, UAC'yi yükseltme için çağırır . 'EVET' seçeneğini seçtikten sonra, PowerShell konsolunun açık olduğunu göreceksiniz ve ekranın üst kısmında "Yönetici" olarak etiketlenecektir.

Bir adım daha ileri gitmek için ... Windows PowerShell profil konumunuzdaki aynı simge kısayoluna sağ tıklayabilir ve en son eklenen simgeyi tıklattığınızla aynı şeyi yapacak bir klavye kısayolu atayabilirsiniz. Yani "Kısayol Tuşu" yazdığı yerde, aşağıdaki gibi bir klavye tuşu / düğme kombinasyonu koyun: Ctrl+Alt + P P(PowerShell için) . Tıklayın Applyve OK.

Şimdi tek yapmanız gereken atadığınız düğme kombinasyonuna basmaktır ve UAC'nin çağrıldığını göreceksiniz ve 'EVET' seçeneğini seçtikten sonra bir PowerShell konsolu göründüğünü ve başlık çubuğunda "Yönetici" görüntülendiğini göreceksiniz.

Bunu yapmanın bir yolunu buldum ...

Komut dosyanızı açmak için bir toplu iş dosyası oluşturun:

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

Sonra masaüstünüzde bir kısayol oluşturun (sağ tıklayın Yeni -> Kısayol ).

Ardından bunu konuma yapıştırın:

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

İlk açılışta şifrenizi bir kez girmeniz gerekecektir. Bu daha sonra Windows kimlik yöneticisi içine kaydeder.

Bundan sonra, bir yönetici kullanıcı adı veya şifresi girmek zorunda kalmadan yönetici olarak çalışabilmeniz gerekir.

Sorun @pgk ve @Andrew Odri'nin cevaplarıyla , özellikle zorunlu olduklarında komut dosyası parametreleriniz olduğundadır. Bu sorunu aşağıdaki yaklaşımı kullanarak çözebilirsiniz:

1. Kullanıcı .ps1 öğesini sağ tıklar dosyasını 'PowerShell ile Çalıştır'ı seçer: giriş kutuları aracılığıyla parametreleri isteyin (bu HelpMessage'ı kullanmaktan çok daha iyi bir seçenektir parametre özniteliğini );
2. Kullanıcı komut dosyasını konsoldan yürütür: istenen parametreleri iletmesine izin verin ve konsolun zorunlu olanları bilgilendirmesi için onu zorlayın.

Betikte ComputerName ve Port zorunlu parametreleri varsa kod şöyle olur :

[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

Buradaki cevapların bir kısmı yakın, ama gerekenden biraz daha fazla iş.

Komut dosyanız için bir kısayol oluşturun ve bunu "Yönetici Olarak Çalıştır" olarak yapılandırın:

• Kısayolu oluşturun.
• Kısayolu sağ tıklayın ve açın Properties...
• Düzenleme Targetgelen <script-path>etmekpowershell <script-path>
• Tıkla Advanced...ve etkinleştirRun as administrator

Başka bir basit çözüm de "C: \ Windows \ System32 \ cmd.exe" yi sağ tıklayıp "Yönetici Olarak Çalıştır" ı seçip herhangi bir uygulamayı herhangi bir şifre girmeden yönetici olarak çalıştırabilmenizdir.

Aşağıdaki çözümü kullanıyorum. Transkript özelliği ile stdout / stderr'i işler ve çıkış kodunu doğru şekilde ana işleme geçirir. Konuşma metni yolunu / dosya adını ayarlamanız gerekir.

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

Yükseltilmiş bir powershell komutunu nasıl çalıştıracağınız ve çıktı formunu tek bir komutta bir windows toplu iş dosyasında nasıl toplayacağınız (ps1 powershell betiği yazmamak).

powershell -Command 'Start-Process powershell -ArgumentList "-Command (Get-Process postgres | Select-Object Path | Select-Object -Index 0).Path | Out-File -encoding ASCII $env:TEMP\camp-postgres.tmp" -Verb RunAs'

Yukarıda, önce yükseltilmiş istemi olan bir powershell başlattım ve sonra komutu çalıştırmak için başka bir powershell (alt kabuk) başlatmasını istedim.

Shay Levy'nin cevabının üstünde, aşağıdaki kurulumu izleyin (sadece bir kez)

1. Yönetici haklarıyla bir PowerShell başlatın.
2. Stack Overflow sorusunu takip edin PowerShell, “bu sistemde komut dosyalarının yürütülmesi devre dışı” diyor. .
3. PATHÖrneğin .ps1 dosyanızı herhangi bir klasöre yerleştirin. Windows \ System32 klasörü

Kurulumdan sonra:

1. Basın Win+R
2. Çağırmak powershell Start-Process powershell -Verb runAs <ps1_file>

Artık her şeyi tek bir komut satırında çalıştırabilirsiniz. Yukarıdaki Windows 8 Basic 64 bit üzerinde çalışır.

Bulduğum en güvenilir yol, kendi kendine yükselen bir .bat dosyasına sarmaktır:

@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

.Bat zaten yönetici olup olmadığınızı kontrol eder ve gerekirse betiği Yönetici olarak yeniden başlatır. Ayrıca ShellExecute()ayarlanan 4. parametresi ile yabancı "cmd" pencerelerinin açılmasını önler 0.

Daha önce kendi yöntemimi görmedim, bu yüzden şunu deneyin. İzlemesi çok daha kolay ve çok daha az yer kaplıyor:

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

Çok basit bir şekilde, geçerli Powershell oturumu yönetici ayrıcalıklarıyla çağrıldıysa, geçerli kimliği aldığınızda Yönetici Grubu tarafından bilinen SID, Gruplarda görünecektir. Hesap bu grubun bir üyesi olsa bile, işlem yükseltilmiş kimlik bilgileriyle çağrılmadığı sürece SID görünmez.

Bu yanıtların neredeyse tamamı, Microsoft'un Ben Armstrong'un gerçekte ne yaptığını ve aynı rutini başka bir şekilde nasıl taklit edeceğini kavramadığı halde bunu nasıl başaracağına dair son derece popüler yönteminin bir varyasyonudur.

Komutun çıktısını geçerli tarihi içeren bir metin dosya adına eklemek için şöyle bir şey yapabilirsiniz:

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

Bu bir açıklama ...

Powershell RUNAS / SAVECRED kimlik bilgileri "güvenli değildir", denedi ve kimlik bilgileri önbelleğine yönetici kimliği ve parolasını ekliyor ve OOPS! Bunu yaptıysanız, girişi kontrol etmenizi ve kaldırmanızı öneririm.

Microsoft ilkesi, programı yönetici olarak yürütmek için UAC (giriş noktası) olmadan aynı kod bloğunda karma kullanıcı ve yönetici koduna sahip olamayacağınız için programınızı veya kodunuzu gözden geçirin. Bu Linux'ta sudo (aynı şey) olurdu.

UAC'nin 3 çeşidi vardır, programın manifestinde oluşturulmuş bir istem veya bir giriş noktası. Programı yükseltmez, bu yüzden UAC yoksa ve yöneticiye ihtiyaç duyarsa başarısız olur. Bir yönetici gereksinimi olarak UAC iyi olsa da, kimlik doğrulaması olmadan kod yürütülmesini önler ve karışık kod senaryosunun kullanıcı düzeyinde yürütülmesini önler.

Çok kolay olduğu ortaya çıktı. Tek yapmanız gereken yönetici olarak bir cmd çalıştırmak. Ardından explorer.exeenter tuşuna basın. Windows Gezgini açılır . Şimdi çalıştırmak istediğiniz PowerShell betiğinize sağ tıklayın, yönetici modunda PowerShell'de başlatacak "PowerShell ile çalıştır" ı seçin.

Politikanın çalışmasını, Y türünü girip enter tuşuna basmanızı isteyebilir. Şimdi komut dosyası PowerShell'de yönetici olarak çalışacaktır. Her şeyin kırmızı renkte çalışması durumunda, politikanız henüz etkilenmediği anlamına gelir. Sonra tekrar deneyin ve iyi çalışması gerekir.