• Software
  • Listar software
  • Buscar software
  • Instalar software
  • Desinstalar software
• Actualizaciones
  • Listar actualizaciones
• Antivirus

El software es la parte que no se puede tocar del ordenador (intangible), es un elemento lógico y se define como un conjunto de órdenes e instrucciones que al ejecutarse sirven para realizar alguna tarea (los programas sin ejecutar son simples archivos en disco). Con el software se saca partido al ordenador, sin software el ordenador sería un conjunto de placas, tarjetas y cables sin ninguna utilidad.

Los sistemas operativos instalados programas pero también se pueden instalar otros.

El software se puede dividir en tipos:

• Software de sistema. Conjunto de programas que administran los recursos del ordenador.
• Software de programación. Es el conjunto de herramientas que sirven para crear nuevos programas, éstos se crean utilizando un lenguaje de programación. Un lenguaje de programación es un conjunto de símbolos, reglas sintácticas y semánticas que indican cómo hacer un programa. Todas las órdenes o instrucciones que forman el programa se escriben en unos archivos llamados códigos fuente.
• Software de aplicación. Se refiere a los programas que permiten realizar tareas a los usuarios con conocimientos básicos de informática. Les permite sacar provecho al ordenador y así realizar tareas relacionadas con su actividad como, por ejemplo, escribir un documento, enviar un mail, etc.

En Windows se pueden ejecutar programas de versiones más antiguas.

Cuando se habla de software tenemos que tener en cuenta qué se puede hacer con el mismo:

• Instalar.
• Actualizar.
• Downgrade (devolver el software a una antigua versión).
• Desinstalar.

La instalación y desinstalación de programas es una tarea importante y se tiene que hacer con control, no hay que instalar un programa sin estar seguro de lo que hace, y siempre hay que conocer la fuente de donde proviene el programa.

Los sistemas operativos tienen instalado por defecto multitud de programas que nos permiten realizar gran cantidad de tareas como escribir documentos, escuchar música, navegar por Internet, etc. Sin embargo, esto no es suficiente para la mayoría de los usuarios y es probable que necesiten instalarse nuevos programas como, por ejemplo, un navegador de Internet distinto al que tiene el sistema operativo por defecto, un conjunto de herramientas ofimáticas más completo, etc.

Aunque lo normal es instalar una sola vez un programa, a veces hay algún problema en el programa y es necesario reinstalar algún archivo o el programa entero.

Es importante tener el software correctamente instalado, indentificado y controlar el acceso a los programas por parte de los usuarios.

Las operaciones que se pueden realizar sobre el software son:

• Listar software

Cmdlet

Get-Package

WMI

Get-WmiObject win32_Product
Get-WmiObject -query "select name from win32_product"

Ejemplos

Listar programas instalados

Get-Package | Select-Object Name
(Get-WmiObject -Class Win32_Product).name
Get-WmiObject -query "select name from win32_product" | select Name

Seleccionar el nombre y versión de los programas instalados

Get-Package | Select-Object Name, Version
(Get-WmiObject -Class Win32_Product) | Select-Object name,version

Indicar si hay algún antivirus instalado

((Get-Package).name) | Select-String 'Defender'
((Get-WmiObject -Class Win32_Product).name) | Select-String 'Antivirus'

Número de programas instalados

((Get-Package).name).count
((Get-WmiObject -Class Win32_Product).name).count

Agrupar los programas cuyo nombre sea “Microsoft”

Get-Package | Select-String "Microsoft" | Group-Object
(Get-WmiObject -Class Win32_Product) | Select-String "Microsoft" | Group-Object

Indicar si está instalado Gimp

if(((Get-Package).name) | Select-String "Microsoft"){"Instalado"}
if(((Get-WmiObject -Class Win32_Product).name) | Select-String "Gimp"){"Instalado"}

Agrupa los programas cuyo vendedor sea Microsoft

(Get-WmiObject -Class Win32_Product).vendor | Select-String "Microsoft" | Group-Object

Indicar el número de programas cuyo nombre sea Microsoft (agrupar)

((Get-Package).Name | Select-String "Microsoft" | Group-Object).Count
((Get-WmiObject -Class Win32_Product).vendor | Select-String "Microsoft" | Group-Object).Count

Mostrar programas instalados por familia

((Get-WmiObject -Class Win32_Product).name) | %{$_.split(' ')[0]}

Agrupar por familia los programas instalados

((Get-WmiObject -Class Win32_Product).name) | %{$_.split(' ')[0]} | Group-Object

Indicar cuántos programas hay por familia

((Get-WmiObject -Class Win32_Product).vendor | Group-Object)

Ejercicios

Crear una función que indique si se ha instalado un programa

function ProgramaInstalado($programa)
{
if(((Get-WmiObject -Class Win32_Product).name) | Select-String $programa){"Instalado"}
}

ProgramaInstalado VMware Player

Buscar en el registro información sobre programas

$name='Google'
$producto=(Get-WmiObject -Class Win32_Product)
foreach($uno in $producto)
{
if($uno.name -match $name)
{
$valor=$uno.IdentifyingNumber
$valor=$valor.replace('{','')
$valor=$valor.replace('}','')
}
}
Get-ChildItem hklm:\ -rec -ea SilentlyContinue | % {
if($_ -match $valor){$_}
}

• Buscar software

Cmdlet

Find-Package

Ejemplos

Buscar la herramienta ZoomIt

Find-Package zoomit

• Instalar software

Para instalar programas es necesario controlar el hardware del equipo, el software instalado en el equipo por el tema de incompatibilidades, las versiones y las licencias.

Cmdlet

Install-Package

Ejemplo

Instalar sofware buscándolo previamente

Find-Package zoomit | Install-Package

• Desinstalar software

Cmdlet

Uninstall-Package

Ejemplos

Desinstalar sofware

Uninstall-Package zoomit

Actualizaciones

Cada día aparecen nuevas vulnerabilidades en los sistemas operativos y en los programas, es importante mantener el sistema operativo actualizado con los últimos parches de seguridad.

Las actualizaciones sirven para evitar problemas o corregirlos, de esta forma el sistema operativo se mantiene seguro. Las actualizaciones son necesarias para los sistemas operativos.

Los sistemas de gestión de actualizaciones permiten que éstas se descarguen y se instalen con orden, de no ser así podrían aparecer problemas si el sistema operativo comenzara a descargar todas las actualizaciones a la vez, en algunos casos pueden llegar a saturar ciertos recursos como, por ejemplo, la conexión de red. Para resolver este problema algunos sistemas operativos tienen programas que descargan las actualizaciones y las envían a otros ordenadores a la red de una manera ordenada.

Gracias a los sistemas de actualizaciones, el tiempo que va desde que se registra un fallo hasta que se corrige es muy pequeño.

Las actualizaciones pueden ser del sistema operativo, de programas, de controladores, etc.

• Listar actualizaciones

Cmdlet

Get-HotFix
Get-Package

Ejemplos

Ver el nombre de las actualizaciones

Get-HotFix
Get-Package | Select-Object Name | Select-String "Actualización"

Ver el ID de las actualizaciones

Get-HotFix | Select-Object HotFixID

Ver si hay una actualización instalada

$kb=Read-Host ‘NúmeroActualización’
((Get-HotFix).hotfixid | Select-String $kb)

Listar por descripción las actualizaciones instaladas en el equipo

Get-HotFix | Select-Object Description
(Get-HotFix).Description

Agrupar actualizaciones por descripción

Get-HotFix | Group-Object Description
(Get-HotFix).Description | Group-Object

Agrupar actualizaciones por descripción y mostrar el nombre de la agrupación

