Menjalankan perintah sebagai Administrator menggunakan PowerShell?

Anda tahu bagaimana jika Anda adalah pengguna administratif suatu sistem dan Anda dapat mengklik kanan mengatakan, skrip batch dan menjalankannya sebagai Administrator tanpa memasukkan kata sandi administrator?

Saya ingin tahu bagaimana melakukan ini dengan skrip PowerShell. Saya tidak mau harus memasukkan kata sandi saya; Saya hanya ingin meniru klik kanan metode Run As Administrator .

Semua yang saya baca sejauh ini mengharuskan Anda untuk memberikan kata sandi administrator.

Jika konsol saat ini tidak ditinggikan dan operasi yang Anda coba lakukan memerlukan hak yang lebih tinggi maka Anda dapat memulai PowerShell dengan Run as administratoropsi:

PS> Start-Process powershell -Verb runAs

Ini adalah tambahan saran Shay Levi (cukup tambahkan baris ini di awal skrip):

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
}

Ini menghasilkan skrip saat ini diteruskan ke proses PowerShell baru dalam mode Administrator (jika Pengguna saat ini memiliki akses ke mode Administrator dan skrip tidak diluncurkan sebagai Administrator).

Skrip PowerShell yang terangkat sendiri

Windows 8.1 / PowerShell 4.0 +

Satu baris :)

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 memposting artikel yang bagus tentang skrip PowerShell yang bisa meningkatkan diri sendiri . Ada beberapa masalah kecil dengan kodenya; versi modifikasi berdasarkan perbaikan yang disarankan dalam komentar di bawah ini.

Pada dasarnya itu mendapatkan identitas yang terkait dengan proses saat ini, memeriksa apakah itu adalah administrator, dan jika tidak, menciptakan proses PowerShell baru dengan hak istimewa administrator dan mengakhiri proses yang lama.

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

Anda bisa membuat file batch ( *.bat) yang menjalankan skrip PowerShell Anda dengan hak administratif ketika diklik dua kali. Dengan cara ini, Anda tidak perlu mengubah apa pun di skrip PowerShell Anda . Untuk melakukannya, buat file batch dengan nama dan lokasi skrip PowerShell yang sama dan kemudian masukkan konten berikut di dalamnya:

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

Itu dia!

Berikut penjelasannya:

Dengan asumsi skrip powershell Anda ada di path C:\Temp\ScriptTest.ps1, file batch Anda harus memiliki path C:\Temp\ScriptTest.bat. Ketika seseorang mengeksekusi file batch ini, langkah-langkah berikut akan terjadi:

1. Cmd akan menjalankan perintah

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

2. Sesi PowerShell baru akan terbuka dan perintah berikut akan dieksekusi:

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

3. Sesi PowerShell baru lainnya dengan hak administratif akan terbuka di system32folder dan argumen berikut akan diteruskan ke sana:

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

