powershell - Een opdracht uitvoeren als beheerder met PowerShell?

Weet je hoe als je de beheerder bent van een systeem en je kunt gewoon met de rechtermuisknop op een batchscript klikken en het uitvoeren als beheerder zonder het beheerderswachtwoord in te voeren?

Ik vraag me af hoe ik dit moet doen met een PowerShell-script. Ik wil mijn wachtwoord niet hoeven in te voeren; Ik wil gewoon de rechtsklik-methode Uitvoeren als beheerdernabootsen.

Alles wat ik tot nu toe heb gelezen, vereist dat je het beheerderswachtwoord opgeeft.

Antwoord 1, autoriteit 100%

Als de huidige console niet is verhoogd en de bewerking die u probeert uit te voeren, vereist verhoogde rechten, dan kunt u powershellstarten met de optie Uitvoeren als beheerder:

PS> Start-Process powershell -Verb runAs

Microsoft Docs: Start-Process

Antwoord 2, autoriteit 37%

Hier is een aanvulling op de suggestie van Shay Levi (voeg deze regels gewoon toe aan het begin van een script):

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
}

Dit resulteert erin dat het huidige script wordt doorgegeven aan een nieuw powershell-proces in de beheerdersmodus (als de huidige gebruiker toegang heeft tot de beheerdersmodus en het script niet als beheerder wordt gestart).

Antwoord 3, autoriteit 33%

Zelfverheffend PowerShell-script

Windows 8.1 / PowerShell 4.0 +

Eén regel 🙂

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

Antwoord 4, autoriteit 12%

Benjamin Armstrong plaatste een uitstekend artikel over zelfverheffende PowerShell-scripts. Er zijn een paar kleine problemen met zijn code; een aangepaste versie op basis van oplossingen die in de opmerking worden voorgesteld, staat hieronder.

In principe krijgt het de identiteit die is gekoppeld aan het huidige proces, controleert het of het een beheerder is en als dat niet het geval is, maakt het een nieuw PowerShell-proces met beheerdersrechten en beëindigt het het oude 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");

Antwoord 5, autoriteit 9%

Hier is een zelfverheffend fragment voor Powershell-scripts waarin de werkmap behouden blijft:

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

Het behouden van de werkdirectory is belangrijk voor scripts die padgerelateerde bewerkingen uitvoeren. Bijna alle andere antwoorden behouden dit pad niet, wat onverwachte fouten in de rest van het script kan veroorzaken.

Als je liever geen zelfverheffend script/fragment gebruikt, en in plaats daarvan gewoon een gemakkelijke manier wilt om een script als beheerder te starten (bijv. vanuit het contextmenu van Explorer), bekijk dan mijn andere antwoord hier: https://stackoverflow.com/a/57033941/2441655

Antwoord 6, autoriteit 6%

U kunt een batchbestand (*.bat) maken dat uw powershell-script uitvoert met beheerdersrechten wanneer u erop dubbelklikt. Op deze manier hoeft u niets te veranderen in uw powershell-script. Om dit te doen, maakt u een batchbestand met dezelfde naam en locatie als uw powershell-script en plaatst u de volgende inhoud erin:

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

Dat is het!

Hier is de uitleg:

Ervan uitgaande dat uw powershell-script zich in het pad C:\Temp\ScriptTest.ps1bevindt, moet uw batchbestand het pad C:\Temp\ScriptTest.bathebben. Wanneer iemand dit batchbestand uitvoert, zullen de volgende stappen plaatsvinden:

De cmd zal het commando uitvoeren

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

Er wordt een nieuwe powershell-sessie geopend en het volgende commando wordt uitgevoerd:

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

Een nieuwe powershell-sessie met beheerdersrechten wordt geopend in de map system32en de volgende argumenten worden eraan doorgegeven:
```
-ExecutionPolicy Bypass -NoProfile -NoExit -Command "cd \"C:\Temp\"; & \".\ScriptTest.ps1\""
```
De volgende opdracht wordt uitgevoerd met beheerdersrechten:
```
cd "C:\Temp"; & ".\ScriptTest.ps1"
```
Zodra het scriptpad en de naamargumenten tussen dubbele aanhalingstekens staan, kunnen ze spaties of enkele aanhalingstekens (‘) bevatten.
De huidige map verandert van system32in C:\Tempen het script ScriptTest.ps1wordt uitgevoerd. Nadat de parameter -NoExitis doorgegeven, wordt het venster niet gesloten, zelfs niet als uw powershell-script een uitzondering maakt.