(Get-HotFix | Group-Object Description).Name

Listar por fecha las actualizaciones instaladas en el equipo

Get-HotFix | Sort-Object InstalledOn

Antivirus

Uno de los programas principales es el antivirus.

El antivirus que se utiliza en Windows es Windows Defender.

Examinar el equipo en busca de virus

Start-MpScan

Ver las últimas definiciones del antivirus

(Get-MpThreatCatalog).ThreatName

Ver últimos escaneos

(Get-MpComputerStatus).FullScanEndTime
(Get-MpComputerStatus).FullScanStartTime
(Get-MpComputerStatus).QuickScanEndTime
(Get-MpComputerStatus).QuickScanStartTime

Última actualización de firmas

(Get-MpComputerStatus).NISSignatureLastUpdated
(Get-MpComputerStatus).AntivirusSignatureLastUpdated

Última actualización del Antispayware

(Get-MpComputerStatus).AntispywareSignatureLastUpdated

Actualizar las definiciones en el antivirus

Update-MpSignature

The post 5. Gestión del software en PowerShell appeared first on Scripting and security.

• Procesos
  • Tabla de procesos
  • Estados de un proceso
  • Crear procesos
  • Matar procesos
  • Procesador
  • Hilos
  • Servicios

Uno de los conceptos más importantes en los sistemas operativos es el proceso que se define como un programa en ejecución. Los programas son un conjunto de archivos que están almacenados en algún dispositivo de almacenamiento (disco duro, USB, etc.) y que por sí solos no tienen ningún funcionamiento, pero cuando ese conjunto de archivos se ejecutan entonces pasan a ser un proceso.

Procesos

El sistema operativo se encarga de: crear y destruir procesos, suspender y reanudar procesos, y sincronizar y comunicar procesos.

Información sobre procesos

Cmdlets

Get-Process

WMI

Get-WmiObject -Class win32_process

Alias

ps
gps

Ejemplos

Obtener información básica sobre procesos

Get-Process

Obtener información ampliada sobre procesos

Get-Process | Select-Object *
gps | Select-Object *
ps | Select-Object *

Obtener información sobre las propiedades de los procesos

Get-Process | Select-Object Name, Id, Company
gps | Select-Object Name, Id, Company
ps | Select-Object Name, Id, Company

Obtener información ordenada sobre las propiedades de los procesos

Get-Process | Select-Object Name, Id, Company | Sort-Object Name
gps | Select-Object Name, Id, Company | Sort-Object Name
ps | Select-Object Name, Id, Company | Sort-Object Name

Obtener los 5 primeros procesos ordenados

Get-Process | Select-Object Name, Id, Company | Sort-Object Name | Select-Object -First 5
gps | Select-Object Name, Id, Company | Sort-Object Name | Select-Object -First 5
ps | Select-Object Name, Id, Company | Sort-Object Name | Select-Object -First 5

Listar los nombres de procesos que se están ejecutando

ps | select Name

Listar los procesos junto el fabricante

ps | select Name,Company

Información sobre la ruta de los procesos

(ps) | %{if($_.path){(Get-ChildItem $_.path | select VersionInfo)}}

Mostrar información sobre un proceso indicando el nombre del proceso

Get-Process -Name notepad

Buscar procesos que no responden

(Get-Process).Where{-not $_.Responding}

Buscar un proceso que se está ejecutando

(Get-Process).Where{$_.Name -like "chrome"}

Módulos que se ejecutan en los procesos

Get-Process -Module
ps -Module

Abrir Notepad y listar las dll que están cargadas cuando se ejecuta, ver la ruta dónde se ejecutan

Get-Process -Name notepad -Module

Información sobre la ruta de los módulos de los procesos

ls (ps -Module | Select-Object Filename).Filename | Select VersionInfo | Format-Custom

Listar todas las propiedades de un proceso en concreto proceso utilizando WMI

(Get-WmiObject win32_process) | Where-Object processName -eq notepad.exe

Mostrar los procesos que ejecuta un usuario

(Get-Process).Threads | Select-Object Id,ThreadState | Sort-Object Id

Ejercicios

Contar el número de procesos que se están ejecutando en el sistema

(Get-Process).count
(Get-WmiObject Win32_OperatingSystem).NumberOfProcesses

Sacar las dll y realizar función hash

Get-Process -Module | Select-Object FileName | %{Write-Host $_.FileName, (Get-FileHash $_.FileName)}

Sacar las dll y realizar función hash para el proceso Notepad

Get-Process -Name notepad -Module | Select-Object FileName | %{Write-Host $_.FileName, (Get-FileHash $_.FileName)}

Ver los programas que se arrancan cuando un usuario inicia sesión.

Get-WmiObject -Class win32_startupCommand

• Tabla de procesos

Cuando un proceso se ejecuta, el sistema operativo le asigna un espacio de direcciones y lo añade a una tabla de procesos. El espacio de direcciones de cada proceso contiene las instrucciones y datos del programa, además tiene una pila que lleva la cuenta de las llamadas a procedimientos.

Los procesos se dividen en partes. Estas partes son las que se llevan a la memoria dependiendo de la técnica de gestión que se utilice: paginación, segmentación, intercambio, memoria virtual, etc.

La tabla de procesos contiene información de cada uno de los procesos que se están ejecutando. El contenido de una entrada (hay una entrada por cada proceso) en la tabla de procesos puede ser el siguiente:

• Identificador del proceso. Es un número que utiliza el sistema operativo para identificar los procesos de forma única, se conoce por la abreviatura PID (Process ID).
• Información del estado del proceso. Preparado, en ejecución o bloqueado.
• Prioridad. El sistema operativo puede asignar distinta importancia a cada proceso.
• Dirección de la memoria. Zona de la memoria donde se ha cargado el proceso.
• Directorio de trabajo. Directorio del usuario que ejecuta el programa.
• Tiempo utilizado por el procesador. Tiempo que el proceso se ha estado ejecutando en el procesador.

Ejemplos

Listar la siguiente información sobre los procesos:

• La cantidad de memoria no paginada que el proceso está utilizando, en kilobytes (NPM).
• La cantidad de memoria paginable que el proceso está utilizando, en kilobytes (PM).
• El tamaño del conjunto de trabajo del proceso, en kilobytes. El conjunto de trabajo se compone de las páginas de memoria que hace poco se hace referencia mediante el proceso (WS).
• La cantidad de memoria virtual que el proceso está utilizando, en megabytes. La memoria virtual incluye el almacenamiento de los archivos de paginación en el disco (VM).
• La cantidad de tiempo de procesador que el proceso se ha utilizado en todos los procesadores, en cuestión de segundos (CPU).

Get-Process | Select-Object NPM,PM,WS,VM,CPU

Listar los procesos que tengan consumo alto de tiempo de CPU

Get-Process | select cpu,id,name | sort cpu -Descending

Mostrar el tiempo transcurrido en la ejecución de un proceso

Get-Process | Select-Object Id,TotalProcessorTime

Mostrar información sobre un proceso indicando el ID del proceso

Get-Process -Id 2732

Mostrar los identificadores de los procesos junto con sus identificadores padre

Get-WmiObject win32_process | Select-Object ParentProcessId,ProcessId

Ejercicio

Mostrar los procesos cuya zona de memoria para trabajar es mayor que 100 MB

#WS(K): The size of the working set of the process, in kilobytes. The working set consists of the pages of memory that were recently referenced by the process
@(Get-Process).where{$_.WorkingSet -gt 100MB}
@(Get-Process).where{$_.WS -gt 100MB}

• Estados de un proceso

