#Abrir el fichero quijote.txt, añadir a una ArrayList, agrupar y obtener la frecuencia cada una de las letras que contiene el fichero

#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 .\quijote.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

The post Análisis de frecuencias de letras en el libro “El ingenioso hidalgo Don Quijote de la Mancha” con PowerShell (parte 6) appeared first on Scripting and security.

ForEach($val in ((Get-NetAdapter).MacAddress).replace("-",""))
{
$val
0..($val.Length-1) | %{
Write-Host $val[$_],([Convert]::ToString([Byte]::Parse($val[$_],[System.Globalization.NumberStyles]::HexNumber),2))
}
}

The post Convertir a binario las direcciones MAC de los dispositivos de red appeared first on Scripting and security.

#Abrir el fichero quijote.txt, añadir a una ArrayList, agrupar y obtener la frecuencia cada una de las letras que contiene el fichero

#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 .\quijote.txt){
#Agrega un objeto al final de ArrayList
0..($elemento.Length-1) | %{
[void]$arraylist.Add($elemento[$_])
}
}

#Representar la frecuencia gráficamente
$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count | %{
$frecuencia=([math]::truncate(($_.count/$arraylist.Count)*100))
$frecuenciadibujo=((1..$frecuencia) | %{Write-Host '█' -NoNewline})
Write-Host $_.name,$frecuencia,$frecuenciadibujo
}

The post Análisis y representación de frecuencias de letras en el libro “El ingenioso hidalgo Don Quijote de la Mancha” con PowerShell (parte 7) appeared first on Scripting and security.

$var=5

ForEach ($elemento in gc .\quijote.txt){
(0..($elemento.Length-1) | % {[char]::ConvertFromUtf32([char]::ConvertToUtf32($elemento[$_].ToString(),0)+$var)}) -join "" | Out-File quijotecif.txt -Append
}

The post Cifrar de forma sencilla el libro “El ingenioso hidalgo Don Quijote de la Mancha” con PowerShell (parte 8) appeared first on Scripting and security.

Sin cifrar

#Abrir el fichero quijote.txt, añadir a una ArrayList, agrupar y obtener la frecuencia cada una de las letras que contiene el fichero

#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 .\quijote.txt){
#Agrega un objeto al final de ArrayList
0..($elemento.Length-1) | %{
[void]$arraylist.Add($elemento[$_])
}
}

#Representar la frecuencia gráficamente
$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count | %{
$frecuencia=([math]::truncate(($_.count/$arraylist.Count)*100))
$frecuenciadibujo=((1..$frecuencia) | %{Write-Host '█' -NoNewline})
Write-Host $_.name,$frecuencia,$frecuenciadibujo
}

Cifrado sencillo

#Abrir el fichero quijotecif.txt, añadir a una ArrayList, agrupar y obtener la frecuencia cada una de las letras que contiene el fichero

#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 .\quijotecif.txt){
#Agrega un objeto al final de ArrayList
0..($elemento.Length-1) | %{
[void]$arraylist.Add($elemento[$_])
}
}

#Representar la frecuencia gráficamente
$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count | %{
$frecuencia=([math]::truncate(($_.count/$arraylist.Count)*100))
$frecuenciadibujo=((1..$frecuencia) | %{Write-Host '█' -NoNewline})
Write-Host $_.name,$frecuencia,$frecuenciadibujo
}

Comparación de frecuencias

The post Análisis y representación de frecuencias de letras en el libro “El ingenioso hidalgo Don Quijote de la Mancha” cifrado y sin cifrar con PowerShell (parte 9) appeared first on Scripting and security.

#Cifrar incrementando un valor a cada letra (el valor empieza en 0 y va sumando 1) de cada palabra de cada frase
$var=0
ForEach ($frases in gc .\quijote.txt){
$frasec=""
ForEach ($palabra in $frases.split()){
$frasecn=(0..($palabra.Length-1) | % {[char]::ConvertFromUtf32([char]::ConvertToUtf32($palabra[$_].ToString(),0)+($var=$var+1))}) -join ""
$frasec=$frasec+$frasecn
$var=0
}
$frasec | Out-File quijotecifcomplex.txt -Append
}

The post Cifrar de forma compleja el libro “El ingenioso hidalgo Don Quijote de la Mancha” con PowerShell (parte 10) appeared first on Scripting and security.

Sin cifrar

#Abrir el fichero quijote.txt, añadir a una ArrayList, agrupar y obtener la frecuencia cada una de las letras que contiene el fichero

#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 .\quijote.txt){
#Agrega un objeto al final de ArrayList
0..($elemento.Length-1) | %{
[void]$arraylist.Add($elemento[$_])
}
}

#Representar la frecuencia gráficamente
$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count | %{
$frecuencia=([math]::truncate(($_.count/$arraylist.Count)*100))
$frecuenciadibujo=((1..$frecuencia) | %{Write-Host '█' -NoNewline})
Write-Host $_.name,$frecuencia,$frecuenciadibujo
}

Cifrado complejo

#Abrir el fichero quijotecifcomplex.txt, añadir a una ArrayList, agrupar y obtener la frecuencia cada una de las letras que contiene el fichero

#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 .\quijotecifcomplex.txt){
#Agrega un objeto al final de ArrayList
0..($elemento.Length-1) | %{
[void]$arraylist.Add($elemento[$_])
}
}

#Representar la frecuencia gráficamente
$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count | %{
$frecuencia=([math]::truncate(($_.count/$arraylist.Count)*100))
$frecuenciadibujo=((1..$frecuencia) | %{Write-Host '█' -NoNewline})
Write-Host $_.name,$frecuencia,$frecuenciadibujo
}

Comparación de frecuencias (las frecuencias del fichero cifrado de forma compleja se suavizan)

The post Análisis y representación de frecuencias de letras en el libro “El ingenioso hidalgo Don Quijote de la Mancha” cifrado de forma compleja y sin cifrar con PowerShell (parte 11) appeared first on Scripting and security.

foreach($segundo in 1..254)
{
    foreach($tercero in 1..254)
    {
        $ip=("192.168."+$segundo+"."+$tercero)
        $ip
        New-NetIPAddress -InterfaceAlias Wi-Fi -IPAddress $ip -PrefixLength 24
        pause
    }
}

The post Agregar más de una dirección IP a una conexión de red con PowerShell appeared first on Scripting and security.