4. Perintah berikut akan dieksekusi dengan hak administratif:

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

   Setelah alur skrip dan argumen nama dikutip ganda, mereka dapat berisi spasi atau karakter tanda kutip tunggal ( ').

5. Folder saat ini akan berubah dari system32menjadi C:\Tempdan skrip ScriptTest.ps1akan dieksekusi. Setelah parameter -NoExitdilewati, jendela tidak akan ditutup, bahkan jika skrip PowerShell Anda melemparkan beberapa pengecualian.

Berikut cuplikan self-elevating untuk skrip Powershell yang mempertahankan direktori kerja :

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

Mempertahankan direktori kerja penting untuk skrip yang melakukan operasi relatif jalur. Hampir semua jawaban lain tidak mempertahankan jalur ini, yang dapat menyebabkan kesalahan tak terduga di sisa skrip.

Jika Anda lebih suka tidak menggunakan skrip self-elevating / snippet, dan sebaliknya hanya ingin cara mudah untuk meluncurkan skrip sebagai adminstrator (mis. Dari menu konteks Explorer), lihat jawaban saya yang lain di sini: https: // stackoverflow .com / a / 57033941/2441655

Menggunakan

#Requires -RunAsAdministrator

belum dinyatakan. Tampaknya sudah ada sejak PowerShell 4.0.

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

Ketika parameter sakelar ini ditambahkan ke pernyataan membutuhkan Anda, ini menentukan bahwa sesi Windows PowerShell tempat Anda menjalankan skrip harus dimulai dengan hak pengguna yang ditingkatkan (Jalankan sebagai Administrator).

Bagi saya, ini sepertinya cara yang baik untuk membahas hal ini, tetapi saya belum yakin dengan pengalaman di lapangan. Runtime PowerShell 3.0 mungkin mengabaikan ini, atau bahkan lebih buruk, memberikan kesalahan.

Ketika skrip dijalankan sebagai non-administrator, kesalahan berikut diberikan:

Skrip 'StackOverflow.ps1' tidak dapat dijalankan karena mengandung pernyataan "#requires" untuk dijalankan sebagai Administrator. Sesi Windows PowerShell saat ini tidak berjalan sebagai Administrator. Mulai Windows PowerShell dengan menggunakan opsi Jalankan sebagai Administrator, lalu coba jalankan kembali skrip.

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

Anda dapat dengan mudah menambahkan beberapa entri registri untuk mendapatkan menu konteks "Jalankan sebagai administrator" untuk .ps1file:

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

(diperbarui ke skrip sederhana dari @Shay)

Pada dasarnya HKCR:\Microsoft.PowershellScript.1\Shell\runas\commandatur nilai default untuk menjalankan script menggunakan Powershell.

Kode yang diposting oleh Jonathan dan Shay Levy tidak berfungsi untuk saya.

Temukan kode kerja di bawah ini:

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"

Anda perlu menjalankan kembali skrip dengan hak administratif dan memeriksa apakah skrip diluncurkan dalam mode itu. Di bawah ini saya telah menulis skrip yang memiliki dua fungsi: DoElevatedOperations dan DoStandardOperations . Anda harus menempatkan kode Anda yang memerlukan hak admin ke yang pertama dan operasi standar ke yang kedua. The IsRunAsAdmin variabel digunakan untuk mengidentifikasi mode admin.

Kode saya adalah ekstrak yang disederhanakan dari skrip Microsoft yang secara otomatis dihasilkan ketika Anda membuat paket aplikasi untuk aplikasi Windows Store.

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
}

Menambahkan 2 sen saya. Versi sederhana saya berdasarkan sesi net yang berfungsi sepanjang waktu di Windows 7 / Windows 10. Mengapa terlalu rumit?

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

tambahkan saja ke bagian atas skrip dan itu akan berjalan sebagai administrator.

Perilaku ini adalah dengan desain. Ada beberapa lapisan keamanan karena Microsoft benar-benar tidak ingin file .ps1 menjadi virus email terbaru. Beberapa orang menemukan ini bertentangan dengan gagasan otomatisasi tugas, yang adil. Model keamanan Vista + adalah untuk "mendeotomatisasi" hal-hal, sehingga membuat pengguna oke saja.

Namun, saya curiga jika Anda meluncurkan PowerShell sebagai peningkatan, itu seharusnya dapat menjalankan file batch tanpa meminta kata sandi lagi sampai Anda menutup PowerShell.

Anda juga dapat memaksa aplikasi untuk membuka sebagai administrator, jika Anda memiliki akun administrator, tentu saja.

Temukan file, klik kanan> properties> Shortcut> Advanced dan centang Run as Administrator

Kemudian Klik OK.

C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShelladalah tempat pintasan PowerShell berada. Itu juga masih pergi ke lokasi yang berbeda untuk memanggil 'exe' yang sebenarnya ( %SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe).

Karena PowerShell digerakkan oleh profil pengguna ketika ada izin terkait; jika nama pengguna / profil Anda memiliki izin untuk melakukan sesuatu maka di bawah profil itu, di PowerShell Anda pada umumnya akan dapat melakukannya juga. Karena itu, masuk akal bahwa Anda akan mengubah pintasan yang terletak di bawah profil pengguna Anda, misalnya C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell,.