Los procesos cuando se ejecutan pueden atravesar distintos estados desde que se inician hasta que finalizan. Cuando un proceso se inicia, primero se mete en una cola de trabajos; cuando es admitido por el sistema, pasa a una cola de procesos que están preparados y esperando para ejecutarse; cuando el procesador asigna tiempo de ejecución, el proceso pasa de estar preparado a ejecución, y cuando el proceso necesita alguna señal o dato, pasa al estado bloqueado (se lo introduce en la cola de bloqueados).

• Crear procesos

Los procesos se pueden crear de varias formas:

• Cuando se arranca el sistema operativo, éste ejecuta procesos necesarios para llevar a cabo distintas funciones.
• Por petición de un usuario del sistema, escribiendo un comando en una línea de comandos o pulsando encima de algún icono.
• Cuando un proceso hace una llamada al sistema para crear un nuevo proceso (para crear un proceso en Windows se utiliza función «CreateProcess()», en Linux se utiliza la llamada «fork()»).

En PowerShell se pueden arrancar procesos de la siguientes formas:

• Iniciar un proceso con un cmdlet

Cmdlet

Start-Process

Alias

saps
start

Ejemplo

Iniciar el programa Notepad

Start-Process notepad

• Invocar un cmdlet

Cmdlet

Invoke-Expression

Ejemplo

Invocar el cmdlet Get-Process

$str = "Get-Process"
Invoke-Expression $str

• Crear un bloque e invocarlo.

Cmdlet

Invoke-Command

Ejemplo

Invocar la ejecución del programa Ping

$scriptblock = {ping host3}
Invoke-Command -scriptblock $scriptblock

• Matar procesos

Igual que existen formas de crear procesos, también existen varias formas de acabar con los procesos:

• El proceso acaba de ejecutarse de forma normal.
• El proceso ha sufrido un error.
• Por petición de un usuario del sistema, escribiendo un comando en una línea de comandos o pulsando encima de algún icono.
• Cuando un proceso hace una llamada al sistema para acabar con un proceso (para terminar con un proceso en Windows se utiliza la función «ExitProcess()» y en Linux la llamada «kill()»).

Hay varias formas de parar un proceso en PowerShell:

• Matar un proceso con un cmdlet

Cmdlet

Stop-Process

Alias

spps
kill

Ejemplo

Parar un proceso de distintas formas

Get-Process -Name notepad | Stop-Process

• Parar un proceso mediante mediante una invocación a un método WMI

Get-WmiObject -Class Win32_Process -Filter “name=’notepad.exe'” | Invoke-WmiMethod -Name Terminate

• Para un proceso mediante el método Kill

Get-Process -Name notepad | ForEach-Object -Process {$_.Kill()}

Ejercicio

Parar procesos de forma gráfica

Get-Process | Out-GridView -PassThru | Stop-Process

• Procesador

Los procesos se pueden ejecutar casi concurrentemente (ejecución simultánea de varios procesos) por el procesador, incluso cuando sólo se dispone de un procesador, dando la sensación de casi paralelismo, aunque el verdadero paralelismo sólo se da con múltiples procesadores o con procesadores con varios núcleos (cada núcleo puede ejecutar un proceso), con un solo procesador se cambia tan rápido de un proceso a otro que nos da esa sensación de paralelismo, esto se denomina multiprogramación.

Cualquier proceso que se está ejecutando puede suspender por la ocurrencia de un evento determinado, por ejemplo, que otro proceso se tenga que ejecutar, una interrupción, etc.

Cuando un proceso tiene que parar y dejar pasar a otro se produce un cambio de contexto, se guarda el contexto del proceso que se estaba ejecutando y se ejecuta el contexto del nuevo proceso. El contexto de un proceso contiene información para que el sistema operativo pueda gestionar el proceso.

Cmdlets con llamadas WMI

Utilización de CPU

Get-WmiObject Win32_PerfFormattedData_PerfOS_Processor

Información detallada de procesos en el procesador

Get-WmiObject Win32_PerfRawData_PerfProc_Process

Carga del procesador

Get-WmiObject Win32_Processor

Ejemplo

Ver la carga del procesador

Get-WmiObject Win32_Processor | Select-Object LoadPercentage

• Hilos

Un proceso tiene miniprocesos que se llaman hilos, la razón de dividir un proceso en unidades más pequeñas es que la mayoría de los procesos están realizando varias acciones a la vez (leer del disco, esperar un clic del ratón, etc.) y puede ser que alguna de esas acciones se bloquee y deje bloqueado al proceso completo.

Utilizando los hilos, el bloqueo sólo se produce en una parte y no todo el proceso, esto quiere decir que otros hilos se pueden seguir ejecutando sin problema.

Algunas características de los hilos:

• Los procesos crean hilos.
• Los hilos tienen prioridad.
• Se pueden ver los hilos que se ejecutan.
• Se pueden ver las prioridades de los hilos.
• Se pueden relacionar hilos con procesos y servicios.

Listado de hilos que se están ejecutando

WMI

Get-WmiObject -Class Win32_Thread

Ejemplos

Proceso que crea un hilo

(Get-WmiObject -Class Win32_Thread).ProcessHandle | %{
Get-Process -Id $_
}

Mostrar la prioridad de los hilos de los procesos

(Get-WmiObject -Class Win32_Thread) | Select-Object ProcessHandle,Priority,PriorityBase | Sort-Object ProcessHandle
(Get-Process).Threads | Select-Object Id,CurrentPriority,BasePriority | Sort-Object Id

Conocer el estado de los hilos de los procesos

(Get-WmiObject -Class Win32_Thread) | Select-Object ProcessHandle,ThreadState | Sort-Object ProcessHandle
(Get-Process).Threads | Select-Object Id,ThreadState | Sort-Object Id

Ejercicios

Mostrar los hilos que se están ejecutando en relación con los servicios y los procesos

$i=0
(Get-WmiObject -Class Win32_Thread) | %{
$i++
Write-Host $i,$_.Handle,$_.ProcessHandle,(Get-WmiObject -Class Win32_Service | Where-Object State -EQ ‘Running’ | Where-Object ProcessId -EQ $_.ProcessHandle),(Get-Process -Id $_.ProcessHandle).ProcessName
}

• Comunicación entre procesos

En ocasiones los procesos tienen que comunicarse unos con otros pasándose información, la forma de comunicarse entre procesos se puede realizar mediante, por ejemplo, zonas de memoria compartida.

Existen algunas situaciones que el sistema operativo debe controlar para que la comunicación entre procesos sea correcta. Una de ellas es asegurar que si un proceso utiliza una zona o archivo compartido, no deje a otros procesos utilizar esos recursos a la vez, es decir, excluir del acceso a otros, esto se conoce como exclusión mutua. La solución es controlar el acceso a la región crítica, que se puede definir como la parte de un programa en la cual se accede a un recurso compartido y donde no debe haber más de un proceso accediendo simultáneamente. Habrá, por tanto, que ordenar y controlar el acceso que hacen los programas a esa región critica, no puede haber dos procesos simultáneamente en sus regiones críticas», entonces si un programa entra en la sección crítica, no permitirá el acceso a otro programa.

• Servicios

Los procesos que se ejecutan pueden estar en primer plano o segundo plano: los de primer plano interactúan con los usuarios, y los de segundo plano o demonios realizan una función específica sin tener que actuar con el usuario (aunque podrían hacerlo).

Los procesos en segundo plano que realizan distintas funciones, algunas relacionadas con el sistema operativo y otras no, se denominan servicios, y se están ejecutando permanentemente en el sistema.

Los servicios se pueden iniciar, detener, pausar, reanudar, etc. Estas acciones, normalmente, sólo las puede realizar el administrador de forma local o remota. Un ejemplo de servicio de sistema es el servicio de escritorio remoto, que permite conectarse remotamente al equipo.

