Usuario:Luis.perez/sistemaspyaytozgz/windows

Administración de Windows con python

Python for Windows extensions: PyWin32

Es un wrapper alrededor del api win32 implementado con SWIG.

Instalación de pywin32

a) versión 214 con pip (versión antigua de hace 3 años) b) versión reciente, 218, desde http://sourceforge.net/projects/pywin32/files/pywin32/Build%20218/pywin32-218.win32-py3.3.exe/download

• Usaremos la versión más reciente, con python 3.3

WINSYS

https://github.com/tjguk/winsys

• Wrapper alrededor de pywin32 para hacerla más "pythonic"

Documentación

Documentación del módulo Winsys: http://timgolden.me.uk/python/winsys/contents.html

Tip: La documentación no es muy exhaustiva, por lo que es aconsejable tener a mano el propio código de Winsys

Instalación

• Instalar pip (instalar distribute primero)
  • Descargar e instalar distribute http://python-distribute.org/distribute_setup.py

 
   $ python distribute_setup.py
 

• • Descargar e instalar pip https://raw.github.com/pypa/pip/master/contrib/get-pip.py

 
   $ python get-pip.py
 

• Instalar PyWin32
• Instalar Winsys

$ pip install WinSys-3.x

Características comunes del api

• La mayoría de clases extienden de core._WinsysObject
• dump _WinSysObject tiene un método dump que devuelve una representación de las estructuras internas del objeto. Ej:

reg = registry.registry(r"HKLM\Software\View\Gvim")
>>> reg.dump()
{
  HKLM\Software\View\Gvim
  access: 983103
}

• Funciones a nivel de módulo: Normalmente, si una clase de un módulo tiene un método, suele existir uno correspondiente a nivel del módulo, a fin de facilitar el uso cuando no se desea tener que crear u obtener el objeto. Ejemplo:

reg = registry.registry(r"HKLM\Software\View\Gvim")
reg.delete()
# en lugar de lo anterior, podemos hacer directamente:
registry.delete(r"HKLM\Software\View\Gvim")

• Métodos factoría: Existen métodos a nivel de módulo para obtener instancias de objetos. Ej:

reg = registry.registry(r"HKLM\Software\View\Gvim")
# además de 
reg = registry.Registry(r"HKLM\Software\View\Gvim")

Módulo security

Módulo que da acceso y gestiona las ACLs de objetos (ficheros, claves del registro...). Implementa la clase Security.

Obtener el objeto Security

• Puede hacerse mediante la función security:

from winsys import security
sec = security.security(r"c:\windows")

• o mediante el método security de algunos objetos

f = fs.file ("test")
sec = f.security()

Listas de control de acceso

sec = security.security(r"c:\windows")
print(sec.dacl.dump())

Podemos añadir nuevos permisos:

sec.dacl.append((security.me(), "F", "ALLOW"))

Constantes:

 ACCESS = {
   u"R" : constants.GENERIC_ACCESS.READ,
   u"W" : constants.GENERIC_ACCESS.WRITE,
   u"X" : constants.GENERIC_ACCESS.EXECUTE,
   u"C" : constants.GENERIC_ACCESS.READ | constants.GENERIC_ACCESS.WRITE | constants.GENERIC_ACCESS.EXECUTE,
   u"F" : constants.GENERIC_ACCESS.ALL
 }

Suplantar permisos de usuario

with security.impersonate ("Administrator", "password"):
  print(security.me())

Api del registro de windows

obtener una key del registro

new_key = registry.registry (r"HKLM\Software\Vim\Gvim")
 
base = registry.registry(r"HKLM\Software")
gvim2 = base + "Gvim" # se puede usar el operador + para concatenar

obtener subkey

subk = base.gvim

iterator de keys

for key in base.keys():
	print(key) #key es de tipo registry

obtener padre:

parent = key.parent()
parent = registry.parent(key)

copiar una key del registro

new_key = registry.copy (r"HKLM\Software\Vim\Gvim", r"HKLM\Software\Vim\Gvim2")

crear una key

gvim2.create("subkey")
registry.create(gvim2, "subkey")

eliminar una key

gvim2.delete("subkey")
# alternativo: registry.delete(gvim2, "subkey")
gvim2.delete()
#alternativo: registry.delete(gvim2)

asignar valores del registro

new_key.myvalue = 5
new_key.set_value('myvalue', 2)

obtener valores del registro

print("Obteniendo valores dentro de una key")
avalue = new_key.myvalue
avalue = new_key.get_value('myvalue')

obtener valores del registro

for name, value in new_key.values():
	print("name: {}, value: {}".format(name, value))
 
values_dict = dict(new_key.values())