Resolve-Path -Path C:\users\*\Desktop -ErrorAction SilentlyContinue | ForEach-Object {$_.Path.Split('\')[-2]}

The post Ver los usuarios que tienen la carpeta Escritorio (Desktop) appeared first on Scripting and security.

#PowerShell
ForEach($fichero in ls .)
{
#Cifrar el contenido del fichero
$cifrado=gc $fichero
$var=1
$textocifrado=(0..($cifrado.Length-1) | % {[char]::ConvertFromUtf32([char]::ConvertToUtf32($cifrado[$_].ToString(),0)+$var)}) -join ""

#Cifrar el nombre y añadir el contenido cifrado
#Quitamos los puntos y otros caracteres para no tener errores a la hora de crear el nuevo fichero cifrado
$ficherosin=$fichero.Name.Replace(".","")
$ficherosin
$ficherocifrado=(0..($ficherosin.Length-1) | % {[char]::ConvertFromUtf32([char]::ConvertToUtf32($ficherosin[$_].ToString(),0)+$var)}) -join ""
$textocifrado | Out-File $ficherocifrado
}

Invoke-WebRequest "http://www.jesusninoc.com/clave/$var"

The post Cifrar con un algoritmo sencillo el nombre y el contenido de un fichero de texto (enviar la clave utilizada en el algoritmo mediante una petición web a un servidor) appeared first on Scripting and security.

ForEach($fichero in ls .)
{
#Cifrar el contenido del fichero
$cifrado=gc $fichero
$var=1
$textocifrado=(0..($cifrado.Length-1) | % {[char]::ConvertFromUtf32([char]::ConvertToUtf32($cifrado[$_].ToString(),0)-$var)}) -join ""

#Cifrar el nombre y añadir el contenido cifrado
#Quitamos los puntos y otros caracteres para no tener errores a la hora de crear el nuevo fichero cifrado
$ficherosin=$fichero.Name.Replace(".","")
$ficherosin
$ficherocifrado=(0..($ficherosin.Length-1) | % {[char]::ConvertFromUtf32([char]::ConvertToUtf32($ficherosin[$_].ToString(),0)-$var)}) -join ""
$textocifrado | Out-File $ficherocifrado
}

The post Descifrar con un algoritmo sencillo el nombre y el contenido de un fichero de texto appeared first on Scripting and security.

foreach($primer in 1..254)
{
    foreach($segundo in 1..254)
    {
        foreach($tercero in 1..254)
        {
            foreach($cuarto in 1..254)
            {
                ''+$primer+'.'+$segundo+'.'+$tercero+'.'+$cuarto
            }
        }
    }
}

The post Recorrer direcciones IP appeared first on Scripting and security.

foreach($primer in 1..254)
{
    foreach($segundo in 1..254)
    {
        foreach($tercero in 1..254)
        {
            "80."+$primer+"."+$segundo+"."+$tercero
        }
    }
}

The post Recorrer un rango de direcciones IP appeared first on Scripting and security.

#Abrir el fichero principito.txt, añadir a una ArrayList, agrupar y obtener la frecuencia de cada una de las letras que contiene el fichero

#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 .\principito.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

Frecuencia de uso de letras en español

The post Análisis de frecuencias de letras en el libro “El Principito” con PowerShell (parte 6) appeared first on Scripting and security.

#Abrir el fichero comedyoferrors.txt, añadir a una ArrayList, agrupar y obtener la frecuencia de cada una de las letras que contiene el fichero

#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 .\comedyoferrors.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

Frecuencia de uso de letras en inglés

The post Análisis de frecuencias de letras en el libro “The Comedy of Errors” con PowerShell (parte 6) appeared first on Scripting and security.

Get-WmiObject Win32_PhysicalMemory | ForEach-Object {$_.capacity / 1GB}

The post Total capacity of the physical memory in bytes appeared first on Scripting and security.

Alias           % -> ForEach-Object
Alias           ? -> Where-Object
Alias           ac -> Add-Content
Alias           asnp -> Add-PSSnapin
Alias           cat -> Get-Content
Alias           cd -> Set-Location
Alias           CFS -> ConvertFrom-String
Alias           chdir -> Set-Location
Alias           clc -> Clear-Content
Alias           clear -> Clear-Host
Alias           clhy -> Clear-History
Alias           cli -> Clear-Item
Alias           clp -> Clear-ItemProperty
Alias           cls -> Clear-Host
Alias           clv -> Clear-Variable
Alias           cnsn -> Connect-PSSession
Alias           compare -> Compare-Object
Alias           copy -> Copy-Item
Alias           cp -> Copy-Item
Alias           cpi -> Copy-Item
Alias           cpp -> Copy-ItemProperty
Alias           curl -> Invoke-WebRequest
Alias           cvpa -> Convert-Path
Alias           dbp -> Disable-PSBreakpoint
Alias           del -> Remove-Item
Alias           diff -> Compare-Object
Alias           dir -> Get-ChildItem
Alias           dnsn -> Disconnect-PSSession
Alias           ebp -> Enable-PSBreakpoint
Alias           echo -> Write-Output
Alias           epal -> Export-Alias
Alias           epcsv -> Export-Csv
Alias           epsn -> Export-PSSession
Alias           erase -> Remove-Item
Alias           etsn -> Enter-PSSession
Alias           exsn -> Exit-PSSession
Alias           fc -> Format-Custom
Alias           fhx -> Format-Hex
Alias           fl -> Format-List
Alias           foreach -> ForEach-Object
Alias           ft -> Format-Table
Alias           fw -> Format-Wide
Alias           gal -> Get-Alias
Alias           gbp -> Get-PSBreakpoint
Alias           gc -> Get-Content
Alias           gci -> Get-ChildItem
Alias           gcm -> Get-Command
Alias           gcs -> Get-PSCallStack
Alias           gdr -> Get-PSDrive
Alias           ghy -> Get-History
Alias           gi -> Get-Item
Alias           gjb -> Get-Job
Alias           gl -> Get-Location
Alias           gm -> Get-Member
Alias           gmo -> Get-Module
Alias           gp -> Get-ItemProperty
Alias           gps -> Get-Process
Alias           gpv -> Get-ItemPropertyValue
Alias           group -> Group-Object
Alias           gsn -> Get-PSSession
Alias           gsnp -> Get-PSSnapin
Alias           gsv -> Get-Service
Alias           gu -> Get-Unique
Alias           gv -> Get-Variable
Alias           gwmi -> Get-WmiObject
Alias           h -> Get-History
Alias           history -> Get-History
Alias           icm -> Invoke-Command
Alias           iex -> Invoke-Expression
Alias           ihy -> Invoke-History
Alias           ii -> Invoke-Item
Alias           ipal -> Import-Alias
Alias           ipcsv -> Import-Csv
Alias           ipmo -> Import-Module
Alias           ipsn -> Import-PSSession
Alias           irm -> Invoke-RestMethod
Alias           ise -> powershell_ise.exe
Alias           iwmi -> Invoke-WMIMethod
Alias           iwr -> Invoke-WebRequest
Alias           kill -> Stop-Process
Alias           lp -> Out-Printer
Alias           ls -> Get-ChildItem
Alias           man -> help
Alias           md -> mkdir
Alias           measure -> Measure-Object
Alias           mi -> Move-Item
Alias           mount -> New-PSDrive
Alias           move -> Move-Item
Alias           mp -> Move-ItemProperty
Alias           mv -> Move-Item
Alias           nal -> New-Alias
Alias           ndr -> New-PSDrive
Alias           ni -> New-Item
Alias           nmo -> New-Module
Alias           npssc -> New-PSSessionConfigurationFile
Alias           nsn -> New-PSSession
Alias           nv -> New-Variable
Alias           ogv -> Out-GridView
Alias           oh -> Out-Host
Alias           popd -> Pop-Location
Alias           ps -> Get-Process
Alias           pushd -> Push-Location
Alias           pwd -> Get-Location
Alias           r -> Invoke-History
Alias           rbp -> Remove-PSBreakpoint
Alias           rcjb -> Receive-Job
Alias           rcsn -> Receive-PSSession
Alias           rd -> Remove-Item
Alias           rdr -> Remove-PSDrive
Alias           ren -> Rename-Item
Alias           ri -> Remove-Item
Alias           rjb -> Remove-Job
Alias           rm -> Remove-Item
Alias           rmdir -> Remove-Item
Alias           rmo -> Remove-Module
Alias           rni -> Rename-Item
Alias           rnp -> Rename-ItemProperty
Alias           rp -> Remove-ItemProperty
Alias           rsn -> Remove-PSSession
Alias           rsnp -> Remove-PSSnapin
Alias           rujb -> Resume-Job
Alias           rv -> Remove-Variable
Alias           rvpa -> Resolve-Path
Alias           rwmi -> Remove-WMIObject
Alias           sajb -> Start-Job
Alias           sal -> Set-Alias
Alias           saps -> Start-Process
Alias           sasv -> Start-Service
Alias           sbp -> Set-PSBreakpoint
Alias           sc -> Set-Content
Alias           select -> Select-Object
Alias           set -> Set-Variable
Alias           shcm -> Show-Command
Alias           si -> Set-Item
Alias           sl -> Set-Location
Alias           sleep -> Start-Sleep
Alias           sls -> Select-String
Alias           sort -> Sort-Object
Alias           sp -> Set-ItemProperty
Alias           spjb -> Stop-Job
Alias           spps -> Stop-Process
Alias           spsv -> Stop-Service
Alias           start -> Start-Process
Alias           sujb -> Suspend-Job
Alias           sv -> Set-Variable
Alias           swmi -> Set-WMIInstance
Alias           tee -> Tee-Object
Alias           trcm -> Trace-Command
Alias           type -> Get-Content
Alias           wget -> Invoke-WebRequest
Alias           where -> Where-Object
Alias           wjb -> Wait-Job
Alias           write -> Write-Output

The post Windows PowerShell aliases appeared first on Scripting and security.

#Leer datos de una base de datos y almacenar en un fichero con el nombre del ID de cada registro
[void][System.Reflection.Assembly]::LoadWithPartialName("MySql.Data")
$Connection = New-Object MySql.Data.MySqlClient.MySqlConnection
$ConnectionString = "server=" + "localhost" + ";port=3306;uid=" + "root" + ";pwd=" + ";database="+"gps"
$Connection.ConnectionString = $ConnectionString
$Connection.Open()

$Query='select * from result'
$Command = New-Object MySql.Data.MySqlClient.MySqlCommand($Query, $Connection)
$DataAdapter = New-Object MySql.Data.MySqlClient.MySqlDataAdapter($Command)
$DataSet = New-Object System.Data.DataSet
$RecordCount = $dataAdapter.Fill($dataSet, "data")
$Connection.Close()

#Almacenar el contenido de cada registro obtenido de la consulta a la base de datos en un fichero
foreach($valor in $DataSet.Tables[0])
{
$valor.ID
$valor | Out-File $valor.id
}

The post Obtener datos de una base de datos y almacenar el contenido en un fichero de texto appeared first on Scripting and security.

• Variables
  • Constantes
  • Ámbito
  • Tipos
  • Tipos simples
    • Numéricas
    • Caracteres
    • Fechas
    • Arrays
    • Arrays de números
    • Arrays de caracteres (cadenas)
  • Tipos complejos
    • Enumeraciones
• Objetos
• Ficheros
• Operaciones aritméticas
• Operaciones lógicas
• Operaciones de comparación
• Sentencias condicionales
• Sentencias de repetición
• Funciones

La programación es necesaria para realizar tareas de forma automática y consiste en indicar ordenes al sistema, en PowerShell el conjunto de ordenes se puede realizar mediante scripts. Un script es un conjunto de comandos (cmdlets) y elementos de programación (bucles, condicionales, comparaciones, etc.) que se ejecutan sobre PowerShell y realizan alguna función.

Ahora podemos hacernos algunas preguntas relacionadas con lo que queremos hacer utilizando scripts:

• ¿Cómo almacenar un valor de forma temporal?
• ¿Cómo almacenar un valor de forma permanente?
• ¿Cómo buscar una cadena?
• ¿Cómo buscar una cadena que ha introducido el usuario?
• ¿Cómo distinguir entre dos opciones?
• ¿Cómo distinguir entre varias opciones?
• ¿Cómo repetir algo?
• ¿Cómo utilizar algo nuevamente y no queremos añadirlo al código?

Variables

El sistema operativo almacena valores temporales en memoria que desaparecen cuando se cierra el sistema operativo, en PowerShell se pueden utilizar datos y almacenarlos hasta que se cierra PowerShell.

En programación, las variables son espacios reservados en la memoria que, como su nombre indica, pueden cambiar de contenido a lo largo de la ejecución de un programa. Una variable corresponde a un área reservada en la memoria principal del ordenador.

Características de las variables

• Se almacenan valores temporales en memoria que desaparecen cuando se cierra PowerShell.
• Almacenan información.
• Se pueden almacenar números te todo tipo, letras, conjunto de letras.
• Los datos con los que estamos trabajando también se pueden almacenar en el
  sistema de forma permanente.
• Concepto de variable relacionado con almacenar datos durante un tiempo.
• Datos que pueden ser introducidos por el usuario.
• Datos que se pueden modificar mediante cálculos.
• Datos que se pueden escribir.
• Datos que se pueden dar formato.
• Datos que residen en la memoria.

Ejemplo

Asignar un valor a una variable y mostrar el valor por pantalla

$cantidad=20
Write-Host $cantidad

• Constantes

En programación, una constante es un valor que no puede ser alterado/modificado durante la ejecución de un programa, únicamente puede ser leído.

Una constante corresponde a una longitud fija de un área reservada en la memoria principal del ordenador, donde el programa almacena valores fijos.

• Ámbito

El ámbito de una variable (llamado “scope” en inglés) es la zona del programa en la que se define la variable.

• Tipos

En PowerShell no es necesario establecer el tipo de dato aunque se puede hacer indicando el tipo de variable entre corchetes [ ]. Pero se puede hacer si se quiere.

Ejemplo

Crear una variable de tipo numérica y mostrar el valor por pantalla

[Int]$num=5
$num

Para ver el tipo de variable se utiliza el método

$var.getType()

Ejemplo

Ver el tipo de las siguientes variables

[Int]$num=5
$num.GetType()
[Char]$num=5
$num.GetType()

Ejercicio

Crear una variable con el valor 20 indicando el tipo entero para una de las variables y el tipo carácter para la otra, después ver el contenido y comprobar el tipo después

[int]$cantidad=20
Write-Host $cantidad
$cantidad.GetType()

[string]$cantidad2=20
Write-Host $cantidad2
$cantidad2.GetType()

• Tipos simples

Numéricas

Variables que representan valores enteros.

Ejemplo

$num=5
$num

Caracteres

Variables que representan valores tipo carácter.

Ejemplo

#Caracteres
$car='c'
$car

Booleanos

Representan el valor verdadero (1) o falso (0).

Ejemplo

$true
$false

Fechas

Fechas también son un tipo de variable, las fechas sirven para saber en qué momento ocurrió algo en relación con el momento actual.

Cmdlet para mostrar la fecha del sistema

Get-Date

Ejemplos

Mostrar la fecha actual

(Get-Date)

Mostrar año

Get-Date).Year

La fecha del sistema se puede cambiar utilizando el cmdlet

Set-Date

Ejemplo

Cambiar la fecha del sistema

Set-Date -date "6/1/2006 8:30 AM"

A las fechas se les puede dar formato

Ejemplos

Mostrar la fecha con distintos formatos

Get-Date -Format 'HH:mm:ss dddd MMMM d'
Get-Date).Year.tostring()+(Get-Date).Month.tostring()+(Get-Date).Day.tostring()
Get-Date).ToString("yyyyMMdd")
Get-Date).ToString("ddMMyyyy")