Los servicios ejecutan procesos y los procesos tienen hilos, hay relación entre procesos e hilos y entre servicios e hilos.

Listar todos los servicios

Cmdlet

Get-Service

WMI

Get-WmiObject -Class Win32_Service
Get-WmiObject -query "select * from win32_service"

Ejercicio

Mostrar los servicios que se están ejecutando en relación con los procesos y los hilos

(Get-WmiObject -Class Win32_Service | Where-Object State -EQ ‘Running’) | %{
Write-Host $_.Name,$_.ProcessId,$_.State,(Get-Process -Id $_.ProcessId).Name,(Get-WmiObject -Class Win32_Thread | Where-Object ProcessHandle -EQ $_.ProcessId)
}

The post 7. Gestión de procesos en PowerShell appeared first on Scripting and security.

• Capa física
  • Adaptadores de red
    • Información sobre los adaptadores de red
    • Cambiar el nombre de los adaptadores de red
    • Información transmitida
• Capa de Internet
  • ARP
  •  IP
    • Ver protocolos IP soportados
    • Obtener configuraciones de protocolo IP
    • Obtener direcciones IP del sistema
    • Cambiar dirección IP
    • Habilitar DHCP para obtener la dirección IP
    • Eliminar dirección IP
    • Obtener información desde la tabla de enrutamiento IP
  • ICMP
    • Enviar paquetes ICMP para comprobar conexión
• Capa de transporte
  • TCP
  • UDP
• Capa de aplicación
  • DNS
    • Información sobre las direcciones IP del servidor DNS
    • Cambiar servidores DNS
    • Habilitar DHCP para los servidores DNS
• Diagnóstico de conexiones

Relación de las capas del modelo TCP/IP con PowerShell:

Capa física

La capa de red física especifica las características del hardware que se utilizará para la red. Por ejemplo, la capa de red física especifica las características físicas del medio de comunicaciones. La capa física de TCP/IP describe por ejemplo los estándares de hardware como IEEE 802.3 y la especificación del medio de red Ethernet.

La capa física se refiere a las transformaciones que se le hacen a la secuencia de bits para trasmitirlos de un lugar a otro, los bits se manejan dentro del equipo como niveles eléctricos.

Por ejemplo, puede decirse que en un punto o cable existe un 1 cuando hay presente un determinado nivel de voltaje y un cero cuando su nivel es de 0 voltios.

Cuando se trasmiten los bits siempre se transforman en otro tipo de señales de tal manera que en el punto receptor puede recuperar la secuencia de bits originales.

Los cmdlets relacionados con esta capa

Get-Command -Module NetAdapter

La tarjeta de red, también conocida como adaptador de red, en inglés Network interface controller (NIC), es un componente de hardware que conecta al equipo a una red informática.

Adaptadores de red

• Información sobre los adaptadores de red

Los cmdlets que dan información sobre el hardware de red

Get-NetAdapterHardwareInfo

Get-NetAdapter -Physical

Información sobre los adaptadores mediante WMI

Get-WmiObject -Class Win32_NetworkAdapterConfiguration

Ejemplos

Ver los adaptadores que hay en el sistema

Get-NetAdapter | Select-Object Name, InterfaceDescription

Ver información sobre un adaptador

Get-NetAdapter -Name *Wi-Fi*

Ver información sobre el adaptador (estatus, velocidad)

Get-NetAdapter | ft Name, Status, Linkspeed

Información sobre los drivers

Get-NetAdapter | ft Name, DriverName, DriverVersion, DriverInformation, DriverFileName

• Cambiar el nombre de los adaptadores de red

Los nombres de los adaptadores de red se pueden cambiar pero es necesario ser administrador.

El cmdlet que sirve para cambiar el nombre del adaptador de red

Rename-NetAdapter

Ejemplo

Cambiar el nombre al adaptador

Rename-NetAdapter -Name "Wi-Fi" -NewName "AdaptadorWi-Fi"

• Información transmitida

La cantidad de información (bytes recibidos y transmitidos) que se transmite por la red a traves de la tarjeta de red, se puede conocer mediante el cmdlet

Get-NetAdapterStatistics

Ejemplo

Ver los bytes enviados y recibidos del interfaz Wi-Fi

Get-NetAdapterStatistics -Name Wi-Fi

Capa de Internet

La capa de Internet, también conocida como capa de red o capa IP, acepta y transfiere paquetes para la red. Esta capa incluye el potente Protocolo de Internet (IP), el protocolo de resolución de direcciones (ARP) y el protocolo de mensajes de control de Internet (ICMP).

Los cmdlets relacionados con esta capa

Get-Command -Module NetTCPIP

ARP

Un protocolo de la capa de enlace es ARP que es responsable de encontrar la dirección de hardware (Ethernet MAC) que corresponde a una determinada dirección IP.

Cmdlet para obtener información sobre las direcciones físicas

Get-NetAdapter | Select-Object Name,MacAddress

Cmdlet con llamada WMI para obtener información sobre las direcciones físicas

Get-WmiObject -Class Win32_NetworkAdapterConfiguration | Select-Object Description,MACAddress

El cmdlet que permite obtener las direcciones físicas asociadas

Get-NetNeighbor

Ejemplo

Obtener entradas de la caché para los equipos vecinos con IPv6

Get-NetNeighbor | Where-Object AddressFamily -EQ IPv6

IP

El protocolo IP y sus protocolos de enrutamiento asociados son posiblemente la parte más significativa del conjunto TCP/IP.

Los parámetros de configuración básicos para una red son: la dirección IP, la máscara de red, la puerta de enlace (Gateway) y los DNS.

Veamos brevemente qué es cada parámetro:

• La dirección IP (Internet Protocol, Protocolo de Internet) es un código que identifica una interfaz como única. La interfaz es un dispositivo como una tarjeta de red, un punto de acceso, etc. Hay distintas versiones de direcciones IP:
  • La IPv4 está formada por un número binario de 32 bits que normalmente se representa como 4 números en base decimal del 0 al 255, separados por puntos, por ejemplo la dirección localhost en IPv4 es 127.0.0.1
  • La otra versión es la IPv6 que es un número de 128 bits representado en hexadecimal con 32 dígitos, separados por dos puntos en grupos de 4 dígitos, por ejemplo la direccion localhost en IPv6 es 0:0:0:0:0:0:0:1
• La máscara de red sirve para saber si se deben enviar los datos dentro o fuera de las redes. Por ejemplo, si el sistema operativo tiene la IP 192.168.0.0 y la máscara de red es 255.255.255.0, esto significa que todos los paquetes que no están dirigidos a la red 192.168.0.x irán a la puerta de enlace predeterminada que puede ser la 192.168.0.1.
• Un gateway (puerta de enlace) es un dispositivo que permite interconectar redes con protocolos y arquitecturas diferentes a todos los niveles de comunicación. Su propósito es traducir la información del protocolo utilizado en una red al protocolo usado en la red de destino. El valor de la puerta de enlace es otro de los valores que se deben indicar al configurar la conexión de red.
• Los DNS son direcciones IP que sirven para resolver los nombres de dominio FQDN (Fully Qualified Domain Names) y traducirlos a direcciones IP.

A continuación vemos algunas operaciones con IP:

• Ver protocolos IP soportados

((Get-NetAdapterBinding).DisplayName) -match 'Protocolo de Internet'
(Get-NetIPInterface) | Select-Object InterfaceAlias,AddressFamily

• Obtener configuraciones de protocolo IP

Los cmdlets para obtener las configuraciones del protocolo IP son