Antwoord 7, autoriteit 5%

Gebruik

#Requires -RunAsAdministrator

is nog niet vermeld. Het lijkt er pas te zijn sinds PowerShell 4.0.

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

Wanneer deze switch-parameter wordt toegevoegd aan uw required-statement,
het geeft aan dat de Windows PowerShell-sessie waarin u zich bevindt
het uitvoeren van het script moet worden gestart met verhoogde gebruikersrechten
(Uitvoeren als beheerder).

Voor mij lijkt dit een goede manier om dit aan te pakken, maar ik ben nog niet zeker van de praktijkervaring. PowerShell 3.0-runtimes negeren dit waarschijnlijk, of erger nog, geven een foutmelding.

Als het script wordt uitgevoerd als een niet-beheerder, wordt de volgende foutmelding gegeven:

Het script ‘StackOverflow.ps1’ kan niet worden uitgevoerd omdat het een . bevat
“#requires” statement om als administrator uit te voeren. De stroom
Windows PowerShell-sessie wordt niet uitgevoerd als beheerder. Begin
Windows PowerShell met behulp van de optie Uitvoeren als beheerder, en dan
probeer het script opnieuw uit te voeren.
+ CategoryInfo          : PermissionDenied: (StackOverflow.ps1:String) [], ParentContainsErrorRecordException
+ FullyQualifiedErrorId : ScriptRequiresElevation

Antwoord 8, autoriteit 4%

U kunt eenvoudig enkele registervermeldingen toevoegen om een contextmenu “Als administrator uitvoeren” te krijgen voor .ps1-bestanden:

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

(bijgewerkt naar een eenvoudiger script van @Shay)

Kortom bij HKCR:\Microsoft.PowershellScript.1\Shell\runas\commandstel de standaardwaarde in om het script aan te roepen met Powershell.

Antwoord 9, autoriteit 3%

De code gepost door Jonathan en Shay Levy werkte niet voor mij.

Vind de werkende code hieronder:

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"

Antwoord 10, Autoriteit 2%

U moet het script opnieuw uitvoeren met administratieve rechten en controleren of het script in die modus is gelanceerd. Hieronder heb ik een script geschreven met twee functies: DoelevatedOperations en DostandardOperations . U moet uw code plaatsen die Admin-rechten vereist in de eerste en standaardoperaties in de tweede. De isrunasadmin variabele wordt gebruikt om de beheerdersmodus te identificeren.

Mijn code is een vereenvoudigd uittreksel uit het Microsoft-script dat automatisch wordt gegenereerd wanneer u een app-pakket maakt voor Windows Store-apps.

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
}

Antwoord 11, autoriteit 2%

Mijn 2 cent toevoegen. Mijn eenvoudige versie op basis van een internetsessie die tot nu toe altijd werkt in Windows 7 / Windows 10. Waarom het te ingewikkeld maken?

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

voeg toe aan de bovenkant van het script en het wordt uitgevoerd als beheerder.

Antwoord 12, autoriteit 2%

Je kunt de applicatie ook forceren om als beheerder te openen, als je natuurlijk een beheerdersaccount hebt.

Zoek het bestand, klik met de rechtermuisknop op > eigenschappen > Snelkoppeling > Geavanceerden vink Als administrator uitvoeren

aan

Klik vervolgens op OK.

Antwoord 13

Dit gedrag is inherent aan het ontwerp. Er zijn meerdere beveiligingslagen omdat Microsoft echt niet wilde dat .ps1-bestanden het nieuwste e-mailvirus zouden zijn. Sommige mensen vinden dit in strijd met het idee van taakautomatisering, wat redelijk is. Het Vista+-beveiligingsmodel is om dingen te “de-automatiseren”, zodat de gebruiker ze goedkeurt.

Ik vermoed echter dat als je powershell zelf start als verhoogd, het batchbestanden moet kunnen uitvoeren zonder opnieuw om het wachtwoord te vragen totdat je powershell sluit.

Antwoord 14

Een aantal van de antwoorden hier zijn dichtbij, maar het is iets meer werk dan nodig is.

Maak een snelkoppeling naar uw script en configureer het als “Uitvoeren als beheerder”:

Maak de snelkoppeling.
Klik met de rechtermuisknop op de snelkoppeling en open Properties...
Bewerk Targetvan <script-path>naar powershell <script-path>
Klik op Geavanceerd...en schakel Run as administrator

Antwoord 15

Hier leest u hoe u een verhoogde powershell-opdracht uitvoert en het uitvoerformulier verzamelt in een Windows-batchbestand in een enkele opdracht (d.w.z. geen ps1 powershell-script schrijven).

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'

Hierboven zie je dat ik eerst een powershell start met een verhoogde prompt en die vraag dan om een andere powershell (subshell) te starten om de opdracht uit te voeren.

Antwoord 16

C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShellis waar de snelkoppelingvan PowerShell zich bevindt. Het gaat ook nog steeds naar een andere locatie om de daadwerkelijke ‘exe’ op te roepen (%SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe).

Aangezien PowerShell wordt aangestuurd door gebruikersprofielen als het om machtigingen gaat; als uw gebruikersnaam/profiel de machtigingen heeft om iets te doen, dan zou u dit in PowerShell over het algemeen ook kunnen doen onder dat profiel. Dat gezegd hebbende, zou het logisch zijn dat u de snelkoppeling onder uw gebruikersprofiel zou wijzigen, bijvoorbeeld C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell.

Klik met de rechtermuisknop en klik op eigenschappen. Klik op de knop “Geavanceerd” onder het tabblad “Snelkoppeling” dat zich direct onder het tekstveld “Opmerkingen” naast twee andere knoppen bevindt, respectievelijk “Bestandslocatie openen” en “Pictogram wijzigen”.

Vink het selectievakje aan met de tekst “Als administrator uitvoeren”. Klik op OK, vervolgens op Toepassenen OK. Klik nogmaals met de rechtermuisknop op het pictogram met het label ‘Windows PowerShell’ in C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShellen selecteer “Pin to Start Menu/Taakbalk”.

Als u nu op dat pictogram klikt, wordt de UACaangeroepen voor escalatie. Nadat u ‘JA’ heeft geselecteerd, ziet u dat de PowerShell-console wordt geopend en dat deze bovenaan het scherm als ‘Beheerder’ wordt aangeduid.

Om nog een stap verder te gaan… kunt u met de rechtermuisknop op diezelfde sneltoets klikken in uw profiellocatie van Windows PowerShell en een sneltoets toewijzen die precies hetzelfde doet als wanneer u op het onlangs toegevoegde pictogram klikt. Dus waar het zegt “Sneltoets”, plaats dan een toetsenbordtoets/knopcombinatie zoals: Ctrl+ Alt+ PP(voor PowerShell). Klik op Toepassenen OK.

Nu hoef je alleen maar op die knopcombinatie te drukken die je hebt toegewezen en je zult zien dat UAC wordt aangeroepen, en nadat je ‘JA’ hebt geselecteerd, zie je een PowerShell-console verschijnen en wordt ‘Beheerder’ weergegeven op de titelbalk.

Antwoord 17

Ik heb een manier gevonden om dit te doen…

Maak een batchbestand om uw script te openen:

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

Maak vervolgens een snelkoppeling, zeg op uw bureaublad (klik met de rechtermuisknop Nieuw-> Snelkoppeling).

Plak dit dan in de locatie:

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

Bij de eerste keer openen, moet u uw wachtwoord één keer invoeren. Dit zal het dan opslaan in de Windows-referentiebeheer.

Hierna zou u als beheerder moeten kunnen werken zonder dat u een beheerdersgebruikersnaam of -wachtwoord hoeft in te voeren.

Antwoord 18

Ik gebruik de onderstaande oplossing. Het verwerkt stdout/stderr via de transcriptfunctie en geeft de exitcode correct door aan het bovenliggende proces. U moet het pad/bestandsnaam van het transcript aanpassen.

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

Antwoord 19

Nog een eenvoudiger oplossing is dat u ook met de rechtermuisknop op “C: \ Windows \ System32 \ CMD.exe” kunt klikken en kiest u “RUN ALS WINDELING”, kunt u een app als beheerder uitvoeren zonder een wachtwoord te bieden.

Antwoord 20

Het probleem met de @PGK en @ andrew ODRI ‘S Antwoorden is wanneer u scriptparameters hebt, speciaal wanneer ze verplicht zijn. U kunt dit probleem oplossen met behulp van de volgende aanpak:

De gebruiker klikt met de rechtermuisknop op het bestand . PSS1 en selecteert ‘Uitvoeren met PowerShell’: vraag hem om de parameters via invoervakken (dit is een veel betere optie dan de HelpMessage < / em>Parameterattribuut);

De gebruiker voert het script uit via de console: laat hem de gewenste parameters doorgeven en laat de console hem dwingen om de verplichte te informeren.

Hier is de code als het script de Computername en poort verplicht had: verplichte parameters:

[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

Antwoord 21

De meest betrouwbare manier die ik heb gevonden is om het in een zelfverheffend .bat-bestand te stoppen:

@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

De .bat controleert of u al beheerder bent en start het script indien nodig opnieuw als beheerder. Het voorkomt ook dat externe “cmd”-vensters worden geopend met de 4e parameter van ShellExecute()ingesteld op 0.

Antwoord 22

Volg naast Shay Levy’s antwoord de onderstaande instellingen (slechts één keer)

Start een PowerShell met beheerdersrechten.
Volg de Stack Overflow-vraag PowerShell zegt: “uitvoering van scripts is uitgeschakeld op dit systeem.”.
Plaats uw .ps1-bestand bijvoorbeeld in een van de PATH-mappen. Map Windows\System32

Na de installatie:

Druk op Win+ R
Roep powershell Start-Process powershell -Verb runAs <ps1_file>

Je kunt nu alles in slechts één opdrachtregel uitvoeren. Het bovenstaande werkt op Windows 8 Basic 64-bit.

Antwoord 23

Ik heb mijn eigen manier om het te doen nog niet eerder gezien, dus probeer dit eens. Het is veel gemakkelijker te volgen en heeft een veel kleinere voetafdruk:

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

Heel eenvoudig, als de huidige Powershell-sessie werd aangeroepen met beheerdersrechten, zal de bekende SID van de beheerdersgroep in de groepen verschijnen wanneer u de huidige identiteit pakt. Zelfs als het account lid is van die groep, wordt de SID niet weergegeven, tenzij het proces is aangeroepen met verhoogde inloggegevens.

Bijna al deze antwoorden zijn een variatie op de immens populaire methode van Ben Armstrong van Microsoft om dit te bereiken zonder echt te begrijpen wat het eigenlijk doet en hoe anders dezelfde routine kan worden nagebootst.

Antwoord 24

Om de uitvoer van de opdracht toe te voegen aan een tekstbestandsnaam die de huidige datum bevat, kun je zoiets als dit doen:

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

Antwoord 25

Dit is een verduidelijking …

De powershell RUNAS / SAVECRED-referentie “is niet veilig”, geprobeerd en het voegt de beheerdersidentiteit en het wachtwoord toe aan de referentiecache en kan elders worden gebruikt OOPS!. Als je dit hebt gedaan, raad ik je aan het item te controleren en te verwijderen.

Controleer uw programma of code, want het Microsoft-beleid is dat u geen gecombineerde gebruikers- en beheerderscode in dezelfde codeblob kunt hebben zonder de UAC (het toegangspunt) om het programma als beheerder uit te voeren. Dit zou sudo (hetzelfde) zijn op Linux.

De UAC heeft 3 typen, niet te zien, een prompt of een ingangspunt gegenereerd in het manifest van het programma. Het verhoogt het programma niet, dus als er geen UAC is en het heeft admin nodig, zal het mislukken. De UAC is echter als beheerdersvereiste goed, het voorkomt code-uitvoering zonder authenticatie en voorkomt dat het scenario met gemengde codes wordt uitgevoerd op gebruikersniveau.

Antwoord 26

Het bleek te gemakkelijk te zijn. Het enige wat u hoeft te doen is een cmd als administrator uitvoeren. Typ vervolgens explorer.exeen druk op enter. Dat opent Windows Explorer.
Klik nu met de rechtermuisknop op uw PowerShell-script dat u wilt uitvoeren, kies “uitvoeren met PowerShell” waardoor het in PowerShell in beheerdersmodus wordt gestart.

Het kan zijn dat u wordt gevraagd om het beleid in te schakelen, typ Y en druk op enter. Nu wordt het script als beheerder in PowerShell uitgevoerd. Als het helemaal rood is, betekent dit dat uw beleid nog niet van kracht is geworden. Probeer het dan opnieuw en het zou goed moeten werken.

Een opdracht uitvoeren als beheerder met PowerShell?