Las operaciones sobre fechas (métodos) son:

AddSeconds
AddMinutes
AddHours
AddDays
AddMonths
AddYears

Ejemplos

Mostrar la fecha del día anterior (con y sin formato)

(Get-Date).AddDays(-1)
(Get-Date).AddDays(-1).ToString("ddMMyyyy")

Mostrar las fechas de la semana pasada

-1..-7 | % {(Get-Date).AddDays($_).ToString("ddMMyyyy")}

Para crear una variable que representa un intervalo de tiempo se utiliza el cmdlet

New-TimeSpan

Ejemplo

Mostrar el intervalo de tiempo entre dos fechas

New-TimeSpan $(Get-Date) $(Get-Date -month 7 -day 19 -year 2016)

Arrays

Una zona de almacenamiento continuo, que contiene una serie de elementos del mismo tipo.

Los arrays pueden contener cualquier carácter, los arrays más utilizados son los arrays de números y de caracteres que se conocen como cadenas.

Arrays de números

Arrays que contienen números.

Ejemplo

Crear un array de números y mostrar el primer elemento

$arraynumeros="12345"
Write-Host $arraynumeros
Write-Host $arraynumeros[1]

Arrays de caracteres

Arrays que contienen cualquier tipo de carácter y se denominan cadenas.