Klik kanan dan klik properti. Klik tombol "Advanced" di bawah tab "Shortcut" yang terletak tepat di bawah bidang teks "Komentar" yang berdekatan di sebelah kanan dua tombol lainnya, "Buka Lokasi File" dan "Ubah Ikon".

Centang kotak yang bertuliskan, "Jalankan sebagai Administrator". Klik OK, lalu Applydan OK. Sekali lagi klik kanan ikon berlabel 'Windows PowerShell' yang terletak di C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShelldan pilih "Pin to Start Menu / Taskbar".

Sekarang setiap kali Anda mengklik ikon itu, itu akan memanggil UAC untuk eskalasi. Setelah memilih 'YA', Anda akan melihat konsol PowerShell terbuka dan akan diberi label "Administrator" di bagian atas layar.

Untuk melangkah lebih jauh ... Anda bisa mengklik kanan ikon pintasan yang sama di lokasi profil Windows PowerShell Anda dan menetapkan pintasan keyboard yang akan melakukan hal yang persis sama seolah-olah Anda mengklik ikon yang baru ditambahkan. Jadi di mana dikatakan "Shortcut Key" dimasukkan ke dalam kombinasi tombol keyboard / tombol seperti: Ctrl+ Alt+ P P(untuk PowerShell) . Klik Applydan OK.

Sekarang yang harus Anda lakukan adalah menekan kombinasi tombol yang Anda tetapkan dan Anda akan melihat UAC dipanggil, dan setelah Anda memilih 'YA' Anda akan melihat konsol PowerShell muncul dan "Administrator" ditampilkan pada bilah judul.

Saya telah menemukan cara untuk melakukan ini ...

Buat file batch untuk membuka skrip Anda:

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

Kemudian buat pintasan, di desktop Anda ucapkan (klik kanan Baru -> Pintasan ).

Kemudian tempel ini ke lokasi:

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

Saat pertama kali dibuka, Anda harus memasukkan kata sandi sekali. Ini kemudian akan menyimpannya di manajer kredensial Windows.

Setelah ini, Anda kemudian dapat menjalankan sebagai administrator tanpa harus memasukkan nama pengguna atau kata sandi administrator.

Masalah dengan jawaban @pgk dan @Andrew Odri adalah ketika Anda memiliki parameter skrip, khususnya ketika itu wajib. Anda dapat memecahkan masalah ini menggunakan pendekatan berikut:

1. Pengguna mengklik kanan file .ps1 dan memilih 'Jalankan dengan PowerShell': minta parameter dari kotak input (ini adalah pilihan yang jauh lebih baik daripada menggunakan atribut parameter HelpMessage );
2. Pengguna menjalankan skrip melalui konsol: izinkan dia untuk melewati parameter yang diinginkan dan biarkan konsol memaksanya untuk memberi tahu yang wajib.

Berikut adalah bagaimana kode jika skrip memiliki parameter wajib ComputerName dan Port :