Get-NetIPv4Protocol
Get-NetIPv6Protocol

• Obtener direcciones IP del sistema

Los cmdlets para obtener las direcciones IP del sistema son

Get-NetIPConfiguration
Get-NetIPAddress

Ejemplos

Dirección IP del adaptador Wi-Fi

Get-NetAdapter -Name "AdaptadorWi-Fi" | Get-NetIPAddress

Dirección IPv4

Get-NetIPAddress -AddressFamily ipv4
(Get-NetAdapter -Name "Local Area Connection" | Get-NetIPAddress).IPv4Address

Dirección IPv6

Get-NetIPAddress -AddressFamily ipv6

Dirección IPv6 del adaptador Wi-Fi

Get-NetIPAddress -AddressFamily IPv6 -InterfaceAlias Wi-Fi

• Cambiar dirección IP

El cmdlet que sirve para cambiar la dirección IP

New-NetIPAddress

Ejemplos

Cambiar la dirección IPv4 del interfaz WiFi

New-NetIPAddress -InterfaceAlias WiFi -IPAddress 192.168.1.10 -PrefixLength 24 -DefaultGateway 192.168.1.1

Cambiar la dirección IPv6 del interfaz WiFi

New-NetIPAddress –InterfaceAlias "Wi-Fi" –IPAddress 2001::1

• Habilitar DHCP para obtener la dirección IP

El cmdlet que permite habilitar DHCP para la dirección IP

Set-NetIPInterface

Ejemplo

Habilitar DHCP en el interfaz WiFi

Set-NetIPInterface -InterfaceAlias WiFi -Dhcp Enabled

• Eliminar dirección IP

Cmdlet que sirve para eliminar una dirección IP configurada en un interfaz

Remove-NetAddress

Ejemplo

Eliminar una dirección IPv4

Remove-NetIPAddress -IPAddress 192.168.1.10 -DefaultGateway 192.168.1.1

• Obtener información desde la tabla de enrutamiento IP

La tabla de enrutamiento

Get-NetRoute

Ejemplo

Ver la tabla de enrutamiento de IPv4

Get-NetRoute -AddressFamily IPv4

La primera zona roja indica qué hacer con los paquetes que se dirigen a 192.168.1.255. En el caso del equipo (0.0.0.0) utilizando un ARP hace peticiones de sus propios recursos a tratar de llegar a su destino a través de probar su dirección MAC.

La segunda zona roja se define como el destino con 0.0.0.0 cualquier otra cosa que no está incluido en la tabla de enrutamiento. Así que todo 192.168.1.255 al exterior se pone en contacto 192.168.1.1.

ICMP

El ‘Protocolo de Mensajes de Control de Internet’ o ICMP (por sus siglas en inglés de Internet Control Message Protocol) es el sub protocolo de control y notificación de errores del Protocolo de Internet (IP). Como tal, se usa para enviar mensajes de error, indicando por ejemplo que un router o host no puede ser localizado.

El cmdlet que sirve para enviar mensajes ICMP

Test-Connection

Ejemplos

Enviar solicitudes de eco a una IPv4

Test-Connection 127.0.0.1

Enviar solicitudes de eco a una IPv6

Test-Connection 2001::1

Ejercicios

Comprobar la conexión a las direcciones IP que están en un fichero

gc .\ips.txt | %{Test-Connection $_}

Realizar ping a las direcciones IP de un rango

1..254 | %{Test-Connection ('192.168.1.'+$_)}

Realizar ping a las direcciones IP de un rango variando el tercer y cuarto octeto

foreach($tercero in 1..254)
{
    foreach($cuarto in 1..254)
    {
        $ip='192.168.'+$tercero+'.'+$cuarto
        ping $ip
    }
}

Realizar ping a las direcciones IP de un rango y comprobar si están o no activas

1..254 | %{Test-Connection ('192.168.1.'+$_) -Quiet}

Obtener la dirección MAC de cada IP de un rango

1..254|%{$ip="192.168.1."+$_;$ip;(NetNeighbor $ip).LinkLayerAddress}

Capa de transporte

La capa de transporte TCP/IP garantiza que los paquetes lleguen en secuencia y sin errores, al intercambiar la confirmación de la recepción de los datos y retransmitir los paquetes perdidos. Los protocolos de capa de transporte de este nivel son el Protocolo de control de transmisión (TCP) y el Protocolo de datagramas de usuario (UDP). El protocolo TCP proporciona un servicio completo y fiable. UDP proporciona un servicio de datagrama poco fiable.

Los cmdlets relacionados con esta capa

Get-Command -Module NetTCPIP

TCP

TCP permite a las aplicaciones comunicarse entre sí como si estuvieran conectadas físicamente. TCP envía los datos en un formato que se transmite carácter por carácter, en lugar de transmitirse por paquetes discretos.

Cmdlet para ver ajustes TCP

Get-NetTCPSetting

Cmdlet para obtener información sobre las estadísticas de conexión actuales TCP

Get-NetTCPConnection

Cmdlet para ver puertos TCP utilizados

Get-NetTCPConnection | Select-Object LocalPort,Remoteport

EjemploS

Listar puertos TCP abiertos

Get-NetTCPConnection | Select-Object LocalPort

Estado de las conexiones TCP

Get-NetTCPConnection | Select-Object LocalAddress,LocalPort,RemoteAddress,RemotePort,State

UDP

UDP proporciona un servicio de entrega de datagramas. UDP no verifica las conexiones entre los hosts transmisores y receptores. Dado que el protocolo UDP elimina los procesos de establecimiento y verificación de las conexiones, resulta ideal para las aplicaciones que envían pequeñas cantidades de datos.

Cmdlet para ver ajustes UDP

Get-NetUDPSetting

Cmdlet para obtener información sobre las estadísticas de conexión actuales UDP

Get-NetUDPEndpoint

Cmdlet para ver puertos UDP utilizados

(Get-NetUDPEndpoint).LocalPort

Ejemplo

Listar puertos UDP abiertos

Get-NetUDPEndpoint | Select-Object LocalPort

Capa de aplicación

La capa de aplicación define las aplicaciones de red y los servicios de Internet estándar que puede utilizar un usuario. Estos servicios utilizan la capa de transporte para enviar y recibir datos.

Existen varios protocolos de capa de aplicación. En la lista siguiente se incluyen ejemplos de protocolos de capa de aplicación, algunos ejemplos son:

• Servicios TCP/IP estándar como los comandos ftp, tftp y telnet.
• Servicios de nombres, como NIS o el sistema de nombre de dominio (DNS).
• Servicios de directorio (LDAP).

Vemos en detalle el servicio de nombres DNS

DNS

El sistema de nombre de dominio (DNS) es el servicio de nombres que proporciona Internet para las redes TCP/IP. DNS proporciona nombres de host al servicio de direcciones IP. También actúa como base de datos para la administración del correo.

Los cmdlets relacionados con DNS

Get-Command -Module DnsClient

El sistema de nombres de dominio​ (DNS, por sus siglas en inglés, Domain Name System) es un sistema de nomenclatura jerárquico descentralizado para dispositivos conectados a redes IP como Internet o una red privada. Este sistema asocia información variada con nombre de dominio asignado a cada uno de los participantes.

El cmdlet que sirve para la resolución de nombres

Resolve-DnsName

Ejemplo

Resolver el dominio microsoft.com utilizando los servidores DNS

Resolve-DnsName microsoft.com
Resolve-DnsName www.microsoft.com

El cmdlet que sirve para borra el contenido de la caché del cliente DNS

Clear-DnsClientCache

• Información sobre las direcciones IP del servidor DNS