Ejemplos

Mostrar una cadena

$palabra=’hola’
Write-Host $palabra

Ver elementos de arrays de caracteres, extraer varios elementos

#Extraer primer elemento (elemento 0)
$frase='Texto largo'
Write-Host $frase[0]

#Extraer segundo elemento (elemento 1)
$frase='Texto largo'
Write-Host $frase[1]

#Extraer último elemento
$frase='Texto largo'
Write-Host $frase[10]

Sobre las cadenas se pueden realizar varias operaciones, algunas operaciones que se pueden realizar en PowerShell son:

• Concatenar

Ejemplo

$palabra1='hola-'
$palabra2='adios'
$frasecontatenada=$palabra1+$palabra2
$frasecontatenada

• Determinar longitud

Ejemplo

'Hola'.Length

• Convertir en mayúsculas

Ejemplo

'Hola'.ToUpper()

• Convertir en minúsculas

Ejemplo

'Hola'.ToLower()

• Reemplazar caracteres

Ejemplo

'Hola'.Replace('o', '0')
"Hola buenas Lucas"-replace "hola|buenas","adios"

• Partir cadenas

Ejemplo

'Hola,buenas'.Split(',')

• Eliminar espacios

Ejemplo

'Hola buenas '.TrimStart()
'Hola buenas '.TrimEnd()
'Hola buenas '.Trim()

• Extraer elementos

Ejemplo

'Hola'.Substring(0)
'Hola'.Substring(0,2)
'Hola'.Substring(2)
'Hola'.Substring(2,1)

• Insertar elementos

Ejemplo

'Hola'.Insert(2, "oooo")

• Eliminar elementos

Ejemplo

'Hola'.Remove(3)
'Hola'.Remove(2)
'Hola'.Remove(1)
'Hola'.Remove(1,1)
'Hola'.Remove(2,2)
'Hola'.Remove(1,2)
'Hola'.Remove(1,3)

• Determinar la primera posición de un carácter

Ejemplo

'Holasa'.IndexOf('a')

• Determinar la última posición de un carácter

Ejemplo

'Holasa'.LastIndexOf('a')

• Determinar si el principio de una cadena coincide con otra cadena

Ejemplo

'Hola'.StartsWith('H')

• Determinar si el principio de una cadena coincide con otra cadena

Ejemplo

'Hola'.EndsWith('lo')

• Determinar si un carácter está contenido en una cadena

Ejemplo

'Hola'.Contains('a')

• Buscar

Ejemplo

'Hola'| Select-String 'o'

• Tipos complejos

Enumeraciones

Ejemplo

Crear una variable de tipo complejo con las principales ciudades del mundo

enum Ciudades
{
    Hannover
    Madrid
    Seattle
    Barcelona
    London
    NewYork
}

function Seleccion-Ciudades
{
    param ([Ciudades][Parameter(Mandatory=$true)]$Ciudad)
    Write-Host "Has elegido la ciudad de $Ciudad"
}

Seleccion-Ciudades 3

Objetos

Los objetos, propiedades, métodos y eventos son las unidades básicas de la programación orientada a objetos. Un objeto es un elemento de una aplicación, que representa una instancia de una clase. Propiedades, métodos y eventos son las unidades de creación básicas de los objetos y constituyen sus miembros.

En PowerShell los cmdlets se tratan como objetos.

Ejemplo

Almacenar la ejecución de los cmdlets ls y ps y ver las propiedades y los métodos de cada variable

$variable=ls
$variable | Get-Member

$variableproce=ps
$variableproce | Get-Member

Algunas características de los objetos:

• Un objeto representa una instancia de una clase.
• Una propiedad es un atributo de un objeto que define una de las características del objeto, como tamaño, color o ubicación en pantalla, o un aspecto de su comportamiento.
• Un método es una acción que un objeto puede realizar.
• Un evento es una acción que un objeto reconoce, como hacer clic con el mouse (ratón) o presionar una tecla, y para el que puede escribir código para responder. Los eventos se producen como consecuencia de una acción del usuario o de código de programa, o bien pueden ser desencadenados por el sistema. También puede desarrollar eventos personalizados propios para que los generen sus objetos y los controlen otros objetos.

En PowerShell se pueden crear objetos y añadir propiedades y métodos a dichos objetos.

Crear un objeto

$objeto=New-Object Object

Añadir una propiedad a un objeto

Add-Member -MemberType NoteProperty -Name Nombre Valor -InputObject $objeto

Listar propiedades y métodos

$objeto | Get-Member

Ejemplo

Crear un objeto coche con propiedades y métodos

#Crear objeto coche
$coche=New-Object Object
#Añadir propiedad color de coche
Add-Member -MemberType NoteProperty -Name Color Negro -InputObject $coche
#Añadir método temperatura del motor
$coche | Add-Member ScriptMethod TemperaturaMotor {60}

#Mostrar el color del coche
$coche.color
#Mostrar la temperatura del motor
$coche.TemperaturaMotor()

Ficheros

Las variables tienen el problema de ser temporales por eso necesitamos poder almacenar datos de forma permanente mediante los ficheros.

Operaciones aritméticas

Con las variables se pueden realizar las siguientes operaciones aritméticas:

• Sumar

Ejemplo

Sumar dos números

$num1=5
$num2=6
$resultado=$num1+$num2
Write-Host "La suma del número $num1 y el número $num2 es: "+ $resultado

• Restar

Ejemplo

Restar dos números

$num1=10
$num2=6
$resultado=$num1-$num2
Write-Host "La resta del número $num1 y el número $num2 es: "+ $resultado

• Multiplicar

Ejemplo

Multiplicar dos números

$num1=3
$num2=6
$resultado=$num1*$num2
Write-Host "La multiplicación del número $num1 y el número $num2 es: "+ $resultado

• Dividir

Ejemplo

Dividir dos números

$num1=10
$num2=5
$resultado=$num1/$num2
Write-Host "La división del número $num1 entre el número $num2 es: "+ $resultado

• Resto

Ejemplo

Resto de la división de números

$num1=4
$num2=2
$resultado=$num1%$num2
Write-Host "El resto de dividir el número $num1 entre el número $num2 es: "+ $resultado

Ejercicio

Saber si un número es par o impar, pidiendo al usuario que introduzca el número con el cmdlet Read-Host

$numero=Read-Host ("Introduzca un número para saber si es par o impar")
if($numero % 2 -eq 0)
{
Write-Host "El número $numero es par"
}
else
{
Write-Host "El número $numero es impar"
}

Operaciones lógicas

Las operaciones lógicas son expresiones matemáticas cuyo resultado es un valor booleano (verdadero o falso true o false), algunas expresiones lógicas que se pueden realizar en PowerShell son:

• And

Tabla lógica del operador and

Ejemplo

Realizar operaciones con el operador lógico and

(1 -eq 1) -and (2 -eq 2)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 2) es True
#El resultado de juntar las dos operaciones es True ya que True y True es True

(1 -eq 2) -and (2 -eq 3)
#La primera operación de comparación (1 -eq 2) es False
#La segunda operación de comparación (2 -eq 3) es False
#El resultado de juntar las dos operaciones es False ya que False y False es False

(1 -eq 1) -and (2 -eq 3)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 3) es False
#El resultado de juntar las dos operaciones es False ya que True y False es False

• Or

Tabla lógica del operador or

Ejemplo

Realizar operaciones con el operador lógico or

(1 -eq 1) -or (2 -eq 2)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 2) es True
#El resultado de juntar las dos operaciones es True ya que True o True es True