[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

Sejumlah jawaban di sini dekat, tetapi sedikit lebih banyak pekerjaan daripada yang dibutuhkan.

Buat pintasan ke skrip Anda dan konfigurasikan ke "Run as Administrator":

• Buat pintasan.
• Klik kanan pintasan dan buka Properties...
• Edit Targetdari <script-path>hinggapowershell <script-path>
• Klik Advanced...dan aktifkanRun as administrator

Solusi lain yang lebih sederhana adalah Anda juga dapat mengklik kanan pada "C: \ Windows \ System32 \ cmd.exe" dan pilih "Run as Administrator" maka Anda dapat menjalankan aplikasi apa pun sebagai administrator tanpa memberikan kata sandi apa pun.

Saya menggunakan solusi di bawah ini. Ini menangani stdout / stderr melalui fitur transkrip dan melewati kode keluar dengan benar ke proses induk. Anda perlu menyesuaikan jalur transkrip / nama file.

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

Berikut adalah cara menjalankan perintah powershell tinggi dan mengumpulkan formulir output dalam file batch windows dalam satu perintah (yaitu tidak menulis skrip powershell ps1).

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'

Di atas Anda melihat saya pertama kali meluncurkan PowerShell dengan prompt yang ditinggikan dan kemudian meminta untuk meluncurkan PowerShell lain (sub shell) untuk menjalankan perintah.

Di atas jawaban Shay Levy, ikuti pengaturan di bawah ini (hanya sekali)

1. Mulai PowerShell dengan hak Administrator.
2. Ikuti pertanyaan Stack Overflow PowerShell mengatakan "eksekusi skrip dinonaktifkan pada sistem ini." .
3. Masukkan file .ps1 Anda di salah satu PATHfolder, misalnya. Folder Windows \ System32

Setelah pengaturan:

1. Tekan Win+R
2. Memohon powershell Start-Process powershell -Verb runAs <ps1_file>

Anda sekarang dapat menjalankan semuanya hanya dalam satu baris perintah. Di atas berfungsi pada Windows 8 Basic 64-bit.

Cara paling tepercaya yang saya temukan adalah membungkusnya dengan file .bat yang dapat berdiri sendiri:

@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 memeriksa apakah Anda sudah menjadi admin dan meluncurkan kembali skrip sebagai Administrator jika diperlukan. Itu juga mencegah jendela "cmd" yang asing dari membuka dengan parameter ke-4 ShellExecute()diatur ke 0.

Saya belum pernah melihat cara saya melakukannya sebelumnya, jadi, coba ini. Cara ini lebih mudah diikuti dan memiliki jejak yang jauh lebih kecil:

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

Sederhananya, jika sesi Powershell saat ini dipanggil dengan hak administrator, SID Grup Administrator yang terkenal akan muncul di Grup saat Anda mengambil identitas saat ini. Sekalipun akun tersebut adalah anggota grup itu, SID tidak akan muncul kecuali prosesnya dilakukan dengan kredensial yang ditingkatkan.

Hampir semua jawaban ini adalah variasi dari metode Microsoft Ben Armstrong yang sangat populer tentang cara mencapainya, tetapi tidak benar-benar memahami apa yang sebenarnya dilakukan dan bagaimana cara meniru persaingan yang sama.

Untuk menambahkan output perintah ke nama file teks yang mencakup tanggal saat ini Anda dapat melakukan sesuatu seperti ini:

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

Ini adalah klarifikasi ...

Kredensial RUNAS / SAVECRED PowerShell "tidak aman", mencobanya dan menambah identitas admin dan kata sandi ke dalam cache kredensial dan dapat digunakan di tempat lain OOPS !. Jika Anda telah melakukan ini, saya sarankan Anda memeriksa dan menghapus entri.

Tinjau program atau kode Anda karena kebijakan Microsoft adalah Anda tidak dapat memiliki kode pengguna dan admin yang dicampur dalam gumpalan kode yang sama tanpa UAC (titik masuk) untuk menjalankan program sebagai admin. Ini akan menjadi sudo (hal yang sama) di Linux.

UAC memiliki 3 jenis, janganlihat, prompt atau titik masuk yang dihasilkan dalam manifes program. Itu tidak meningkatkan program jadi jika tidak ada UAC dan perlu admin itu akan gagal. Meskipun UAC sebagai persyaratan administrator baik, ia mencegah eksekusi kode tanpa otentikasi dan mencegah skenario kode campuran dieksekusi di tingkat pengguna.

Ternyata itu terlalu mudah. Yang harus Anda lakukan adalah menjalankan cmd sebagai administrator. Kemudian ketik explorer.exedan tekan enter. Itu membuka Windows Explorer . Sekarang klik kanan pada skrip PowerShell yang ingin Anda jalankan, pilih "jalankan dengan PowerShell" yang akan meluncurkannya di PowerShell dalam mode administrator.

Ini mungkin meminta Anda untuk mengaktifkan kebijakan untuk menjalankan, ketik Y dan tekan enter. Sekarang skrip akan berjalan di PowerShell sebagai administrator. Jika semuanya berjalan merah, itu berarti kebijakan Anda belum berpengaruh. Kemudian coba lagi dan itu akan berfungsi dengan baik.