El cmdlet que sirve para ver direcciones servidores DNS

Get-DnsClientServerAddress

Ejemplos

Obtener las direcciones IP del servidor DNS se configuran en todas las interfaces de un equipo

Get-DnsClientServerAddress

Ver las direcciones de los servidores DNS del adaptador Wi-Fi

Get-NetAdapter -Name "AdaptadorWi-Fi" | Get-DnsClientServerAddress

• Cambiar servidores DNS

El cmdlet que sirve para cambiar los servidores DNS

Set-DNSClientServerAddress

Ejemplo

Cambiar los servidores DNS

Set-DNSClientServerAddress –interfaceAlias WiFi –ServerAddresses ("192.168.1.5","192.168.1.6")

• Habilitar DHCP para los servidores DNS

El cmdlet que sirve para habilitar el DHCP en DNS

Set-DNSClientServerAddress -InterfaceAlias Wifi -ResetServerAddress

Diagnóstico de conexiones

Existen cmdlets para diagnosticar conexiones de red, el principal cmdlet es

Test-NetConnection

Muestra información de diagnóstico para una conexión, se pueden realizar varias pruebas con el cmdlet dependiendo de los parámetros de entrada y la salida se puede incluir los resultados de búsqueda de DNS, lista de interfaces IP, reglas IPsec, resultados de selección de dirección de ruta / fuente y / o confirmación de establecimiento de conexión.

Ejemplo

Realizar una prueba de la conectividad ping con resultados detallados

Test-NetConnection -InformationLevel "Detailed"

The post 9. Gestión de la red en PowerShell appeared first on Scripting and security.

(0..5 | ForEach-Object { '{0:x}{1:x}' -f (Get-Random -Minimum 0 -Maximum 15),(Get-Random -Minimum 0 -Maximum 15)})  -join ':'

The post Generar direcciones MAC con PowerShell appeared first on Scripting and security.

using System;
using System.Management.Automation;  // Windows PowerShell namespace.

namespace HostPS1
{
    class HostPS1
    {
        static void Main(string[] args)
        {

            // Call the PowerShell.Create() method to create an
            // empty pipeline.
            PowerShell ps = PowerShell.Create();

            // Call the PowerShell.AddCommand(string) method, add
            // the Get-Process cmdlet to the pipeline. Do
            // not include spaces before or after the cmdlet name
            // because that will cause the command to fail.
            ps.AddCommand("Get-Process");

            Console.WriteLine("Process                 Id");
            Console.WriteLine("----------------------------");


            // Call the PowerShell.Invoke() method to run the
            // commands of the pipeline in the default runspace.
            foreach (PSObject result in ps.Invoke())
            {
                Console.WriteLine("{0,-24}{1}",
                        result.Members["ProcessName"].Value,
                        result.Members["Id"].Value);
            } // End foreach.
        } // End Main.
    } // End HostPs1.
}

The post Ejecutar un cmdlet de PowerShell desde C# appeared first on Scripting and security.

using System;
using System.Management.Automation;  // Windows PowerShell namespace.

namespace HostPS1
{
    class HostPS1
    {
        static void Main(string[] args)
        {

            // Call the PowerShell.Create() method to create an
            // empty pipeline.
            PowerShell ps = PowerShell.Create();

            // Call the PowerShell.AddCommand(string) method.
            ps.AddCommand("Get-DnsClientCache");

            Console.WriteLine("Entry                 Data");
            Console.WriteLine("----------------------------");


            // Call the PowerShell.Invoke() method to run the
            // commands of the pipeline in the default runspace.
            foreach (PSObject result in ps.Invoke())
            {
                Console.WriteLine("{0,-24}{1}",
                        result.Members["Entry"].Value,
                        result.Members["Data"].Value);
            } // End foreach.
        } // End Main.
    } // End HostPs1.
}

The post Ejecutar el cmdlet de PowerShell que recupera el contenido de la caché de cliente DNS desde C# appeared first on Scripting and security.

using System;
using System.Management.Automation;  // Windows PowerShell namespace.

namespace HostPS1
{
    class HostPS1
    {
        static void Main(string[] args)
        {

            // Call the PowerShell.Create() method to create an
            // empty pipeline.
            PowerShell ps = PowerShell.Create();

            ps.AddCommand("Get-WmiObject");
            ps.AddArgument("win32_physicalmemory");
            ps.AddCommand("sort-object");
            ps.AddArgument("Manufacturer");

            // Call the PowerShell.Invoke() method to run the
            // commands of the pipeline in the default runspace.
            foreach (PSObject result in ps.Invoke())
            {
                Console.WriteLine(result.Members["Manufacturer"].Value);
            } // End foreach.
        } // End Main.
    } // End HostPs1.
}

The post Ejecutar el cmdlet de PowerShell para obtener información de la memoria RAM desde C# appeared first on Scripting and security.

$CodigoC = @”

using System;
using System.Management.Automation;  // Windows PowerShell namespace.

namespace HostPS1
{
    public class HostPS1
    {
        public static void Main()
        {

            // Call the PowerShell.Create() method to create an
            // empty pipeline.
            PowerShell ps = PowerShell.Create();

            ps.AddCommand("Get-WmiObject");
            ps.AddArgument("win32_physicalmemory");
            ps.AddCommand("sort-object");
            ps.AddArgument("Manufacturer");

            // Call the PowerShell.Invoke() method to run the
            // commands of the pipeline in the default runspace.
            foreach (PSObject result in ps.Invoke())
            {
                Console.WriteLine(result.Members["Manufacturer"].Value);
            } // End foreach.
        } // End Main.
    } // End HostPs1.
}

“@

Add-Type -TypeDefinition $CodigoC -ErrorAction SilentlyContinue

[HostPS1.HostPS1]::Main()

The post Ejecutar un código de C# desde PowerShell que ejecuta un cmdlet de PowerShell appeared first on Scripting and security.

using System;
using System.Collections.ObjectModel;
using System.Management.Automation;  // Windows PowerShell namespace.

namespace PowerSh
{
    class PowerSh
    {
        static void Main(string[] args)
        {
                using (PowerShell PowerShellInstance = PowerShell.Create())
                {
                    // use "AddScript" to add the contents of a script file to the end of the execution pipeline.
                    // use "AddCommand" to add individual commands/cmdlets to the end of the execution pipeline.
                    PowerShellInstance.AddScript("Get-Process | out-file out.txt");

                    Collection<PSObject> PSOutput = PowerShellInstance.Invoke();
                    foreach (PSObject outputItem in PSOutput)
                    {
                        // if null object was dumped to the pipeline during the script then a null
                        // object may be present here. check for null to prevent potential NRE.
                        if (outputItem != null)
                        {
                            Console.WriteLine(outputItem.BaseObject.ToString() + "\n");
                        }
                    }
                if (PowerShellInstance.Streams.Error.Count > 0)
                {
                    Console.Write("Error");
                }
                else
                {
                    Console.Write("Correcto");
                }
                    Console.ReadKey();
                }

        } // End Main.
    } // End PowerSh.
}

The post Mostrar un mensaje si se ha ejecutado correctamente un script de PowerShell desde C# appeared first on Scripting and security.

$url="http://www.jesusninoc.com"
foreach($links in (Invoke-WebRequest $url).Links.href){foreach($links2 in (Invoke-WebRequest $links).Links.href){$links2,(Invoke-WebRequest $links2).RawContentLength,2}}

Ejemplo (el segundo nivel NO corresponde con el segundo nivel de directorios, corresponde con los enlaces que aparecen al recorrer los enlaces del primer nivel)

The post Recorrer el segundo nivel de un sitio web y obtener información de todos los enlaces appeared first on Scripting and security.

