web-dev-qa-db-fra.com

Script batch: comment vérifier les droits d'administrateur

Comment vérifier si le script de lot en cours a des droits d'administrateur?

Je sais comment l'appeler lui-même avec les runas mais pas comment vérifier les droits d'administrateur. Les seules solutions que j'ai vues sont des travaux de piratage grossiers ou des programmes externes. Eh bien, en fait, je me moque de savoir s’il s’agit d’un travail hack, tant que cela fonctionne sous Windows XP et plus récent.

windowsbatch-filecmdadmin
256
flacs

Problèmes

La solution de blak3r / Rushyo fonctionne bien pour tout, sauf Windows 8. Si vous exécutez AT sous Windows 8, vous obtenez:

The AT command has been deprecated. Please use schtasks.exe instead.

The request is not supported.

(voir capture d'écran n ° 1) et retournera %errorLevel%1.

Recherche

J'ai donc cherché d'autres commandes nécessitant des autorisations élevées. rationallyparanoid.com avait une liste de quelques-uns, alors j'ai exécuté chaque commande sur les deux extrêmes opposés des systèmes d'exploitation Windows actuels (XP et 8) dans l'espoir de trouver une commande dont l'accès serait refusé aux deux Les systèmes d'exploitation lorsqu'ils sont exécutés avec des autorisations standard.

Finalement, j'en ai trouvé un - NET SESSION. Une vraie , solution propre et universelle qui ne comporte pas:

  • la création ou l'interaction de données dans des emplacements sécurisés
  • analyse des données renvoyées par les boucles FOR
  • recherche de chaînes pour "Administrateur"
  • using AT (Windows 8 incompatible) ou WHOAMI (Windows XP incompatible).

Chacune d’entre elles a ses propres problèmes de sécurité, d’utilisabilité et de portabilité.

Essai

J'ai indépendamment confirmé que cela fonctionne sur:

  • Windows XP, x86
  • Windows XP, x64
  • Windows Vista, x86
  • Windows Vista, x64
  • Windows 7, x86
  • Windows 7, x64
  • Windows 8, x86
  • Windows 8, x64

(voir capture d'écran n ° 2)

Mise en oeuvre/utilisation

Donc, pour utiliser cette solution, faites simplement quelque chose comme ceci:

@echo off
goto check_Permissions

:check_Permissions
    echo Administrative permissions required. Detecting permissions...

    net session >nul 2>&1
    if %errorLevel% == 0 (
        echo Success: Administrative permissions confirmed.
    ) else (
        echo Failure: Current permissions inadequate.
    )

    pause >nul

Disponible ici, si vous êtes paresseux: https://dl.dropbox.com/u/27573003/Distribution/Binaries/check_Permissions.bat

Explication

NET SESSION est une commande standard utilisée pour "gérer les connexions de l'ordinateur serveur. Utilisé sans paramètre, il affiche des informations sur toutes les sessions avec l'ordinateur local."

Alors, voici le processus de base de ma mise en œuvre donnée:

  1. @echo off
    • Désactiver l'affichage des commandes
  2. goto check_Permissions
    • Aller au bloc de code :check_Permissions
  3. net session >nul 2>&1
    • Exécuter la commande
    • Masquer la sortie visuelle de commande par
      1. Redirection du flux de sortie standard (poignée numérique 1/STDOUT) vers nul
      2. Redirection du flux de sortie d'erreur standard (identificateur numérique 2/STDERR) vers la même destination que l'identificateur numérique 1
  4. if %errorLevel% == 0
    • Si la valeur du code de sortie (%errorLevel%) est 0, cela signifie que aucune erreur ne s'est produite et, par conséquent, la commande immédiatement précédente a été exécutée avec succès
  5. else
    • Si la valeur du code de sortie (%errorLevel%) n’est pas 0, cela signifie que des erreurs se sont produites et, par conséquent, la commande précédente immédiate a été exécutée sans succès
  6. Le code entre les parenthèses respectives sera exécuté en fonction des critères remplis

Captures d'écran

Windows 8 AT%errorLevel% :

[imgur]

NET SESSION sous Windows XP x86 - Windows 8 x64 :

[imgur]

Merci, @Tilka, d'avoir modifié votre réponse acceptée à la mienne. :)

431
mythofechelon

La solution d'Anders a fonctionné pour moi, mais je ne savais pas trop comment l'inverser pour obtenir le contraire (quand vous n'étiez pas administrateur).

Voici ma solution. Il a deux cas, un cas IF et un autre, et des dessins ascii pour s’assurer que les gens le lisent réellement. :)

Version minimale

Rushyo a posté cette solution ici: Comment détecter si CMD s’exécute en tant qu’administrateur/a des privilèges élevés?

NET SESSION >nul 2>&1
IF %ERRORLEVEL% EQU 0 (
    ECHO Administrator PRIVILEGES Detected! 
) ELSE (
    ECHO NOT AN ADMIN!
)

Version qui ajoute un message d'erreur, des pauses et des sorties

@rem ----[ This code block detects if the script is being running with admin PRIVILEGES If it isn't it pauses and then quits]-------
echo OFF
NET SESSION >nul 2>&1
IF %ERRORLEVEL% EQU 0 (
    ECHO Administrator PRIVILEGES Detected! 
) ELSE (
   echo ######## ########  ########   #######  ########  
   echo ##       ##     ## ##     ## ##     ## ##     ## 
   echo ##       ##     ## ##     ## ##     ## ##     ## 
   echo ######   ########  ########  ##     ## ########  
   echo ##       ##   ##   ##   ##   ##     ## ##   ##   
   echo ##       ##    ##  ##    ##  ##     ## ##    ##  
   echo ######## ##     ## ##     ##  #######  ##     ## 
   echo.
   echo.
   echo ####### ERROR: ADMINISTRATOR PRIVILEGES REQUIRED #########
   echo This script must be run as administrator to work properly!  
   echo If you're seeing this after clicking on a start menu icon, then right click on the shortcut and select "Run As Administrator".
   echo ##########################################################
   echo.
   PAUSE
   EXIT /B 1
)
@echo ON

Fonctionne sur WinXP -> Win8 (y compris les versions 32/64 bits).

EDIT: 28/08/2012 Mise à jour pour prendre en charge Windows 8. @BenHooper l'a souligné dans sa réponse ci-dessous. Merci de bien vouloir voter sa réponse.

75
blak3r

Plus de numéros

Comme l'a souligné @Lectrode, si vous essayez d'exécuter la commande net session alors que le service Serveur est arrêté, vous recevez le message d'erreur suivant:

The Server service is not started.

More help is available by typing NET HELPMSG 2114

Dans ce cas, la variable %errorLevel% sera définie sur 2.

Remarque Le service Serveur n'est pas démarré en mode sans échec (avec ou sans mise en réseau).

À la recherche d'une alternative

Quelque chose que:

  • peut être exécuté tel quel sous Windows XP et versions ultérieures (32 et 64 bits);
  • ne touche pas le registre ni aucun fichier/dossier système;
  • fonctionne indépendamment des paramètres régionaux du système;
  • donne des résultats corrects même en mode sans échec.

J'ai donc démarré une machine virtuelle Windows XP de Vanilla et j'ai commencé à faire défiler la liste des applications du dossier C:\Windows\System32, en essayant de trouver des idées. Après des essais et des erreurs, c’est l’approche sale que je propose:

fsutil dirty query %systemdrive% >nul

La commande fsutil dirty nécessite des droits d'administrateur pour s'exécuter, sinon elle échouera. %systemdrive% est une variable d'environnement qui renvoie la lettre du lecteur sur lequel le système d'exploitation est installé. La sortie est redirigée vers nul, donc ignorée. La variable %errorlevel% sera définie sur 0 uniquement si son exécution est réussie.

Voici ce que dit la documentation:

Fsutil sale

Interroge ou définit le bit sale d'un volume. autochk vérifie automatiquement le volume pour détecter d'éventuelles erreurs lors du prochain redémarrage de l'ordinateur.

Syntaxe

fsutil dirty {query | set} <VolumePath>

Paramètres

query           Queries the specified volume's dirty bit.
set             Sets the specified volume's dirty bit.
<VolumePath>    Specifies the drive name followed by a colon or GUID.

Remarques

Un bit sale d'un volume indique que le système de fichiers peut être dans un état incohérent. Le bit sale peut être défini parce que:

  • Le volume est en ligne et il présente des modifications remarquables.
  • Des modifications ont été apportées au volume et l'ordinateur a été éteint avant que les modifications ne soient validées sur le disque.
  • La corruption a été détectée sur le volume.

Si le bit endommagé est défini au redémarrage de l'ordinateur, chkdsk s'exécute pour vérifier l'intégrité du système de fichiers et tenter de résoudre les problèmes liés au volume.

Exemples

Pour interroger le bit modifié sur le lecteur C, tapez:

fsutil dirty query C:

De plus amples recherches

Bien que la solution ci-dessus fonctionne à partir de Windows XP, il convient d'ajouter que Windows 2000 et Windows PE (environnement préinstallé) ne sont pas fournis avec fsutil.exe, nous devons donc recourir à autre chose.

Lors de mes tests précédents, j'avais remarqué que l'exécution de la commande sfc sans aucun paramètre aurait pour résultat:

  • une erreur, si vous n'aviez pas assez de privilèges;
  • une liste des paramètres disponibles et de leur utilisation.

C'est-à-dire: pas de paramètres, pas de parti . L'idée est que nous pouvons analyser la sortie et vérifier si nous obtenons autre chose qu'une erreur:

sfc 2>&1 | find /i "/SCANNOW" >nul

La sortie d'erreur est d'abord redirigée vers la sortie standard, qui est ensuite acheminée vers la commande find. À ce stade, nous devons rechercher le paramètre uniquement qui est pris en charge dans toutes les versions de Windows depuis Windows 2000: /SCANNOW. La recherche est insensible à la casse et la sortie est supprimée en la redirigeant vers nul.

Voici un extrait de la documentation:

Sfc

Analyse et vérifie l'intégrité de tous les fichiers système protégés et remplace les versions incorrectes par les versions correctes.

Remarques

Vous devez être connecté en tant que membre du groupe Administrateurs pour exécuter sfc.exe .

Exemple d'utilisation

Voici quelques exemples de collage:

Windows XP et versions ultérieures

@echo off

call :isAdmin
if %errorlevel% == 0 (
echo Running with admin rights.
) else (
echo Error: Access denied.
)

pause >nul
exit /b

:isAdmin
fsutil dirty query %systemdrive% >nul
exit /b

Windows 2000/Windows PE

@echo off

call :isAdmin
if %errorlevel% == 0 (
echo Running with admin rights.
) else (
echo Error: Access denied.
)

pause >nul
exit /b

:isAdmin
sfc 2>&1 | find /i "/SCANNOW" >nul
exit /b

S'applique à

  • Windows 2000
  • Windows XP
  • Windows Vista
  • Windows 7
  • Windows 8
  • Windows 8.1
    ---
  • Windows PE
37
and31415

une autre façon

fltmc >nul 2>&1 && (
  echo has admin permissions
) || (
  echo has NOT admin permissions
)

La commande fltmc est disponible sur tous les systèmes Windows depuis XP. Elle devrait donc être assez portable.

Une autre solution testée sur XP, 8.1, 7 (malheureusement ne fonctionne pas sur toutes les machines win10 - voir les commentaires.) - il existe une variable spécifique =:: qui n'est présenté que si la session de console n'a pas de privilèges d'administrateur. Comme il n'est pas si facile de créer une variable qui contient = dans son nom, il s'agit d'un moyen relativement fiable de vérifier les droits d'administrateur (et assez rapidement n'appelle pas les exécutables externes)

setlocal enableDelayedExpansion
set "dv==::"
if defined !dv! ( 
   echo has NOT admin permissions
) else (
   echo has admin permissions
)
17
npocmaka
>nul 2>&1 "%SYSTEMROOT%\system32\cacls.exe" "%SYSTEMROOT%\system32\config\system"&&(
 echo admin...
)
17
Anders

solution alternative:

@echo off
pushd %SystemRoot%
openfiles.exe 1>nul 2>&1
if not %errorlevel% equ 0 (
    Echo here you are not administrator!
) else (
    Echo here you are administrator!
)
popd
Pause
14
Lucretius

Non seulement vérifier mais OBTENIR les droits d'administrateur automatiquement
aussi appelé UAC automatique pour Win 7/8/8.1 ff.: Ce qui suit est vraiment cool avec une fonctionnalité supplémentaire: Cet extrait de lot ne vérifie pas seulement les droits d'administrateur, mais les obtient automatiquement! (et teste avant si vous utilisez un système d'exploitation compatible UAC.)

Avec cette astuce, vous n’avez pas besoin de plus de temps pour cliquer correctement sur votre fichier batch "avec des droits d’administrateur". Si vous avez oublié, pour commencer avec des droits élevés, UAC apparaît automatiquement! De plus, au début, il est testé, si le système d'exploitation a besoin/fournit un contrôle de compte d'utilisateur, afin qu'il se comporte correctement, par exemple. pour Win 2000/XP jusqu'à Win 8.1 - testé.

@echo off
REM Quick test for Windows generation: UAC aware or not ; all OS before NT4 ignored for simplicity
SET NewOSWith_UAC=YES
VER | FINDSTR /IL "5." > NUL
IF %ERRORLEVEL% == 0 SET NewOSWith_UAC=NO
VER | FINDSTR /IL "4." > NUL
IF %ERRORLEVEL% == 0 SET NewOSWith_UAC=NO


REM Test if Admin
CALL NET SESSION >nul 2>&1
IF NOT %ERRORLEVEL% == 0 (

    if /i "%NewOSWith_UAC%"=="YES" (
        rem Start batch again with UAC
        echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs"
        echo UAC.ShellExecute "%~s0", "", "", "runas", 1 >> "%temp%\getadmin.vbs"
        "%temp%\getadmin.vbs"
        del "%temp%\getadmin.vbs"
        exit /B
    )

    rem Program will now start again automatically with admin rights! 
    rem pause
    goto :eof
)

L'extrait de code fusionne de bons modèles de traitement par lots, en particulier (1) le test admin de ce thread par Ben Hooper et (2) l'activation du contrôle de compte d'utilisateur lue sur BatchGotAdmin et citée sur le site de traitement par batch par robvanderwoude (respect). (3) Pour l'identification du système d'exploitation par "motif VER | FINDSTR", je ne trouve pas la référence.)

(En ce qui concerne certaines restrictions très mineures, lorsque "NET SESSION" ne fonctionne pas comme indiqué dans une autre réponse, n'hésitez pas à insérer une autre de ces commandes. Pour moi, exécuter en mode sans échec Windows ou des services standard spéciaux en panne ne constitue pas un cas d'utilisation important. - pour certains administrateurs, peut-être qu'ils le sont.)

13
Philm

J'ai deux moyens de vérifier les accès privilégiés, les deux sont assez fiables et très portables dans presque toutes les versions de Windows.

1. Méthode

set guid=%random%%random%-%random%-%random%-%random%-%random%%random%%random%

mkdir %WINDIR%\%guid%>nul 2>&1
rmdir %WINDIR%\%guid%>nul 2>&1

IF %ERRORLEVEL%==0 (
    ECHO PRIVILEGED!
) ELSE (
    ECHO NOT PRIVILEGED!
)

C'est l'une des méthodes les plus fiables, en raison de sa simplicité, et le comportement de cette commande très primitive a très peu de chances de changer. Ce n'est pas le cas d'autres outils CLI intégrés tels que net session qui peuvent être désactivés par des stratégies d'administration/réseau ou des commandes telles que fsutils qui ont modifié la sortie sous Windows 10. .

* Fonctionne sur XP et versions ultérieures

2. Méthode

REG ADD HKLM /F>nul 2>&1

IF %ERRORLEVEL%==0 (
    ECHO PRIVILEGED!
) ELSE (
    ECHO NOT PRIVILEGED!
)

Parfois, l’idée de toucher le disque de l’utilisateur ne vous plait pas, même si c’est aussi inoffensif que d’utiliser fsutils ou de créer un dossier vide, cela n’est pas démontable, mais cela peut entraîner une défaillance catastrophique en cas de problème. Dans ce scénario, vous pouvez simplement vérifier les privilèges du registre.

Pour cela, vous pouvez essayer de créer une clé sur HKEY_LOCAL_MACHINE en utilisant les autorisations par défaut que vous obtiendrez Accès refusé et le ERRORLEVEL == 1, mais si vous vous exécutez en tant qu'administrateur, il va imprimer "commande exécutée avec succès" et ERRORLEVEL == 0. Comme la clé existe déjà, elle n’a aucun effet sur le registre. C'est probablement le moyen le plus rapide, et le REG est là depuis longtemps.

* Ce n'est pas disponible sur les versions antérieures à NT (Win 9X).

* Fonctionne sur XP et versions ultérieures

Exemple de travail

Un script qui efface le dossier temporaire

@echo off
:main
    echo.
    echo. Clear Temp Files script
    echo.

    call :requirePrivilegies

    rem Do something that require privilegies

    echo. 
    del %temp%\*.*
    echo. End!

    pause>nul
goto :eof


:requirePrivilegies
    set guid=%random%%random%-%random%-%random%-%random%-%random%%random%%random%
    mkdir %WINDIR%\%guid%>nul 2>&1
    rmdir %WINDIR%\%guid%>nul 2>&1
    IF NOT %ERRORLEVEL%==0 (
        echo ########## ERROR: ADMINISTRATOR PRIVILEGES REQUIRED ###########
        echo # This script must be run as administrator to work properly!  #
        echo # Right click on the script and select "Run As Administrator" #
        echo ###############################################################
        pause>nul
        exit
    )
goto :eof
11
Vitim.us

Le moyen le plus propre de vérifier les privilèges d'administrateur à l'aide d'un script CMD, que j'ai trouvé, ressemble à ceci:

@echo off

REM  Calling verify with no args just checks the verify flag,
REM   we use this for its side effect of setting errorlevel to zero
verify >nul

REM  Attempt to read a particular system directory - the DIR
REM   command will fail with a nonzero errorlevel if the directory is
REM   unreadable by the current process.  The DACL on the
REM   c:\windows\system32\config\systemprofile directory, by default,
REM   only permits SYSTEM and Administrators.
dir %windir%\system32\config\systemprofile >nul 2>nul

REM  Use IF ERRORLEVEL or %errorlevel% to check the result
if not errorlevel 1 echo has Admin privs
if     errorlevel 1 echo has only User privs

Cette méthode utilise uniquement les commandes intégrées CMD.exe, elle devrait donc être très rapide. Il vérifie également les capacités réelles du processus plutôt que de rechercher les SID ou les appartenances à un groupe. L'autorisation effective est donc testée. Et cela fonctionne aussi loin que Windows 2003 et XP. Les processus utilisateur normaux ou les processus non générés échouent dans l'exploration d'annuaire, à la différence des processus d'administration ou élevés.

6
William

Ce qui suit tente de créer un fichier dans le répertoire Windows. Si cela réussit, il sera supprimé.

copy /b/y NUL %WINDIR%\06CF2EB6-94E6-4a60-91D8-AB945AE8CF38 >NUL 2>&1
if errorlevel 1 goto:nonadmin
del %WINDIR%\06CF2EB6-94E6-4a60-91D8-AB945AE8CF38 >NUL 2>&1
:admin
rem here you are administrator
goto:eof
:nonadmin
rem here you are not administrator
goto:eof

Notez que 06CF2EB6-94E6-4a60-91D8-AB945AE8CF38 est un GUID qui a été généré aujourd'hui et qu'il est improbable qu'il entre en conflit avec un nom de fichier existant.

5
Benoit

Dans le script batch Elevate.cmd (voir ) ce lien ), pour lequel j'ai écrit obtenir les droits d'administrateur , je l'ai fait de la manière suivante:

:checkPrivileges
  NET FILE 1>NUL 2>NUL
  if '%errorlevel%' == '0' ( goto gotPrivileges ) else ( goto getPrivileges )

Ceci est testé pour Windows 7, 8, 8.1, 10 et même Windows XP et ne nécessite aucune ressource telle qu'un répertoire spécial, un fichier ou une clé de registre .

5
Matt

Les whoami/groupes ne fonctionnent pas dans un cas. Si le contrôle de compte d'utilisateur est totalement désactivé (pas seulement la notification désactivée), et vous avez démarré à partir d'une invite de l'administrateur, puis émis:

runas /trustlevel:0x20000 cmd

vous exécuterez non-élevé, mais en émettant:

whoami /groups

dira que tu es élevé. C'est faux. Voici pourquoi c'est faux:

Lors de l'exécution dans cet état, si IsUserAdmin ( https://msdn.Microsoft.com/en-us/library/windows/desktop/aa376389 (v = vs.85) .aspx ) renvoie FALSE et Le contrôle de compte d'utilisateur est entièrement désactivé et GetTokenInformation renvoie TokenElevationTypeDefault ( http://blogs.msdn.com/b/cjacks/archive/2006/10/24/modifying-the- mandatory-integrity-level-for-a- securable-object-in-windows-Vista.aspx ) le processus est alors non surélevé, mais whoami /groups le prétend .

vraiment, la meilleure façon de faire cela à partir d'un fichier batch est:

net session >nul 2>nul
net session >nul 2>nul
echo %errorlevel%

Vous devez faire net session deux fois parce que si quelqu'un fait un at avant, vous obtiendrez des informations erronées.

4
zumalifeguard

Certains serveurs désactivent les services requis par la commande "net session". Il en résulte que la vérification de l'administrateur indique toujours que vous ne possédez pas de droits d'administrateur lorsque vous en avez.

2
Dan

Edit: copyitright a fait remarquer que cela n’est pas fiable. L’approbation de l’accès en lecture avec UAC permettra à dir de réussir. J'ai un peu plus de script pour offrir une autre possibilité, mais ce n'est pas en lecture seule.

reg query "HKLM\SOFTWARE\Foo" >NUL 2>NUL && goto :error_key_exists
reg add "HKLM\SOFTWARE\Foo" /f >NUL 2>NUL || goto :error_not_admin
reg delete "HKLM\SOFTWARE\Foo" /f >NUL 2>NUL || goto :error_failed_delete
goto :success

:error_failed_delete
  echo Error unable to delete test key
  exit /b 3
:error_key_exists
  echo Error test key exists
  exit /b 2
:error_not_admin
  echo Not admin
  exit /b 1
:success
  echo Am admin

Ancienne réponse ci-dessous

Attention: non fiable

Sur la base d’un certain nombre d’autres bonnes réponses ici et des points soulevés par and31415, j’ai découvert que je suis fan de ce qui suit:

dir "%SystemRoot%\System32\config\DRIVERS" 2>nul >nul || echo Not Admin

Peu de dépendances et rapide.

2
Tyler Szabo
whoami /groups | find "S-1-16-12288" > nul
if not errorlevel 1 (
  echo ...  connected as admin
)
2
Totonga

PowerShell quelqu'un?

param (
    [string]$Role = "Administrators"
)

#check for local role

$identity  = New-Object Security.Principal.WindowsIdentity($env:UserName)
$principal = New-Object Security.Principal.WindowsPrincipal($identity)

Write-Host "IsInRole('$Role'): " $principal.IsInRole($Role)

#enumerate AD roles and lookup

$groups = $identity::GetCurrent().Groups
foreach ($group in $groups) {
    $trans = $group.Translate([Security.Principal.NTAccount]);
    if ($trans.Value -eq $Role) {
       Write-Host "User is in '$Role' role"
    }
}
1
Ostati

Remarque: La vérification de\system32\config\system avec cacls échouera TOUJOURS dans WOW64 (par exemple, à partir de% systemroot%\syswow64\cmd.exe/Total Commander 32 bits), de sorte que les scripts exécutés dans un shell 32 bits en système 64 bits seront automatiquement mis en boucle. ... Mieux vaut vérifier les droits sur le répertoire Prefetch:

>nul 2>&1 "%SYSTEMROOT%\system32\cacls.exe" "%SYSTEMROOT%\Prefetch\"

Win XP à 7 testés, mais cela échoue dans WinPE car dans Windows 7 install.wim, il n’existe pas de tel répertoire ni cacls.exe.

Également dans winPE AND wow64, la vérification avec openfiles.exe échoue:

OPENFILES > nul

Sous Windows 7, le niveau d'erreur sera "1" avec l'info suivante: "Le système cible doit être un système d'exploitation 32 bits"

Les deux vérifications échoueront probablement également dans la console de récupération.

Ce qui fonctionne dans Windows XP - 8 32/64 bits, dans WOW64 et dans WinPE sont: des tests de création de répertoires (SI l'administrateur n'a pas tapé le répertoire Windows bombardé avec des autorisations pour tout le monde. ..) et

net session

et

reg add HKLM /F

chèques.

De plus, une note supplémentaire dans certaines fenêtres XP (et d'autres versions probablement, en fonction du bricolage de l'administrateur), en fonction des entrées de registre appelant directement le script bat/cmd à partir du script .vbs échouera, indiquant que les fichiers bat/cmd ne sont pas associé à rien ...

echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs"
echo UAC.ShellExecute "%~s0", "", "", "runas", 1 >> "%temp%\getadmin.vbs"
cscript "%temp%\getadmin.vbs" //nologo

L'appel de cmd.exe avec le paramètre du fichier bat/cmd fonctionne correctement:

echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs"
echo UAC.ShellExecute "cmd.exe", "/C %~s0", "", "runas", 1 >> "%temp%\getadmin.vbs"
cscript "%temp%\getadmin.vbs" //nologo
1
user2902818

Des douzaines de réponses à cette question et à d'autres questions liées et ailleurs chez SE, toutes déficientes de cette manière ou d'une autre, ont clairement montré que Windows ne fournit pas un utilitaire de console intégré fiable. Alors, il est temps de déployer le vôtre.

Le code C suivant, basé sur Détecter si le programme est exécuté avec des droits d'administrateur complets , fonctionne dans Win2k +1, n'importe où et dans tous les cas (UAC, domaines, groupes transitifs ...) - car il fait la même chose que le système lui-même lorsqu'il vérifie les autorisations. Il signale le résultat à la fois avec un message (qui peut être désactivé avec un commutateur) et un code de sortie.

Il ne doit être compilé qu’une seule fois, vous pouvez alors copier le .exe partout - cela ne dépend que de kernel32.dll et advapi32.dll (J'ai téléchargé une copie ).

chkadmin.c: 

#include <malloc.h>
#include <stdio.h>
#include <windows.h>
#pragma comment (lib,"Advapi32.lib")

int main(int argc, char** argv) {
    BOOL quiet = FALSE;
    DWORD cbSid = SECURITY_MAX_SID_SIZE;
    PSID pSid = _alloca(cbSid);
    BOOL isAdmin;

    if (argc > 1) {
        if (!strcmp(argv[1],"/q")) quiet=TRUE;
        else if (!strcmp(argv[1],"/?")) {fprintf(stderr,"Usage: %s [/q]\n",argv[0]);return 0;}
    }

    if (!CreateWellKnownSid(WinBuiltinAdministratorsSid,NULL,pSid,&cbSid)) {
        fprintf(stderr,"CreateWellKnownSid: error %d\n",GetLastError());exit(-1);}

    if (!CheckTokenMembership(NULL,pSid,&isAdmin)) {
        fprintf(stderr,"CheckTokenMembership: error %d\n",GetLastError());exit(-1);}

    if (!quiet) puts(isAdmin ? "Admin" : "Non-admin");
    return !isAdmin;
}

1MSDN affirme que les API sont XP +, mais c'est faux. CheckTokenMembershipest 2k + et l'autre est encore plus vieux . Le dernier lien contient également une manière beaucoup plus compliquée qui fonctionnerait même dans NT.

1
ivan_pozdeev

En voici un autre à ajouter à la liste ;-)

(tenter une création de fichier à l'emplacement du système)

CD.>"%SystemRoot%\System32\Drivers\etc\_"
MODE CON COLS=80 LINES=25

IF EXIST "%SystemRoot%\System32\Drivers\etc\_" (

  DEL "%SystemRoot%\System32\Drivers\etc\_"

  ECHO Has Admin privileges

) ELSE (

  ECHO No Admin privileges

)

MODE CON réinitialise l'écran et supprime le texte/les erreurs sans l'autorisation d'écrire dans l'emplacement système.

1
script'n'code

Je pense que le moyen le plus simple est d'essayer de changer la date du système (qui nécessite des droits d'administrateur):

date %date%
if errorlevel 1 (
   echo You have NOT admin rights
) else (
   echo You have admin rights
)

Si la variable %date% peut inclure le jour de la semaine, obtenez simplement la date de la dernière partie de la commande DATE:

for /F "delims=" %%a in ('date ^<NUL') do set "today=%%a" & goto break
:break
for %%a in (%today%) do set "today=%%a"
date %today%
if errorlevel 1 ...
0
Aacini
@echo off
ver
set ADMDIR=C:\Users\Administrator
dir %ADMDIR% 1>nul 2>&1
echo [%errorlevel%] %ADMDIR%
if "%errorlevel%"=="0" goto main
:: further checks e.g. try to list the contents of admin folders
:: wherever they are stored on older versions of Windows
echo You need administrator privileges to run this script: %0
echo Exiting...
exit /b

:main
echo Executing with Administrator privileges...
0
cmd

Net User %username% >nul 2>&1 && echo admin || echo not admin

0
heretic
@echo off
:start
set randname=%random%%random%%random%%random%%random%
md \windows\%randname% 2>nul
if %errorlevel%==0 (echo You're elevated!!!
goto end)
if %errorlevel%==1 (echo You're not elevated :(:(
goto end)
goto start
:end
rd \windows\%randname% 2>nul
pause >nul

Je vais expliquer le code ligne par ligne:

@echo off

Les utilisateurs seront ennuyés avec beaucoup plus de 1 lignes sans cela.

:start

Point où le programme commence.

set randname=%random%%random%%random%%random%%random%

Définissez le nom de fichier du répertoire à créer.

md \windows\%randname% 2>nul

Crée le répertoire sur <DL>:\Windows (remplace <DL> par la lettre du lecteur).

if %errorlevel%==0 (echo You're elevated!!!
goto end)

Si la variable d'environnement ERRORLEVEL est égale à zéro, alors echo message de réussite.
Allez à la fin (ne continuez pas).

if %errorlevel%==1 (echo You're not elevated :(:(
goto end)

Si ERRORLEVEL est un, renvoyez le message d'échec et allez à la fin.

goto start

Si le nom de fichier existe déjà, recréez le dossier (sinon, la commande goto end ne le laissera pas s'exécuter).

:end

Spécifiez le point d'arrivée

rd \windows\%randname% 2>nul

Supprimer le répertoire créé.

pause >nul

Faites une pause pour que l'utilisateur puisse voir le message.

Note: Le >nul et 2>nul filtrent la sortie de ces commandes.

0
EKons

Alternative: utilisez un utilitaire externe conçu à cet effet, par exemple, IsAdmin.exe (logiciel gratuit non restreint).

Codes de sortie:

0 - Utilisateur actuel non membre du groupe Administrateurs

1 - Utilisateur actuel membre des administrateurs et en cours d'exécution élevée

2 - Utilisateur actuel membre des administrateurs, mais n'exécutant pas élevé

0
Bill_Stewart

J'ai trouvé un utilisateur qui peut utiliser net session même s'ils ne sont pas admin. Je n'ai pas cherché pourquoi. Ma solution consiste à vérifier si l'utilisateur peut créer un dossier dans le dossier Windows.

Voici mon code:

::::::: :testadmin function START :::::::
:: this function tests if current user is admin.  results are returned as "true" or "false" in %isadmin%
:: Test "%isadmin" after calling this function
:: Usage: "call :testadmin"
echo Your script entered the :testadmin function by error.  Usage: "call :testadmin"
pause
exit /b
:testadmin

 rd %windir%\local_admin_test > nul 2> nul
 md %windir%\local_admin_test > nul 2> nul
 if [%errorlevel%]==[0] set isadmin=true
 if not [%errorlevel%]==[0] set isadmin=false
 rd %windir%\local_admin_test > nul 2> nul

 if [%isadmin%]==[true] (
   echo User IS admin.
 )
 if not [%isadmin%]==[true] (
   echo User IS NOT admin.
   timeout 30
   :: or use "pause" instead of "timeout"
   exit /b
 )
exit /b
:::::: :testadmin function END ::::::
0
Grallen