Droits d'administrateur d'un utilisateur

Version imprimable

06/07/2018, 06h35
bonjourajax

Droits d'administrateur d'un utilisateur

Bonjour,

Sur certains programmes ecris en python puis compilé en exe.
sur une machine sous windows10 -x64 :roll:

Une fois lancés, certaines taches ne s'effectuent que si le programme est lancé en tant qu'administrateur
(par exemple ajouter/modifier des fichiers ou l'utilisateur normal n'aurait pas les droits c:/... ou faire diverses autres intéractions)

Mais pourtant l'utilisateur en question a les droits pour tout faire en tant qu'administrateur donc pourquoi cela coince?
Est ce qu'on peut coder dans le programme quelque chose pour que l'utilisateur élève automatiquement ses privileges puisqu'il en a le droit?
Comment faire apparaitre la fameuse fenetre "le programme doit etre lancé en administrateur confirmer ?"

Question supplémentaire : il y a-t-il un moyen pour que tous les programmes soient lancés en admin (avec un user) sans afficher la fenêtre de confirmation, ni aller chercher le clic droit?
windows c'est bien pour quelques fonctionnalités mais pour le reste c'est autre chose ...:mouarf:
06/07/2018, 07h07
tyrtamos

Citation:

Envoyé par bonjourajax

windows et programmation, j'ai de plus en plus l'impression que ce sont 2 choses totalement incompatibles

Bien sûr que non! Windows fonctionne très bien!

On peut toujours lancer un programme exe en tant qu'administrateur: il suffit de le demander dans "propriété" => "Compatibilité" et de cocher la case "Exécuter ce programme en tant qu'administrateur". Chaque exécution commence donc par la fenêtre habituelle d'élévation des droits. Certains programmes qui doivent accéder à des fichiers système sont faits comme ça (exemple: CCleaner).

Si l'accès administrateur ne porte que sur certaines parties du logiciel, on devrait pouvoir élever les droits de ces parties uniquement avec win32 (module pywin32). A titre de source d'inspiration, il y a déjà eu une ancienne discussion sur ce sujet ici: https://www.developpez.net/forums/d1...-winreg-seven/.

Peut-on lancer un programme en tant qu'administrateur sans la fenêtre d'élévation des droits? Je ne sais pas faire, mais si c'était possible, ce serait très dangereux pour la sécurité de l'OS...
06/07/2018, 17h08
bonjourajax

Merci de tes réponses
Je suis allé voir la discussion aussi
06/07/2018, 23h08
YCL-1

Bonsoir,

Il est possible de créer un simple raccourci en cochant dans l'onglet Compatibilité : « Exécuter ce programme en tant qu'administrateur » ce qui va forcer la demande de privilège admin et afficher l'UAC systématiquement.

Citation:

Envoyé par tyrtamos

Peut-on lancer un programme en tant qu'administrateur sans la fenêtre d'élévation des droits? Je ne sais pas faire, mais si c'était possible, ce serait très dangereux pour la sécurité de l'OS...

Dans certains cas c'est bien pratique, du moment que c'est fait de manière réfléchie et limité à des applications que l'on maîtrise.

Dans mon cas je m'en sers pour des outils de programmation ou des vieilles applications XP.

Pour se faire :
Il faut déclarer l'application dans le planificateur de tâche (taskschd.msc)

À la racine Bibliothèque -> Clic-droit -> Créer une nouvelle tâche

Dans les propriétés générales de la tâche il faut cocher : « Exécuter avec les autorisations maximales » / "Run with highest privileges"
Pas besoin de configurer un déclencheur
Et en Action de créer le démarrage du programme

Puis ensuite il faut créer un raccourci qui va appeler la tâche telle que configurée et sans afficher l'UAC
schtasks /Run /TN "Le nom de la tâche"

Merci pour ces réponses
Quant à la question restante, apres lecture du sujet de discussion proposé par tyrtamos
Je n'ai pas tres bien compris la fin
Citation:
Dans ce cas, et pour intégrer le tout dans le même code, je ne vois qu'un ramdisk ou la création d'un fichier disque temporaire contenant le code.
Soit ici
Code:

1 2 3 4 5 6 7 8 9 10 11 lecode="""import _winreg try: key = _winreg.CreateKey(_winreg.HKEY_CLASSES_ROOT, 'Folder\\shell\\CheckFileFormat') key = _winreg.CreateKey(_winreg.HKEY_CLASSES_ROOT, 'Folder\\shell\\CheckFileFormat\\command') key = _winreg.OpenKey( _winreg.HKEY_CLASSES_ROOT, 'Folder\\shell\\CheckfileFormat\\command',0, _winreg.KEY_SET_VALUE) _winreg.SetValueEx(key, '', 0, _winreg.REG_SZ, '"toto" -i "%1"') _winreg.CloseKey(key) except WindowsError,e: print print 'The key registry is not created'"""
Écriture d'un fichier contenant le code de 'lecode' dans le dossier temporaire du système et faire le windll.shell32.ShellExecuteA avec.
Comment il a fait pour le lancer en admin?

Bonjour,

J'ai un peu creusé la question, et voilà où j'en suis:

Pour obtenir les droits administrateur du programme dans sa totalité, voilà un code qui a l'air de fonctionner:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
"""
Source d'inspiration:
https://stackoverflow.com/questions/19672352/how-to-run-python-script-with-elevated-privilege-on-windows
"""
 
import sys
import os
import ctypes
 
#############################################################################
def administrateur(argv=None):
    """permet d'obtenir les droits administrateur sous Windows
       nb: compatible avec un exécutable "exe" obtenu par PyInstaller
    """
    if sys.platform != "win32":
        return False # on n'est pas sous Windows
 
    if ctypes.windll.shell32.IsUserAnAdmin():
        return True # on a actuellement les droits administrateur
 
    executable = sys.executable
 
    if argv is None:
        argv = sys.argv
    if getattr(sys, 'frozen', False):
        arguments = argv[1:] # programme traité par pyinstaller
    else:
        arguments = argv # programme normal .py
    ligne_args = ' '.join(arguments)
 
    # relance du programme avec les droits administrateur
    ret = ctypes.windll.shell32.ShellExecuteW(None, "runas", executable, ligne_args, None, 1)
    if ret <= 32:
        return False # erreur
 
    # la demande des droits admin a été acceptée dans le programme relancé
    return None
 
#############################################################################
if __name__ == '__main__':
 
    # demande d'obtention des droits administrateur
    ok = administrateur()
 
    if ok is None:
        # les droits admin viennent d'être obtenus: il faut laisser le
        # programme qui vient d'être relancé avec ces droits et arrêter ici
        sys.exit(0)
 
    elif ok:
        print("J'ai les droits administrateur")
        # suite normale du programme qui s'exécute avec les droits administrateur
 
        # tentative de mener une action qui nécessite des droits administrateur
        # suppose ici que "c:" est le drive système et que "c:\test" n'existe pas
        try:
            os.mkdir(r"c:\test")    
        except Exception as msgerr:
            print(msgerr)
 
        x = input("Faites 'entrée' pour sortir")
 
    else:
        raise Exception ("Erreur: je n'ai pas pu obtenir les droits administrateur")

Il y a en fait 3 cas:
- on a déjà les droits administrateur => le programme doit continuer son exécution "normale"
- on vient d'avoir les droits administrateur => il faut arrêter le programme (sys.exit(0)) car il vient d'être relancé avec ces droits!
- on n'a pas obtenu les droits administrateur => erreur et arrêt du programme.

Pour tester, j'ai utilisé une fonction qui nécessite des droits administrateur: la création d'un répertoire sur le disque système C:. Le test demande à ce que le répertoire n'existe pas.

Cela fonctionne pour l'exécution classique d'un code python .py, auquel cas l'exécutable est "python.exe", mais aussi pour l'exécution d'un programme "exe" traité par PyInstaller.

Remarque: comme l’obtention de ces droits nécessite la relance du programme par Windows, il n'est pas prévu que ça puisse s'appliquer à une partie seulement du programme. Sauf si cette partie fait l'objet d'un processus séparé mais je n'ai pas essayé.