PowerShell: exécuter une commande en tant qu’administrateur

Vous savez comment si vous êtes l’administrateur d’un système et que vous pouvez simplement cliquer avec le bouton droit sur un script de traitement par lots et l’exécuter en tant qu’administrateur sans entrer le mot de passe administrateur?

Je me demande comment faire avec un script PowerShell. Je ne veux pas avoir à entrer mon mot de passe; Je veux juste imiter le clic droit sur la méthode Run As Administrator .

Tout ce que j’ai lu jusqu’à présent exige que vous fournissiez le mot de passe administrateur.

Si la console actuelle n’est pas élevée et que l’opération que vous tentez d’exécuter nécessite des privilèges élevés, vous pouvez lancer powershell avec l’option “Exécuter en tant qu’administrateur”

PS> Start-Process powershell -Verb runAs 

Voici un ajout à la suggestion de Shay Levi (ajoutez simplement ces lignes au début d’un 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 } 

Cela se traduit par le passage du script en cours à un nouveau processus Powershell en mode Administrateur (si l’utilisateur actuel a access au mode Administrateur et que le script n’est pas lancé en tant qu’administrateur).

Script PowerShell auto-élévateur

Windows 8.1 / PowerShell 4.0 +

Une ligne 🙂

 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 a publié un excellent article sur les scripts PowerShell auto-élévateurs . Il y a quelques problèmes mineurs avec son code; une version modifiée basée sur les correctifs suggérés dans le commentaire est ci-dessous.

Fondamentalement, il obtient l’identité associée au processus en cours, vérifie s’il s’agit d’un administrateur et, dans le cas contraire, crée un nouveau processus PowerShell avec des privilèges d’administrateur et met fin à l’ancien processus.

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

Vous pouvez créer un fichier de commandes ( *.bat ) qui exécute votre script powershell avec des privilèges d’administrateur lorsque vous double-cliquez dessus. De cette façon, vous n’avez rien à changer dans votre script powershell . Pour ce faire, créez un fichier de commandes portant le même nom et le même emplacement que votre script powershell, puis placez-y le contenu suivant:

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

C’est tout!

Voici l’explication:

En supposant que votre script powershell se trouve dans le chemin C:\Temp\ScriptTest.ps1 , votre fichier de commandes doit avoir le chemin C:\Temp\ScriptTest.bat . Lorsque quelqu’un exécute ce fichier de commandes, les étapes suivantes se produisent:

  1. Le cmd exécutera la commande

     powershell -Command "Start-Process powershell \"-ExecutionPolicy Bypass -NoProfile -NoExit -Command `\"cd \`\"C:\Temp\`\"; & \`\".\ScriptTest.ps1\`\"`\"\" -Verb RunAs" 
  2. Une nouvelle session PowerShell s’ouvrira et la commande suivante sera exécutée:

     Start-Process powershell "-ExecutionPolicy Bypass -NoProfile -NoExit -Command `"cd \`"C:\Temp\`"; & \`".\ScriptTest.ps1\`"`"" -Verb RunAs 
  3. Une autre nouvelle session PowerShell avec des privilèges d’administration s’ouvrira dans le dossier system32 et les arguments suivants lui seront transmis:

     -ExecutionPolicy Bypass -NoProfile -NoExit -Command "cd \"C:\Temp\"; & \".\ScriptTest.ps1\"" 
  4. La commande suivante sera exécutée avec les privilèges d’administrateur:

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

    Une fois que les arguments du nom et du chemin du script sont entre guillemets, ils peuvent contenir des caractères de guillemets ( ' ).

  5. Le dossier actuel passera de system32 à C:\Temp et le script ScriptTest.ps1 sera exécuté. Une fois que le paramètre -NoExit été passé, la fenêtre ne sera pas fermée, même si votre script powershell génère des exceptions.

Vous pouvez facilement append des entrées de registre pour obtenir un menu contextuel “Exécuter en tant qu’administrateur” pour les fichiers .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"' 

(mis à jour vers un script plus simple depuis @Shay)

Fondamentalement, à HKCR:\Microsoft.PowershellScript.1\Shell\runas\command définit la valeur par défaut pour invoquer le script à l’aide de Powershell.

En utilisant

#Requires -RunAsAdministrator

n’a pas encore été indiqué. Il semble y avoir seulement depuis PowerShell 4.0.

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

Lorsque ce paramètre de commutateur est ajouté à votre instruction requires, il spécifie que la session Windows PowerShell dans laquelle vous exécutez le script doit être démarrée avec des droits d’utilisateur élevés (Exécuter en tant qu’administrateur).

Pour moi, cela semble être un bon moyen d’y parvenir, mais je ne suis pas encore certain de l’expérience sur le terrain. Les exécutions de PowerShell 3.0 ignorent probablement ceci, ou pire encore, donnent une erreur.

Lorsque le script est exécuté en tant que non-administrateur, l’erreur suivante est donnée:

Le script ‘StackOverflow.ps1’ ne peut pas être exécuté car il contient une instruction “#requires” pour s’exécuter en tant qu’administrateur. La session Windows PowerShell en cours ne s’exécute pas en tant qu’administrateur. Démarrez Windows PowerShell en utilisant l’option Exécuter en tant qu’administrateur, puis essayez à nouveau d’exécuter le script.

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

Le code posté par Jonathan et Shay Levy ne fonctionnait pas pour moi.

Veuillez trouver le code de travail ci-dessous:

 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" 

Vous devez réexécuter le script avec les privilèges d’administrateur et vérifier si le script a été lancé dans ce mode. Ci-dessous, j’ai écrit un script qui a deux fonctions: DoElevatedOperations et DoStandardOperations . Vous devez placer votre code qui requirejs des droits d’administrateur dans le premier et des opérations standard dans le second. La variable IsRunAsAdmin est utilisée pour identifier le mode admin.

Mon code est un extrait simplifié du script Microsoft généré automatiquement lorsque vous créez un package d’application pour les applications 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 Unressortingcted -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 est l’endroit où réside le raccourci de PowerShell. Il se déplace également vers un autre emplacement pour appeler le fichier “exe” ( %SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe ).

Étant donné que PowerShell utilise un profil utilisateur lorsque les permissions sont concernées; Si votre nom d’utilisateur / profil a le droit de faire quelque chose, sous ce profil, dans PowerShell, vous pourrez également le faire. Cela étant dit, il serait logique que vous modifiiez le raccourci situé sous votre profil utilisateur, par exemple, C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell .

Cliquez avec le bouton droit et cliquez sur les propriétés. Cliquez sur le bouton “Avancé” sous l’onglet “Raccourci” situé juste en dessous du champ de texte “Commentaires” à droite de deux autres boutons, “Ouvrir l’emplacement du fichier” et “Changer d’icône”, respectivement.

Cochez la case “Exécuter en tant qu’administrateur”. Cliquez sur OK , puis sur Appliquer et sur OK . Cliquez à nouveau avec le bouton droit de la souris sur l’icône “Windows PowerShell” située dans C:\Users\"username"\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Windows PowerShell et sélectionnez “Pin to Start Menu / Taskbar”.

Maintenant, chaque fois que vous cliquez sur cette icône, elle appelle le contrôle de compte d’utilisateur pour l’escalade. Après avoir sélectionné «OUI», vous remarquerez que la console PowerShell est ouverte et qu’elle sera intitulée «Administrateur» en haut de l’écran.

Pour aller plus loin, vous pouvez cliquer avec le bouton droit sur le même raccourci d’icône dans l’emplacement de votre profil de Windows PowerShell et atsortingbuer un raccourci clavier qui fera exactement la même chose que si vous cliquiez sur l’icône récemment ajoutée. Donc, où il est dit “Shortcut Key”, placez une combinaison de touches / boutons du clavier comme: Ctrl + Alt + P P (pour PowerShell) . Cliquez sur Appliquer et sur OK .

Il ne vous rest plus qu’à appuyer sur la combinaison de boutons que vous avez assignée et vous verrez que l’UAC sera invoqué. Après avoir sélectionné “OUI”, vous verrez apparaître une console PowerShell et “Administrateur” dans la barre de titre.

Vous pouvez également forcer l’application à s’ouvrir en tant qu’administrateur. Si vous avez un compte administrateur bien sûr.

entrer la description de l'image ici

Recherchez le fichier, cliquez avec le bouton droit de la souris> Propriétés> Raccourci> Avancé et cochez Exécuter en tant qu’administrateur

Cliquez ensuite sur OK.

Un certain nombre de réponses ici sont proches, mais un peu plus de travail que nécessaire.

Créez un raccourci vers votre script et configurez-le sur “Exécuter en tant qu’administrateur”:

  • Créez le raccourci.
  • Cliquez avec le bouton droit sur raccourci et ouvrez Properties...
  • Modifier la Target de vers powershell
  • Cliquez sur Avancé ... et activez Run as administrator

Ce comportement est inhérent à la conception. Il existe plusieurs niveaux de sécurité, Microsoft ne souhaitant pas que les fichiers .ps1 soient le dernier virus de messagerie. Certaines personnes trouvent que cela va à l’encontre de la notion même d’automatisation des tâches, qui est juste. Le modèle de sécurité Vista + consiste à “désautomatiser” les choses, ce qui permet à l’utilisateur de les accepter.

Cependant, je suppose que si vous lancez powershell lui-même comme étant élevé, il devrait pouvoir exécuter des fichiers de commandes sans demander à nouveau le mot de passe jusqu’à ce que vous fermiez le fichier powershell.

Une autre solution plus simple est que vous pouvez également cliquer avec le bouton droit sur “C: \ Windows \ System32 \ cmd.exe” et choisir “Exécuter en tant qu’administrateur”. Vous pouvez alors exécuter n’importe quelle application en tant qu’administrateur sans fournir de mot de passe.

J’ai trouvé un moyen de faire ça …

Créez un fichier de commandes pour ouvrir votre script:

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

Créez ensuite un raccourci, sur votre bureau, par exemple (cliquez avec le bouton droit sur Nouveau -> Raccourci ).

Ensuite, collez-le dans l’emplacement:

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

Lors de la première ouverture, vous devrez entrer votre mot de passe une fois. Cela va ensuite l’enregistrer dans le gestionnaire d’informations d’identification Windows.

Après cela, vous devriez pouvoir fonctionner en tant qu’administrateur sans avoir à entrer un nom d’utilisateur ou un mot de passe administrateur.

Le problème avec les réponses @pgk et @Andrew Odri est lorsque vous avez des parameters de script, en particulier quand ils sont obligatoires. Vous pouvez résoudre ce problème en utilisant l’approche suivante:

  1. L’utilisateur clique avec le bouton droit sur le fichier .ps1 et sélectionne “Exécuter avec PowerShell”: demandez-lui les parameters via les zones de saisie (cette option est bien meilleure que l’utilisation de l’atsortingbut de paramètre HelpMessage );
  2. L’utilisateur exécute le script via la console: lui permettre de passer les parameters souhaités et laisser la console le forcer à renseigner les parameters obligatoires.

Voici comment serait le code si le script avait les parameters obligatoires ComputerName et Port :

 [CmdletBinding(DefaultParametersetName='RunWithPowerShellContextMenu')] param ( [parameter(ParameterSetName='CallFromCommandLine')] [switch] $CallFromCommandLine, [parameter(Mandatory=$false, ParameterSetName='RunWithPowerShellContextMenu')] [parameter(Mandatory=$true, ParameterSetName='CallFromCommandLine')] [ssortingng] $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]::ToBase64Ssortingng($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() { [ssortingng] $script:ComputerName = [Microsoft.VisualBasic.Interaction]::InputBox('Enter a computer name:', 'Testing Network Connection') if ($script:ComputerName -eq '') { throw 'The computer name is required.' } [ssortingng] $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 

En plus de la réponse de Shay Levy, suivez la configuration ci-dessous (juste une fois)

  1. Démarrez un PowerShell avec des droits d’administrateur.
  2. Suivez la question sur le débordement de la stack PowerShell dit que «l’exécution des scripts est désactivée sur ce système» .
  3. Placez votre fichier .ps1 dans l’un des dossiers PATH , par exemple. Dossier Windows \ System32

Après l’installation:

  1. Appuyez sur Win + R
  2. Appelez powershell Start-Process powershell -Verb runAs

Vous pouvez maintenant tout exécuter en une seule ligne de commande. Ce qui précède fonctionne sur Windows 8 Basic 64 bits.

La manière la plus fiable que j’ai trouvée est de l’envelopper dans un fichier .bat auto-élévateur:

 @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 

Le .bat vérifie si vous êtes déjà administrateur et relance le script en tant qu’administrateur si nécessaire. Il empêche également l’ouverture de fenêtres “cmd” étrangères avec le 4ème paramètre de ShellExecute() défini sur 0 .

J’utilise la solution ci-dessous. Il gère stdout / stderr via la fonctionnalité de transcription et transmet le code de sortie correctement au processus parent. Vous devez ajuster le chemin d’access / nom du fichier de transcription.

 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 

Je n’ai pas vu ma propre façon de le faire avant, alors, essayez ceci. Il est beaucoup plus facile à suivre et a une empreinte beaucoup plus réduite:

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

Très simplement, si la session Powershell en cours a été appelée avec des privilèges d’administrateur, le SID connu du groupe Administrateur apparaîtra dans les groupes lorsque vous récupérerez l’identité actuelle. Même si le compte est membre de ce groupe, le SID ne s’affiche pas, sauf si le processus a été appelé avec des informations d’identification élevées.

Presque toutes ces réponses sont une variante de la méthode extrêmement populaire de Microsoft Ben Armstrong, qui consiste à comprendre comment accomplir ce travail et à émuler la même routine.

Pour append la sortie de la commande à un nom de fichier texte contenant la date du jour, vous pouvez faire quelque chose comme ceci:

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

Ceci est une clarification …

Les informations d’identification RUNAS / SAVECRED de powershell “ne sont pas sûres” l’ont essayé et il ajoute l’identité et le mot de passe d’administrateur dans le cache des informations d’identification et peut être utilisé ailleurs. Si vous avez fait cela, je vous suggère de vérifier et de supprimer l’entrée.

Examinez votre programme ou code car la stratégie de Microsoft est que vous ne pouvez pas avoir un code utilisateur et administrateur mixte dans le même object blob de code sans le contrôle de compte d’utilisateur (le point d’entrée) pour exécuter le programme en tant qu’administrateur. Ce serait sudo (même chose) sous Linux.

L’UAC a 3 types, ne voyez pas, une invite ou un point d’entrée généré dans le manifeste du programme. Il n’élève pas le programme donc s’il n’y a pas de UAC et qu’il a besoin d’admin, il échouera. Bien que l’administrateur ait besoin d’un bon contrôle de compte d’utilisateur, il empêche l’exécution de code sans authentification et empêche l’exécution du scénario de codes mixtes au niveau de l’utilisateur.

Ajouter mes 2 cents. Ma version simple basée sur net session qui fonctionne tout le temps jusqu’à présent dans Windows 7 / Windows 10. Pourquoi le compliquer?

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

ajoutez simplement en haut du script et il fonctionnera en tant qu’administrateur.

Il s’avère que c’était trop facile. Tout ce que vous avez à faire est de lancer un cmd en tant qu’administrateur. Ensuite, tapez explorer.exe et appuyez sur Entrée. Cela ouvre Windows Explorer . Maintenant, cliquez avec le bouton droit sur votre script PowerShell que vous souhaitez exécuter, choisissez “exécuter avec PowerShell” qui le lancera dans PowerShell en mode administrateur.

Il se peut que vous deviez activer la stratégie pour exécuter, tapez Y et appuyez sur Entrée. Maintenant, le script s’exécutera dans PowerShell en tant qu’administrateur. Dans le cas où tout fonctionne en rouge, cela signifie que votre politique n’a pas encore pris effet. Puis réessayez et ça devrait bien marcher.