(1 -eq 2) -or (2 -eq 3)
#La primera operación de comparación (1 -eq 2) es False
#La segunda operación de comparación (2 -eq 3) es False
#El resultado de juntar las dos operaciones es False ya que False o False es False

(1 -eq 1) -or (2 -eq 3)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 3) es False
#El resultado de juntar las dos operaciones es True ya que True o False es True

• Not

Tabla lógica del operador not

Ejemplo

Realizar operaciones con el operador lógico not

(1 -eq 1) -and -not (2 -eq 2)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 2) es Not True es decir False
#El resultado de juntar las dos operaciones es False ya que True y False es False

(1 -eq 2) -and -not (2 -eq 3)
#La primera operación de comparación (1 -eq 2) es False
#La segunda operación de comparación (2 -eq 3) es Not False es decir True
#El resultado de juntar las dos operaciones es False ya que False y True es False

(1 -eq 1) -and -not (2 -eq 3)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 3) es Not False es decir True
#El resultado de juntar las dos operaciones es False ya que True y True es True

(1 -eq 1) -or -not (2 -eq 2)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 2) es Not True es decir False
#El resultado de juntar las dos operaciones es True ya que True o False es True

(1 -eq 2) -or -not (2 -eq 3)
#La primera operación de comparación (1 -eq 2) es False
#La segunda operación de comparación (2 -eq 3) es Not False es decir True
#El resultado de juntar las dos operaciones es False ya que False o True es True

(1 -eq 1) -or -not (2 -eq 3)
#La primera operación de comparación (1 -eq 1) es True
#La segunda operación de comparación (2 -eq 3) es Not False es decir True
#El resultado de juntar las dos operaciones es True ya que True o True es True

Operaciones de comparación

Algunas operaciones de comparación que se pueden realizar en PowerShell son:

• eq (Equal to -> Igual a)

Ejemplo

Realizar operaciones con el operador de comparación eq

$numero=1
$resultado=$numero -eq 1
#El resultado es True, esto significa que el resultado es verdadero
Write-Host $resultado

$cadena='pepito'
$resultado=$cadena -eq 'pepito'
#El resultado es True
Write-Host $resultado

$cadena='pepito'
$resultado=$cadena -eq 'Pepito'
#El resultado es True
Write-Host $resultado

#En el caso de cadenas de caracteres cuando comparamos dos cadenas que tienen incluidas mayúsculas y minúsculas nos indica que son iguales, para diferenciar hay que utilizar:
#-ceq

$cadena='pepito'
$resultado=$cadena -ceq 'Pepito'
#El resultado es False porque no son iguales la 'p'y la 'P'
Write-Host $resultado

• lt (Less than -> Menos que)

Ejemplo

Realizar operaciones con el operador de comparación lt

$numero1=1
$numero2=2
$resultado=$numero1 -lt $numero2
#El resultado es True, esto significa que el resultado es verdadero y que el número 2 es menor que el número 1
Write-Host $resultado

$numero1=1
$numero2=2
$resultado=$numero2 -lt $numero1
#El resultado es False, esto significa que el resultado es falso y que el número 1 no es menor que el número 2
Write-Host $resultado

• gt (Greater than -> Más que)

Ejemplo

Realizar operaciones con el operador de comparación gt

$numero1=1
$numero2=2
$resultado=$numero1 -gt $numero2
#El resultado es False, esto significa que el resultado es falso y que el número 1 no es mayor que el número 2
Write-Host $resultado

$numero1=1
$numero2=2
$resultado=$numero2 -gt $numero1
#El resultado es True, esto significa que el resultado es verdadero y que el número 2 es mayor que el número 1
Write-Host $resultado

• ge (Greater than or Equal to -> Mayor o igual a)

Ejemplo

Realizar operaciones con el operador de comparación ge

$numero1=1
$numero2=2
$resultado=$numero1 -ge $numero2
#El resultado es False, esto significa que el resultado es falso y que el número 1 no es mayor o igual que el número 2
Write-Host $resultado

$numero1=1
$numero2=2
$resultado=$numero2 -ge $numero1
#El resultado es True, esto significa que el resultado es verdadero y que el número 2 es mayor que el número 1
Write-Host $resultado

$numero1=1
$numero2=1
$resultado=$numero2 -ge $numero1
#El resultado es True, esto significa que el resultado es verdadero y que el número 2 es igual que el número 1
Write-Host $resultado

• le (Less than or equal to – Menor o igual a)

Ejemplo

Realizar operaciones con el operador de comparación le

$numero1=1
$numero2=2
$resultado=$numero1 -le $numero2
#El resultado es True, esto significa que el resultado es verdadero y que el número 1 es menor o igual que el número 1
Write-Host $resultado

$numero1=1
$numero2=2
$resultado=$numero2 -le $numero1
#El resultado es False, esto significa que el resultado es falso y que el número 2 no es menor que el número 1
Write-Host $resultado

$numero1=1
$numero2=1
$resultado=$numero2 -le $numero1
#El resultado es True, esto significa que el resultado es verdadero y que el número 2 es igual que el número 1
Write-Host $resultado

• ne (Not equal to – No es igual a)

Ejemplo

Realizar operaciones con el operador de comparación ne

$numero=1
$resultado=$numero -ne 1
#El resultado es False, esto significa que es falso que el número 1 no sea igual al número 1
Write-Host $resultado

$cadena='pepito'
$resultado=$cadena -ne 'pepitos'
#El resultado es True porque pepito no es igual a pepitos
Write-Host $resultado

Sentencias condicionales

En programación, una sentencia condicional es una instrucción o grupo de instrucciones que se pueden ejecutar o no en función del valor de una condición, los tipos de sentencias condicionales son:

• If

Ejemplo

Comprobar si un número es igual a otro utilizando if

$a=5
if($a -eq 5)
{
Write-Host “5”
}

• Else

Ejemplo

Comprobar si un número es igual a otro utilizando else

$a=5
if($a -eq 5)
{
Write-Host “5”
}
else
{
Write-Host “No 5”
}

• ElseIf

Ejemplo

Comprobar si un número es igual a otro utilizando elseif

$a=6
if($a -eq 5)
{
Write-Host “5”
}
elseif($a -eq 6)
{
Write-Host “6”
}
else
{
Write-Host “No 5 o 6”
}

• Switch

Ejemplo

Comprobar si un número es igual a otro utilizando switch

$a=5
switch($a){
5{
Write-Host “5”
break
}
6{
Write-Host “6”
break
}
7{
Write-Host “7”
break
}
}

Sentencias de repetición

Una estructura de repetición o bucle nos permite ejecutar un numero de veces determinado una serie de instrucciones, los tipos de sentencias de repetición son:

• Bucle While

Ejemplo

Mostrar los números de 1 a 10 utilizando el bucle while

$i=1
while($i -lt 11){
$i
$i++
}

• Bucle Do-While

Ejemplos

Mostrar los números de 1 a 10 utilizando el bucle do-while

$i=1
do{
$i
$i++
}while($i -lt 11)

• Bucle For

Ejemplos

Mostrar los números de 1 a 10 utilizando el bucle for

for($i=1;$i -lt 11;$i++)
{
$i
}

• Bucle Foreach

Ejemplo

Mostrar los números de 1 a 10 utilizando el bucle foreach

foreach($i in 1..10)
{
$i
}

Mostrar los números de 1 a 10 utilizando el bucle foreach abreviado

1..10 | % {$_}

Ejercicios

Recorrer de distintas formas de 1 a 3 con Foreach

#Forma 1
$numeros=1..3

#Forma 2
$numeros | %{$PSItem}

#Forma 3
$numeros | %{$_}

#Forma 4
foreach($numero in $numeros)
{
$numero
}

Funciones

Una función es un conjunto de líneas de código que realizan una tarea específica y puede retornar un valor.

Las funciones pueden tomar parámetros que modifiquen su funcionamiento.