walk dentro de una clave (similar a lo que hace os.walk para ficheros y directorios

for key, subkeys, values in base.walk():
	#key es de tipo registry
	#subkeys es una iterator de tipo registry
	#values es un iterator de tuplas nombre-valor
	pass

Add permisos totales a un usuario

try:
	with new_key.security () as sec:
		sec.break_inheritance (copy_first=False)
		sec.dacl.append((accounts.user("luis"), "F", "ALLOW"))
finally:
	new_key.security().dump ()

Api del entorno de windows

from winsys import environment

Entorno del usuario

>>>> environment.user()
{'TMP': 'C:\\Documents and Settings\\luis\\Temp', 'TEMP':'C:\\Documents and Settings\\luis\\Temp'}

Entorno del sistema

>>>> environment.system()
'NUMBER_OF_PROCESSORS': '1', 'PROCESSOR_IDENTIFIER': 'x86 Family 6 Model 42 Stepping 7, GenuineIntel', 
'PATHEXT': '.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH', 
'windir': 'C:\\WINDOWS', 'PROCESSOR_LEVEL': '6', 'FP_NO_HOST_CHECK': 'NO', 
'ComSpec': 'C:\\WINDOWS\\system32\\cmd.exe', 'Path': 'C:\\Python33\\;C:\\WINDOWS\\system32;C:\\WINDOWS;C:\\WINDOWS\\System32\\Wbem;C:\\Python33\\Scripts;C:\\C
...

La modificación de ambos diccionarios actualiza los entornos

Gestión de usuarios y grupos

Obtención de listado de usuarios

users = accounts.users()

Obtención de un usuario

user = accounts.user("luis")

Creación de un usuario

accounts.User.create("luis2", "mypassword")

atención: El usuario no se incluye en ningún grupo

Eliminación de un usuario

accounts.user("luis2").delete()

También un objeto Princpal puede usarse:

accounts.principal("luis2").delete()

Obtención de listado de grupos

groups = accounts.local_groups()

Obtención de un grupo

group = accounts.group("Administradores")

ó

group = accounts.local_group("Administradores")

Creación de un grupo

group = accounts.LocalGroup("MyCustomGroup")

Eliminación de un grupo

accounts.local_group("MyCustomGroup").delete()

Asociación de un usuario a un grupo

user = accounts.user("luis2")
group = accounts.local_group("Usuarios")
group.add(user)

Atención: En la última versión de Winsys parece haber un bug en el api de la clase accounts.User. Aunque existe el método join, el siguiente código no funcionará, debido a que join busca el grupo con accounts.group, el cual devuelve un objeto de tipo Group, no LocalGroup, que no tiene el método add para añadir el usuario a sus miembros:

user = accounts.user("luis2")
user.join("Usuarios") # Error!

Eliminación de un usuario de un grupo

user = accounts.user("luis2")
group = accounts.local_group("Usuarios")
group.remove(user)

Igual que en el caso de añadir usuarios a grupos, el método leave de la clase User presenta el mismo problema que join

Obtener el usuario que está ejecutando el proceso

user = accounts.me()

Actuar como otro usuario

user = accounts.user("luis")
with user:
  # ejecutar proceso, modificar archivos...

Tip: En el tutorial sobre accounts se puede apreciar el import

 
from __future__ import with_statement

Es innecesario para versiones de python > 2.5

Windows Management Instrumentation: WMI

• Wrapper alrededor de pywin32 para acceder al api WMI

Documentación

Documentación del módulo WMI para python: http://timgolden.me.uk/python/wmi/contents.htmlhttp://python.org/doc Documentación sobre WMI en MSDN: http://msdn2.microsoft.com/en-us/library/aa394582.aspx

Instalación

http://pypi.python.org/pypi/WMI/#downloads

• Puede instalarse ejecutando el exe instalador, o bien haciendo

python setup.py install

Sobre los sources descargados.

Obtención del interfaz

Basta con importar wmi e invocar a su método WMI.

import wmi
 
c = wmi.WMI ()
for i in c.classes:
    print(i)

• Como se ve en el ejemplo, se puede obtener información deº qué clases de WMI expone.
• Para acceder a una de esas clases:

c = wmi.WMI ()
for os in c.Win32_OperatingSystem(): # Siempre devuelve una lista, aunque sepamos que hay un solo objeto
  print(os.Caption)

• También se puede acceder a una máquina remota:

c = wmi.WMI("maquinaremota")

• Para poder conectar con otro user/pass:

c = wmi.WMI("MyOtherMachine", user=r"MyOtherMachine\luis", password="mypassword")

ó

remote_connetion = wmi.connect_server (
  server="MyOtherMachine", user="luis", password="mypassword"
)
c = wmi.WMI(wmi=remote_connection)

• Para conocer atributos del objeto:

c = wmi.WMI ()
for os in c.Win32_OperatingSystem(): 
  print(os.properties)
  print(os.methods)

• Se pueden filtrar los objetos que se devuelven, pasando valores de propiedades del objeto:

c = wmi.WMI ()
for disk in c.Win32_LogicalDisk(Caption="E:"):
  print(disk) # devolverá solo la unidad "E:"

• Se puede obtener directamente un objeto conociendo su moniker

disks = wmi.WMI(moniker="//./root/cimv2:Win32_LogicalDisk")

• ...y obtener un objeto filtrado:

disks = wmi.WMI(moniker='//./root/cimv2:Win32_LogicalDisk.Description="Mi unidad de red"')

• Usar una consulta WQL

c = wmi.WMI()
wql = "SELECT Caption, Description FROM Win32_LogicalDisk WHERE DriveType <> 3"
for disk in c.query(wql):
  print(disk)

Gestión de procesos

Listar procesos

c = wmi.WMI ()
for process in c.Win32_Process ():
  print process.ProcessId, process.Name

Filtrar lista de procesos

for process in c.Win32_Process("firefox.exe"):
  print("firefox pid: {}".format(process.ProcessId))

Crear un proceso

c = wmi.WMI ()
process_id, return_value = c.Win32_Process.Create(CommandLine="firefox.exe")

Matar un proceso

for process in c.Win32_Process("firefox.exe"):
  result = process.terminate()

o por pid (el anterior ejemplo matará todos los procesos de firefox):

for process in c.Win32_Process(processId=2132):
  result = process.terminate()

Gestión de paquetes

Listado

c = wmi.WMI()
for prod in c.Win32_Product():
   print(prod)

Filtrado

c = wmi.WMI()
for prod in c.Win32_Product(Name="Python 2.7"):
   print(prod)

Instalación

c.Win32_Product.Install(AllUsers=True, PackageLocation="c:\Downloads\Python-2.7.msi")

Desinstalación

c = wmi.WMI()
for prod in c.Win32_Product(Name="Python 2.7"):
   prod.Uninstall()