$url="http://www.jesusninoc.com"
foreach($links in (Invoke-WebRequest $url).Links.href){($links,(Invoke-WebRequest $links).RawContentLength,1)}

The post Recorrer el primer nivel de un sitio web y obtener información de todos los enlaces del sitio appeared first on Scripting and security.

$url="http://www.jesusninoc.com"
foreach($links in (Invoke-WebRequest $url).Links.href){foreach($links2 in (Invoke-WebRequest $links).Links.href){$links2}}

The post Recorrer el segundo nivel de un sitio web y obtener todos los enlaces del sitio appeared first on Scripting and security.

#Clase Enlace con información sobre el enlace: URL, tamaño y nivel de recorrido
class Enlace
{
    $URL
    $Long
    $Level

    Enlace($URL,$Long,$Level)
    {
        $this.URL=$URL
        $this.Long=$Long
        $this.Level=$Level
    }
}

#Iniciar array
$myArray = @()
$myArray += [Enlace]::new("https://www.jesusninoc.com/",1,1)

#Eliminar el fichero que contiene la expresión que se va a ejecutar
rm .\fichero.txt
"" | Out-File -FilePath fichero.txt -NoNewline

#Crear una función que permite automatizar el recorrido de una web por niveles
$url="https://www.jesusninoc.com/"
function insertar($numeroveces)
{
for($i;$i -lt $numeroveces;$i++){'foreach($links'+($i+1)+' in (Invoke-WebRequest $links'+$i+').Links.href){' | Add-Content -Path fichero.txt -NoNewline}
'if(!$myArray.URL.Contains($links'+$numeroveces+')){$myArray += [Enlace]::new($links'+$numeroveces | Add-Content -Path fichero.txt -NoNewline
',(Invoke-WebRequest $links'+$numeroveces+').RawContentLength,' | Add-Content -Path fichero.txt -NoNewline
$numeroveces | Add-Content -Path fichero.txt -NoNewline
')' | Add-Content -Path fichero.txt -NoNewline
';start-sleep -s 2' | Add-Content -Path fichero.txt -NoNewline
';$links'+$numeroveces | Add-Content -Path fichero.txt -NoNewline
'}' | Add-Content -Path fichero.txt -NoNewline
for($j;$j -lt $numeroveces;$j++){"}" | Add-Content -Path fichero.txt -NoNewline}
}

#Ejecutar la función y leer la información que ha generado la función
insertar(1)
gc .\fichero.txt

#Ejecutar la expresión generada al ejecutar la función que permite automatizar el recorrido de una web por niveles
foreach($links in (Invoke-WebRequest $url).Links.href){Invoke-Expression(gc .\fichero.txt)}

#Ordenar el array por tamaño
$myArray | sort Long

Resultado de la ejecución del script

Ver el contenido del array con la clase Enlace

The post Automatizar el recorrido de niveles de un sitio web, obteniendo información de todos los enlaces del sitio y añadir la información creando una clase a un array appeared first on Scripting and security.

Introducción

####################################################################################################
####################################################################################################
#Teniendo en cuenta la idea de comunicar dos ordenadores mediante la voz del sistema operativo
#https://www.jesusninoc.com/2016/01/10/comunicar-dos-ordenadores-mediante-la-voz-del-sistema-operativo/
#Realizar una comunicación enviando preguntas y respondiendo de forma automática
####################################################################################################
####################################################################################################

Reconocimiento y respuesta (ejecutar primero)

####################################################################################################
#RECONOCIMIENTO Y RESPUESTA
####################################################################################################
#Crear objeto para reconocimiento
Add-Type -AssemblyName System.Speech
$rec = New-Object 'System.Speech.Recognition.SpeechRecognitionEngine'
$rec.LoadGrammar((New-Object 'System.Speech.Recognition.DictationGrammar'))
$rec.SetInputToDefaultAudioDevice()

#Añadir posibles respuestas
"tal|Bien y tú?" | Out-File frases.txt
"años|40" | Out-File frases.txt -Append
"novia|Sí" | Out-File frases.txt -Append
"novio|Sí" | Out-File frases.txt -Append

#Crear un ArrayList con las respuestas
[System.Collections.ArrayList]$arraylist = New-Object System.Collections.ArrayList
ForEach ($elemento in (gc .\frases.txt).split("|")){[void]$arraylist.Add($elemento)}

#Función para comprobar si el mensaje que llega está entre las posibles respuestas
#La función responde mediante la voz del Sistema Operativo
function comprobar($frase){
    [System.Collections.ArrayList]$arraylist2 = New-Object System.Collections.ArrayList
    ForEach ($elemento in $frase.split(" ")){[void]$arraylist2.Add($elemento)}

    $arraylist2 | %{
        if($arraylist.IndexOf($_) -ne -1){
            (New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer).Speak($arraylist[($arraylist.IndexOf($_))+1])
        }
    }
}

#Comenzar a reconocer los audios que vayan llegando y comprobar qué mensajes llegan
do{
$mensaje=$rec.Recognize().Text
$mensaje
comprobar $mensaje
}while(1)

Enviar preguntas

####################################################################################################
#ENVIAR PREGUNTAS
####################################################################################################
#Leer el texto contenido dentro de un fichero mediante la voz del Sistema Operativo
Add-Type -AssemblyName System.Speech

#Añadir textos para que se lean
"¿Qué tal?" | Out-File conversacion.txt
"¿Cuántos años tienes?" | Out-File conversacion.txt -Append
"¿Tienes novia?" | Out-File conversacion.txt -Append

#Leer los textos mediante la voz del Sistema Operativo
gc conversacion.txt | %{
$_
(New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer).Speak($_)
Start-Sleep -Seconds 3
}

The post Realizar una comunicación enviando preguntas y respondiendo de forma automática mediante el motor de síntesis de voz en PowerShell appeared first on Scripting and security.

####################################################################
#Convertir una cadena de caracteres a binario (Char - Int - Binario)
$resultado = ""
$codificar = 'GC'
foreach($letra in [Char[]]$codificar)
{
$decimal = [Int][Char]$letra
$resultado += [Convert]::ToString($decimal, 2)
}
$resultado
####################################################################

####################################################################
#Convertir una cadena de caracteres a binario (char - int - binario)
([Char[]]"GC" | %{[Convert]::ToString([Int][Char]$_, 2)}) -join ""
####################################################################

####################################################################
#Convertir números en binario en caracteres (agrupando de 7 en 7 bits)
(10001111000011 -split "(?<=\G\d{7})(?=.)" | %{[Char][Convert]::ToInt32($_,2)}) -join ""
####################################################################

####################################################################
#Invertir un script
$valor = '(10001111000011 -split "(?<=\G\d{7})(?=.)" | %{[Char][Convert]::ToInt32($_,2)}) -join ""'
$invertido = $valor[$valor.Length..0]-join ""
$invertido
####################################################################

####################################################################
#Obtener el alias del cmdlet Get-Content mediante Get-Command
(gcm g?)[0].Name
####################################################################

####################################################################
#Obtener el alias del cmdlet Get-Content mediante Get-Command y abrir un fichero
(gcm g?)[0].Name + ' fichero.txt' | Invoke-Expression
####################################################################

The post Ofuscación en PowerShell appeared first on Scripting and security.

Introducción

####################################################################################################
####################################################################################################
#Teniendo en cuenta la idea de comunicar dos ordenadores mediante la voz del sistema operativo
#https://www.jesusninoc.com/2016/01/10/comunicar-dos-ordenadores-mediante-la-voz-del-sistema-operativo/
#Realizar una comunicación enviando preguntas y respondiendo de forma automática
####################################################################################################
####################################################################################################