Las funciones son utilizadas para descomponer grandes problemas en tareas simples y para implementar operaciones que son comúnmente utilizadas durante un programa y de esta manera reducir la cantidad de código.

Cuando una función es invocada se le pasa el control a la misma, una vez que esta finalizó con su tarea el control es devuelto al punto desde el cual la función fue llamada.

El esquema de una función:

function funcion1
{
  param
  (
    [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
    [String[]]
    [AllowEmptyString()]
    $Var,$Var2
  )
  begin
  {
  }
  process
  {
  }
  end
  {
  }
}

Ejemplos

Pedir a un usuario su nombre y mostrarlo mediante una función

function Get-Nombre
{
  param
  (
    $Name = $(
      Write-Host 'Introduzca su nombre: '-ForegroundColor Yellow -NoNewLine
      Read-Host
    )
  )

  "Tu nombre es: $Name"
}

#Ejecutar la función
Get-Nombre

Hacer un login creando una función que comprueba un nombre de usuario y una contraseña

function funcion5
{
  param
  (
    [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
    [String[]]
    [AllowEmptyString()]
    $User,$Pass
  )

  begin
  {
    Write-Host "Principio de login"
    $usercorrecto="Carlos"
    $passcorrecto="Contraseña"
  }

  process
  {
   if($User -eq $usercorrecto -and $Pass -eq $passcorrecto)
    {
        $ok=1
    }
    else
    {
        $ok=0
    }
  }
  end
  {
   if($ok)
    {
        Write-Host "User correcto"
    }
    else
    {
        Write-Host "User no correcto"
    }
    Write-Host "Fin de login"
  }
}

#Ejecutar la función
funcion4 Carlos Contraseña

Hacer un login avanzado creando una función que comprueba un nombre de usuario y una contraseña

###############################################################################
#Función login de user y pass
#El user y pass (hash en MD5) correcto se escriben en el bloque BEGIN

#Ejecutar la función
#PS C:\Users\usuario>loginH user pass

function loginH
{
  param
  (
    [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
    [String[]]
    [AllowEmptyString()]
    $User,$Pass
  )

  begin
  {
    Write-Host "Principio de login"
    $usercorrecto="user"
    #El pass en MD5
    #$passcorrecto="pass"
    $passcorrecto="1A1DC91C907325C69271DDF0C944BC72"
  }

  process
  {
   #Realizar el MD5 del pass introducido por el usuariO
   [Reflection.Assembly]::LoadWithPartialName("System.Web")
   $Pass
   if($User -eq $usercorrecto -and [System.Web.Security.FormsAuthentication]::HashPasswordForStoringInConfigFile($Pass, "MD5") -eq $passcorrecto)
    {
        $ok=1
    }
    else
    {
        $ok=0
    }
  }
  end
  {
   if($ok)
    {
        Write-Host "User correcto"
    }
    else
    {
        Write-Host "User no correcto"
    }
    Write-Host "Fin de login"
  }
}
###############################################################################

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

• Procesador
• Memoria
  • Memoria caché
  • Acceso directo a memoria
• Discos duros
• Buses
  • Conexiones E/S
• Dispositivos de entrada y salida
  • Entrada
  • Salida
  • Entrada y salida
• Placa base y otros componentes
  • BIOS
  • Batería
  • Refrigeración

El hardware es el conjunto de componentes físicos que constituyen un ordenador y que mediante conexiones con dispositivos auxiliares permiten realizar las funciones de procesamiento, almacenamiento y transferencia de datos.

El procesamiento consiste en recibir datos, realizar cálculos y operaciones con los mismos, el almacenamiento consiste en almacenar datos durante un periodo de tiempo y la transferencia consiste en enviar los resultados procesados al exterior.

El hardware son los elementos físicos que se pueden tocar. Sirven para realizar tareas que se resuelven mediante el software, algunos elementos hardware son: la caja donde está la placa base, el procesador, la memoria, el disco duro, etc. También se consideran hardware los dispositivos de entrada y salida como la pantalla, el teclado, el ratón, etc.

Una de las funciones del sistema operativo es controlar y gestionar el uso del hardware del ordenador: procesador, dispositivos de E/S, memoria principal, tarjetas gráficas y el resto de periféricos.

Los componente hardware más importantes son:

• Procesador
• Memoria
• Discos
• Buses
• Dispositivos de entrada y salida
• Placa base y otros componentes

Procesador

También conocido como CPU (Central Processing Unit, unidad central de procesamiento), es el cerebro del ordenador. Su función es leer instrucciones y ejecutarlas, estas instrucciones configuran un conjunto de datos codificados en binario que se almacena en la memoria. Todos los programas se componen de instrucciones, cada instrucción se ejecuta mediante un ciclo básico de ejecución que es el período que tarda el procesador en ejecutar una instrucción.

La CPU funciona del siguiente modo: obtiene la obtiene la primera instrucción de la memoria, la decodifica para determinar el código de operación y los datos, después la ejecuta y en algunos casos almacena el resultado. Este proceso se ejecuta continuamente hasta que se leen todas las instrucciones del programa.

Un concepto importante al hablar de CPU y que nos permite comprender algunas de sus funciones es la arquitectura. Una arquitectura indica qué hace un ordenador y define el conjunto de instrucciones y cómo se codifican, los datos que maneja, los registros internos, etc. Cada arquitectura es distinta aunque puede haber características similares entre arquitecturas.

Para una arquitectura puede haber distintas organizaciones. La organización define cómo realiza las funciones un ordenador; por último, la realización del ordenador se encarga de implantar físicamente una organización. Pongamos un ejemplo de todo esto: la arquitectura IA-32 conocida como x86, x86-32 o i386 tiene las organizaciones 8086, Pentium 4, etc. Y en el caso de Pentium 4 la realización puede ser de 2,4 GHz, 3,4 GHz, etc.

Otro ejemplo son las implementaciones de x86-64 (x86-64 está basada en la extensión del conjunto de instrucciones x86 para manejar direcciones de 64 bits): AMD64 e Intel64 en el caso de Intel64 tiene las organizaciones Core 2 Duo, Core 2 Quad, y Core 2 Extreme, etc. La realización de un Core 2 Quad puede ser de 3,40 GHz, 3,80, GHz etc.

Cmdlet con llamada WMI que muestra información sobre los procesadores

Get-WmiObject Win32_Processor

Ejemplos

Información sobre la arquitectura

(Get-WmiObject Win32_Processor).caption

Información sobre la organización

(Get-WmiObject Win32_Processor).name

Información sobre la realización

((Get-WmiObject Win32_Processor).name).split("@")[1]

Información sobre los procesadores

Get-WmiObject -Class Win32_Processor | Select -Property Name, Number*

Número de cores

Get-WmiObject -Class Win32_Processor | Select-Object NumberOfCores
Get-WmiObject -query "select NumberOfCores from Win32_Processor"

Carga del procesador

Get-WmiObject win32_processor | Select-Object LoadPercentage

Ejercicios

Información sobre el procesador

Get-WmiObject -class "Win32_Processor"| % {
    Write-Host "CPU ID: "
    Write-Host $_.DeviceID
    Write-Host "CPU Model: "
    Write-Host $_.Name
    Write-Host "CPU Cores: "
    Write-Host $_.NumberOfCores
    Write-Host "CPU Max Speed: "
    Write-Host $_.MaxClockSpeed
    Write-Host "CPU Status: "
    Write-Host $_.Status
    Write-Host
}

Saber si el procesador es Intel o AMD

if((Get-WmiObject Win32_Processor).Caption -match "Intel"){"Intel"}else{"No es Intel"}

Memoria

Se encarga de almacenar los programas que se están ejecutando en el ordenador y los datos necesarios para la ejecución de dichos programas.

En teoría las memorias tiene que ser muy rápidas, de gran tamaño y con bajo precio, pero actualmente no existe ninguna tecnología que reúna estos requisitos, como solución a esta situación existe la jerarquía de memoria.

Dos principios sobre la memoria:

• Menor cantidad, acceso más rápido.
• Mayor cantidad, menor coste por byte.

La idea es que la memoria se organice en niveles, cuanto más cercanos al procesador, más pequeños, rápidos y caros. El objetivo de es conseguir un rendimiento de memoria a gran velocidad y de un tamaño igual al nivel más bajo de la jerarquía. A medida que bajamos en los niveles, la velocidad es menor pero el almacenamiento es mayor.

El primer nivel de la jerarquía es el de los registros que se están en el procesador, son muy rápidos pero limitados; el siguiente nivel es la caché que son zonas de gran velocidad y muy próximas a la CPU en donde se almacena la información que se utiliza con más frecuencia; el siguiente nivel es la memoria principal, a esta memoria se la conoce como RAM (Random Access Memory, memoria de acceso aleatorio) y tiene las siguientes características:

• Es una memoria de acceso aleatorio; se accede directamente a una determinada posición de la memoria sin pasar por las anteriores.
• Es una memoria volátil, mantiene los datos hasta que se corta la alimentación.
• Es una memoria de lectura/escritura, se pueden leer los datos que tiene almacenados y escribir en ella nuevos datos o resultados.

Algunos tipos de memoria RAM son DRAM (Dynamic Random Access Memory, memoria de acceso aleatorio dinámica), SRAM (Static Random Access Memory, memoria estática de acceso aleatorio), SDRAM (Synchronous Dynamic Random Access Memory, memoria de acceso aleatorio dinámica síncrona) y DDR SDRAM (Double Data Rate, doble tasa de transferencia de datos).

Cmdlets con llamadas WMI que muestran información sobre la memoria

Get-WmiObject Win32_MemoryArray
Get-WmiObject Win32_MemoryArrayLocation
Get-WmiObject Win32_MemoryDevice
Get-WmiObject Win32_MemoryDeviceArray
Get-WmiObject Win32_MemoryDeviceLocation
Get-WmiObject Win32_PhysicalMemory
Get-WmiObject Win32_PhysicalMemoryArray
Get-WmiObject Win32_PhysicalMemoryLocation
Get-WmiObject Win32_SMBIOSMemory

Ejemplos

Lugar físico en donde se encuentran las memorias

Get-WmiObject Win32_PhysicalMemory | Select-Object BankLabel

Velocidad de reloj del dispositivo de memoria en megahercios

Get-WmiObject Win32_PhysicalMemory | Select-Object ConfiguredClockSpeed

Voltaje configurado para los dispositivos de memoria en milivoltios

Get-WmiObject Win32_PhysicalMemory | Select-Object ConfiguredVoltage

Capacidad de la memoria en bytes

Get-WmiObject Win32_PhysicalMemory | ForEach-Object {$_.capacity / 1GB}

Tipo de memoria

Get-WmiObject Win32_PhysicalMemory | Select-Object MemoryType

Tipo de implementación del chip de los dispositivos de memoria

Get-WmiObject Win32_PhysicalMemory | Select-Object FormFactor

Máxima y mínima tensión soportada por los dispositivos de memoria

Get-WmiObject Win32_PhysicalMemory | Select-Object MaxVoltage,MinVoltage

Velocidad de la memoria en nanosegundos

Get-WmiObject Win32_PhysicalMemory | Select-Object Speed

Ejercicios

Saber si el fabricante de la memoria es Elpida, Kingston o Hynix

if((Get-WmiObject Win32_PhysicalMemory).Manufacturer -match "Elpida"){"Elpida"}else{"No es Elpida"}

• Memoria caché

La memoria caché es un área de almacenamiento dedicada a los datos usados o solicitados con más frecuencia para su recuperación a gran velocidad.

Cmdlets con llamadas WMI que muestran información sobre la memoria caché

Get-WmiObject Win32_AssociatedProcessorMemory
Get-WmiObject Win32_CacheMemory

• Acceso directo a memoria

DMA (Direct Memory Access, Acceso directo a memoria) es un chip se encarga de la transferencia y accede a la memoria para leer o escribir datos que recibe y envía el dispositivo sin pasar por el procesador.

Cmdlets con llamadas WMI que muestran información sobre DMA

Get-WmiObject Win32_DMAChannel
Get-WmiObject Win32_DeviceMemoryAddress
Get-WmiObject Win32_SystemMemoryResource

Discos duros

El último nivel en la jerarquía de memoria son los discos duros. Son dispositivos de almacenamiento no volátil, es decir, no se pierde la información cuando se desconecta la energía. La capacidad de almacenamiento de los discos duros es muy superior a la RAM, siendo además de menor precio; sin embargo, el problema está en que es lento acceder a la información, esto se debe a que disco es un dispositivo mecánico y tiene que moverse hasta llegar a la información.

Un disco duro consiste en uno o varios platos que están girando, mientras giran hay un componente dentro del disco que llamado brazo mecánico, que en el extremo tiene dos cabezas que leen y escriben sobre la cada una de las superficies del plato (caras), dentro de un disco hay varios platos.

Cmdlet que muestra información sobre los discos duros

Get-Disk

Cmdlet con llamada WMI que muestra información sobre los discos duros

Get-WmiObject Win32_DiskDrive

Ejemplo

Obtener información sobre los discos que hay conectados

Get-Disk

Buses

Hay un elemento muy importante que interviene en la comunicación entre procesador, memoria y dispositivos de entrada y salida denominado bus, éste se define como un conjunto de líneas por las que se transmite información entre distintos componentes hardware.

Algunos de los buses que tienen los ordenadores actuales son el PCI (Peripheral Component Interconnect, interconexión de componentes periféricos), Express, ISA (Industry Standard Architecture, Arquitectura estándar de la industria), USB (Universal Serial Bus, Bus universal en serie), IEEE 1394 (también llamado FireWire), etc.

Cmdlets con llamadas WMI que muestran información sobre los buses PCI, ISA

Get-WmiObject Win32_AllocatedResource
Get-WmiObject Win32_Bus
Get-WmiObject Win32_DeviceBus
Get-WmiObject Win32_PortResource

Cmdlets con llamadas WMI que muestran información sobre los buses IDE

Get-WmiObject Win32_IDEController
Get-WmiObject Win32_IDEControllerDevice

Cmdlets con llamadas WMI que muestran información sobre los buses SCSI

Get-WmiObject Win32_SCSIController
Get-WmiObject Win32_SCSIControllerDevice

Cmdlets con llamadas WMI que muestran información sobre los buses USB

Get-WmiObject Win32_ControllerHasHub
Get-WmiObject Win32_USBController
Get-WmiObject Win32_USBControllerDevice
Get-WmiObject Win32_USBHub

Cmdlets con llamadas WMI que muestran información sobre los buses IEEE 1394

Get-WmiObject Win32_1394Controller
Get-WmiObject Win32_1394ControllerDevice

Cmdlets con llamadas WMI que muestran información sobre otros buses y puertos

Get-WmiObject Win32_InfraredDevice
Get-WmiObject Win32_ParallelPort
Get-WmiObject Win32_PCMCIAController
Get-WmiObject Win32_SerialPort
Get-WmiObject Win32_SerialPortConfiguration
Get-WmiObject Win32_SerialPortSetting

Ejemplos

Buses conectados al sistema operativo

(Get-WmiObject Win32_Bus).DeviceID

Buses USB conectados al sistema

Get-WmiObject Win32_USBControllerDevice |%{[wmi]($_.Dependent)} | Sort Manufacturer,Description,DeviceID | Ft -GroupBy Manufacturer Description,Service,DeviceID

• Conexiones E/S

Las conexiones de la entrada y salida se realizan mediante interrupciones y otros tipos de conexiones.

Las IRQ son líneas que llegan al controlador de interrupciones, un componente de hardware dedicado a la gestión de las interrupciones, y que puede estar integrado en el procesador principal o ser un circuito separado conectado al mismo.

Cmdlet con llamada WMI que muestra información sobre interrupciones

Get-WmiObject Win32_IRQResource

Cmdlet que muestra información sobre conexiones de entrada y salida

Get-PnpDevice

Cmdlets con llamadas WMI que muestran información sobre otros tipos de conexiones de entrada y salida

Get-WmiObject Win32_DeviceSettings
Get-WmiObject Win32_OnBoardDevice
Get-WmiObject Win32_PNPAllocatedResource
Get-WmiObject Win32_PNPDevice
Get-WmiObject Win32_PNPEntity
Get-WmiObject Win32_SystemDriverPNPEntity

Dispositivos de entrada y salida

La transferencia de datos se realiza mediante el sistema de entrada y salida, de esta forma es posible comunicarse con el exterior y así poder recibir datos y enviar los resultados.

Los dispositivos de E/S tienen dos partes: un dispositivo controlador y el dispositivo en sí. El dispositivo controlador es un chip o un conjunto de chips que controlan físicamente el dispositivo. La comunicación entre el dispositivo controlador y el sistema operativo se realiza mediante un software llamado driver. Los dispositivos de E/S se pueden dividir en dos: dispositivos de bloque y de carácter.

Los dispositivos de bloque almacenan información en bloque de tamaño fijo, algunos ejemplos son los discos duros, CDs y memorias USB. Los dispositivos de carácter, como su propio nombre indica, envían información en forma de carácter, un ejemplo es el teclado.

Los dispositivos en sí pueden ser de entrada, salida o ambos. Se conocen como periféricos.

• Entrada

Cmdlet con llamada WMI que muestra información sobre el teclado

Get-WmiObject Win32_Keyboard

Cmdlet con llamada WMI que muestra información sobre el ratón

Get-WmiObject Win32_PointingDevice

• Salida

Cmdlets con llamadas WMI que muestran información sobre el monitor y vídeo

Get-WmiObject Win32_DesktopMonitor
Get-WmiObject Win32_DisplayControllerConfiguration
Get-WmiObject Win32_VideoController
Get-WmiObject Win32_VideoSettings

Cmdlet con llamada WMI que muestra información sobre el dispositivo de sonido

Get-WmiObject Win32_SoundDevice

Cmdlets con llamadas WMI que muestran información sobre las impresoras

Get-WmiObject Win32_DriverForDevice
Get-WmiObject Win32_Printer
Get-WmiObject Win32_PrinterConfiguration
Get-WmiObject Win32_PrinterController
Get-WmiObject Win32_PrinterDriver
Get-WmiObject Win32_PrinterDriverDll
Get-WmiObject Win32_PrinterSetting
Get-WmiObject Win32_PrintJob
Get-WmiObject Win32_TCPIPPrinterPort

• Entrada y salida

Cmdlets con llamadas WMI que muestran información sobre el CD y DVD

Get-WmiObject Win32_CDROMDrive
Get-WmiObject Win32_PhysicalMedia

Cmdlets que muestra información sobre los adaptadores de red

Get-NetAdapterHardwareInfo
Get-NetAdapter -Physical

Cmdlets con llamadas WMI que muestran información sobre los adaptadores de red

Get-WmiObject Win32_NetworkAdapter
Get-WmiObject Win32_NetworkAdapterConfiguration
Get-WmiObject Win32_NetworkAdapterSetting

Ejemplos

Impresoras en el sistema

Get-WmiObject Win32_Printer

Ver los dispositivos plug and play

Get-WmiObject -query “select Name,Status from Win32_PnPEntity”

Ver el estado de los dispositivos plug and play

Get-WmiObject -Class Win32_Processor | Select -Property Name, Number*

Ver información sobre la webcam

Get-WmiObject -query "select * from Win32_PnPEntity where caption like '%cam%'"
Get-WmiObject Win32_PnPEntity | where {$_.caption -match 'webcam'}

Ejercicio

Imprimir un texto en todas las impresoras conectadas al equipo

(Get-WmiObject Win32_Printer).name | %{"Texto"| Out-Printer}

Placa base y otros componentes

Cmdlet con llamada WMI que muestra información sobre el equipo

Get-WmiObject Win32_ComputerSystem

Cmdlet con llamada WMI que muestra información sobre el fabricante del equipo

Get-WmiObject Win32_SystemEnclosure

Cmdlets con llamadas WMI que muestran información sobre la placa base

Get-WmiObject Win32_BaseBoard
Get-WmiObject Win32_MotherboardDevice

Ejemplo

Fabricante de placa base

(Get-WmiObject Win32_BaseBoard).Manufacturer

Identificación del equipo

(Get-WmiObject Win32_SystemEnclosure).SerialNumber

• BIOS

Cuando un ordenador se enciende, generalmente el procesador busca la BIOS y la ejecuta, la BIOS (Basic Input-Output System) no sólo es el primer paso del proceso de arranque, sino que también proporciona una interfaz de bajo nivel para dispositivos periféricos. La BIOS comprueba los dispositivos hardware conectados al ordenador y localiza un dispositivo con el que arrancar el sistema.

En los ordenadores que utilizan la BIOS, una vez que ésta ha comprobado los dispositivos hardware, intenta localizar un dispositivo con el que arrancar. Cuando el dispositivo que arranca es el disco duro, la BIOS carga en memoria el programa que resida en el primer sector de este dispositivo, ese programa se llama MBR (Master Boot Record, Registro maestro de arranque).

A parte del MBR también se puede cargar la tabla de partición GUID (GPT), en la actualidad el MBR ha sido sustituido por la tabla de partición GUID.

Cmdlets con llamadas WMI que muestran información sobre la BIOS

Get-WmiObject Win32_BIOS
Get-WmiObject Win32_SystemBIOS

Ejemplo

Información de la BIOS

(Get-WmiObject Win32_BIOS).Version

• Batería

Cmdlets con llamadas WMI que muestran información sobre la batería

Get-WmiObject Win32_Battery
Get-WmiObject Win32_CurrentProbe
Get-WmiObject Win32_PortableBattery
Get-WmiObject Win32_PowerManagementEvent
Get-WmiObject Win32_VoltageProbe

Ejemplo

Porcentaje de carga de batería restante

(Get-WmiObject Win32_Battery).EstimatedChargeRemaining

• Refrigeración

Cmdlets con llamadas WMI que muestran información sobre la refrigeración del equipo

Get-WmiObject Win32_Fan
Get-WmiObject Win32_HeatPipe
Get-WmiObject Win32_Refrigeration
Get-WmiObject Win32_TemperatureProbe
Get-WmiObject MSAcpi_ThermalZoneTemperature -Namespace "root/wmi"

Ejemplo

Temperatura de CPU (hay que ejecutar PowerShell como administrador)

$Temperatura = Get-WmiObject MSAcpi_ThermalZoneTemperature -Namespace "root/wmi"
$Kelvin = $Temperatura.CurrentTemperature / 10
$Celsius = $Kelvin - 273.15
$Celsius.ToString() + "C "

Ejercicio

Obtener la mayor cantidad de información sobre el hardware

(Get-WmiObject Win32_AutochkSetting).SettingID
(Get-WmiObject Win32_BaseBoard).Manufacturer
(Get-WmiObject Win32_BIOS).Version
(Get-WmiObject Win32_Bus).DeviceID
Get-WmiObject Win32_Processor
Get-WmiObject Win32_SystemEnclosure
Get-WmiObject Win32_Battery
Get-WmiObject Win32_Printer

The post 3. Gestión del hardware en PowerShell appeared first on Scripting and security.