Reconocimiento y respuesta (ejecutar primero)

####################################################################################################
#RECONOCIMIENTO Y RESPUESTA
####################################################################################################
#Crear objeto para reconocimiento
Add-Type -AssemblyName System.Speech
$rec = New-Object 'System.Speech.Recognition.SpeechRecognitionEngine'
#Crear las restricciones para una gramática de reconocimiento de voz
$rec.LoadGrammar([System.Speech.Recognition.GrammarBuilder]::new("tal"))
$rec.LoadGrammar([System.Speech.Recognition.GrammarBuilder]::new("años"))
$rec.LoadGrammar([System.Speech.Recognition.GrammarBuilder]::new("novia"))
$rec.LoadGrammar([System.Speech.Recognition.GrammarBuilder]::new("novio"))
$rec.SetInputToDefaultAudioDevice()

#Añadir posibles respuestas
"tal|Bien y tú?" | Out-File frases.txt
"años|40" | Out-File frases.txt -Append
"novia|Sí" | Out-File frases.txt -Append
"novio|Sí" | Out-File frases.txt -Append

#Crear un ArrayList con las respuestas
[System.Collections.ArrayList]$arraylist = New-Object System.Collections.ArrayList
ForEach ($elemento in (gc .\frases.txt).split("|")){[void]$arraylist.Add($elemento)}

#Función para comprobar si el mensaje que llega está entre las posibles respuestas
#La función responde mediante la voz del Sistema Operativo
function comprobar($frase){
    [System.Collections.ArrayList]$arraylist2 = New-Object System.Collections.ArrayList
    ForEach ($elemento in $frase.split(" ")){[void]$arraylist2.Add($elemento)}

    $arraylist2 | %{
        if($arraylist.IndexOf($_) -ne -1){
            "Respuesta: " +$arraylist[($arraylist.IndexOf($_))+1]
            (New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer).Speak($arraylist[($arraylist.IndexOf($_))+1])
        }
    }
}

#Comenzar a reconocer los audios que vayan llegando y comprobar qué mensajes llegan
do{
$mensaje=$rec.Recognize().Text
$mensaje
comprobar $mensaje
}while(1)

Enviar preguntas

####################################################################################################
#ENVIAR PREGUNTAS
####################################################################################################
#Leer el texto contenido dentro de un fichero mediante la voz del Sistema Operativo
Add-Type -AssemblyName System.Speech

#Añadir textos para que se lean
"¿Qué tal?" | Out-File conversacion.txt
"¿Cuántos años tienes?" | Out-File conversacion.txt -Append
"¿Tienes novia?" | Out-File conversacion.txt -Append

#Leer los textos mediante la voz del Sistema Operativo
gc conversacion.txt | %{
$_
(New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer).Speak($_)
Start-Sleep -Seconds 3
}

The post Realizar una comunicación enviando preguntas y respondiendo de forma automática mediante el motor de síntesis de voz en PowerShell (con restricciones para una gramática de reconocimiento de voz) appeared first on Scripting and security.

#Clase Enlace con información sobre el enlace: URL, tamaño y nivel de recorrido
class Enlace
{ 
    $URL
    $Long
    $Level

    Enlace($URL,$Long,$Level)
    {
        $this.URL=$URL
        $this.Long=$Long
        $this.Level=$Level
    }
}

#Iniciar array
$myArray = @()

#Recorrer el sitio hasta el segundo nivel, almacenando cada información (clase Enlace) en un array
$url="http://www.jesusninoc.com"
foreach($links in (Invoke-WebRequest $url).Links.href){foreach($links2 in (Invoke-WebRequest $links).Links.href)
{$myArray += [Enlace]::new($links2,(Invoke-WebRequest $links2).RawContentLength,2);start-sleep -s 4;$links2}}

$myArray

The post Recorrer el segundo nivel de un sitio web, obtener información de todos los enlaces del sitio y añadir la información creando una clase a un array appeared first on Scripting and security.

Versión 1

#Abrir el fichero texto.txt y añadir cada una de las letras que contiene el fichero en una ArrayList

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada
[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList
 
ForEach ($elemento in gc .\texto.txt){
#Agrega un objeto al final de ArrayList
0..($elemento.Length-1) | %{
[void]$arraylist.Add($elemento[$_])
}
}

$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count

Versión 2

(((Get-Content .\texto.txt) -join "`r").ToUpper().GetEnumerator()) | Group-Object | Sort-Object Count -Descending | select Name,Count

The post Ejercicios de PowerShell: analizar la frecuencia de letras en un fichero appeared first on Scripting and security.

$Cave = [System.Drawing.Bitmap]::FromFile( '.\juan2.jpg' )
$cave
$i=0
$a=0
$array = @()

for ($y = 0;$y -lt $Cave.Height;$y+=1)
{
    for ($x = 0;$x -lt $Cave.Width;$x+=1)
    {
        $col=$Cave.GetPixel($x,$y).Name
        if ($i -lt $Cave.Width -1)
        {
            switch ($col)
            {
                "ff000000" {
                    Write-Host "X" -BackgroundColor Black -ForegroundColor White -NoNewLine
                    $array += "X"
                }
            default{
                Write-Host " " -BackgroundColor white -NoNewLine
                $array += " "
                }
            }
            $i=$i+1
            if ($a -lt 9){$a=$a+1}
            else{$a=0}
        }
        else
        {
            Write-Host " "
            $array += "*"
            $i=0
            $a=0
        }
    }
}

#########
#Negativo
#########
$uu=""
foreach ($p in $array)
{
    if ($p -eq "*")
    {
        write-Host $p -BackgroundColor Black -ForegroundColor White
        $uu=$uu+"`n"
    }
    else
    {
        write-Host $p -BackgroundColor Black -ForegroundColor White -NoNewLine
        $uu=$uu+$p
    }
}

The post Convert una imagen JPG a caracteres en la consola de PowerShell (obtener el negativo) appeared first on Scripting and security.

$Cave = [System.Drawing.Bitmap]::FromFile( '.\juan2.jpg' )
$cave
$i=0
$a=0
$array = @()

for ($y = 0;$y -lt $Cave.Height;$y+=1)
{
    for ($x = 0;$x -lt $Cave.Width;$x+=1)
    {
        $col=$Cave.GetPixel($x,$y).Name
        if ($i -lt $Cave.Width -1)
        {
            switch ($col)
            {
                "ff000000" {
                    Write-Host "X" -BackgroundColor Black -ForegroundColor White -NoNewLine
                    $array += "X"
                }
            default{
                Write-Host " " -BackgroundColor white -NoNewLine
                $array += " "
                }
            }
            $i=$i+1
            if ($a -lt 9){$a=$a+1}
            else{$a=0}
        }
        else
        {
            Write-Host " "
            $array += "*"
            $i=0
            $a=0
        }
    }
}

#########
#Negative
#########
$uu=""
foreach ($p in $array)
{
    if ($p -eq "*")
    {
        write-Host $p -BackgroundColor Black -ForegroundColor White
        $uu=$uu+"`n"
    }
    else
    {
        write-Host $p -BackgroundColor Black -ForegroundColor White -NoNewLine
        $uu=$uu+$p
    }
}

###############
#Blue and white
###############
rm .\traducir2.txt
$ji=0
foreach ($pp in $uu)
{
    if($pp -match "x")
    {
        write-host $ji $pp
        $pp >> traducir2.txt
        $ji=$ji+1
        $valorfinal=$pp.Length
    }
}

The post Convert bitmap to characters in Write-Host (blue and white) appeared first on Scripting and security.