#Listado los dominios de Cloudflare, Inc. que aparecen en la primera página en Netcraft
[String]$resultado=(Invoke-WebRequest "http://toolbar.netcraft.com/netblock?q=CLOUDFLARENET,104.16.0.0,104.31.255.255").AllElements.href | Select-String "site_report" | Select-String "http://" | Select-String -NotMatch "#"
$resultado.replace("/site_report?url=","").split(" ")
The post Listar los dominios de Cloudflare appeared first on Scripting and security.
$json=(Invoke-WebRequest -Uri 'http://jesusninoc.com/wp-json/wp/v2/users/').content | ConvertFrom-JSON
Start-Process ($json.avatar_urls.96).Replace("s=96","s=800")
The post Ver el avatar de un usuario de WordPress en tamaño gigante con PowerShell appeared first on Scripting and security.
$redandroid=.\adb.exe shell netstat
$redandroid
#Quitar espacios las partes de cada línea
$redandroid=$redandroid -replace(" "," ") -replace(" "," ") -replace(" "," ")
#Quitar espacios al principio y al final
$redandroid.trim() | %{$_}
#Mostrar la columna con las direcciónes IP remotas (Address)
$redandroid.trim() | %{$_.split(" ")[4]}
#Agrupar por dirección IP remota
$redandroid.trim() | %{
$direccionremota=$_.split(" ")[4]
if($direccionremota)
{
$direccionremota.split(":")[0]
}
} | Group-Object
#Consultar información sobre cada dirección IP agrupada
($redandroid.trim() | %{
$direccionremota=$_.split(" ")[4]
if($direccionremota)
{
$direccionremota.split(":")[0]
}
} | Group-Object | select Name).name | %{[Net.DNS]::GetHostEntry($_) | Format-Custom}
The post Analizar la información de red en un dispositivo Android con ADB y PowerShell appeared first on Scripting and security.
Add-Type -AssemblyName System.Speech
$synthesizer = New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer
$synthesizer.SelectVoice("Microsoft Zira Desktop")
$synthesizer.Rate=0
$json=Invoke-WebRequest -Uri 'https://en.wikipedia.org/w/api.php?action=parse&format=json&prop=text&page=PowerShell' | ConvertFrom-JSON
$json.parse.text.'*' -replace "<.*?>" | %{
$synthesizer.Speak($_)
}
The post Leer artículos de la Wikipedia mediante la voz del Sistema Operativo con PowerShell appeared first on Scripting and security.
Start-Process ((((Invoke-WebRequest "http://www.alexa.com/siteinfo/jesusninoc.com").Images | ? { $_.outerHTML -match "traffic.alexa.com"})[0]).src).replace("&","&")The post How is this site ranked relative to other sites? appeared first on Scripting and security.
ls *.mp4 | %{
$_.FullName
#Descargar FFmpeg https://ffmpeg.org/download.html
E:\programas\ffmpeg\bin\ffmpeg.exe -i $_.FullName -acodec libmp3lame -ab 128k $_.FullName.replace(".mp4",".mp3")
}
The post Convertir una lista de ficheros MP4 a MP3 con FFmpeg appeared first on Scripting and security.
$urls='http://www.bing.com/search?q=powershell'
$result=Invoke-WebRequest $urls
$valor=($result.AllElements | ? {$_.class -eq “sb_count”}).innerText
$valor
$valor=$valor.replace(".","").replace("resultados","")
switch([Int]$valor)
{
{$_ -ge 0 -and $_ -le 1000}{"Poco importante"}
{$_ -ge 1001 -and $_ -le 10000}{"Algo importante"}
{$_ -ge 10000 -and $_ -le 100000000}{"Muy importante"}
}
The post Conocer la relevancia de una búsqueda en Bing 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
}
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.
#Leer nombres en un fichero para realizar la búsqueda en Google, crear el fichero con los términos de búsqueda
Get-Content .\nombres.txt | %{
$urls='https://www.google.com/search?q='+ $_ +''
$result=Invoke-WebRequest $urls
$valor=($result.AllElements | ? {$_.id -eq “resultStats”}).innerText
$valor=$valor.replace("Aproximadamente","")
$valor=$valor.replace("resultados","")
$valor=$valor.Trim()
Write-Host $_
Write-Host $valor
}
The post Conocer la relevancia de varias búsquedas en Google appeared first on Scripting and security.
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:
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:
Asignar un valor a una variable y mostrar el valor por pantalla
$cantidad=20 Write-Host $cantidad
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.
El ámbito de una variable (llamado “scope” en inglés) es la zona del programa en la que se define la variable.
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.
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()
Ver el tipo de las siguientes variables
[Int]$num=5 $num.GetType() [Char]$num=5 $num.GetType()
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()
Variables que representan valores enteros.
$num=5 $num
Variables que representan valores tipo carácter.
#Caracteres $car='c' $car
Representan el valor verdadero (1) o falso (0).
$true $false
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
Mostrar la fecha actual
(Get-Date)
Mostrar año
Get-Date).Year
La fecha del sistema se puede cambiar utilizando el cmdlet
Set-Date
Cambiar la fecha del sistema
Set-Date -date "6/1/2006 8:30 AM"
A las fechas se les puede dar formato
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
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")}
Calcular de forma aleatoria un día entre hoy y hace cinco años
#Día aleatorio entre hoy y hace cinco años $diaaleatorio=Get-Random (1..(5*365)) (Get-Date).AddDays(-$diaaleatorio)
Para crear una variable que representa un intervalo de tiempo se utiliza el cmdlet
New-TimeSpan
Mostrar el intervalo de tiempo entre dos fechas
New-TimeSpan $(Get-Date) $(Get-Date -month 7 -day 19 -year 2016)
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 que contienen números.
Crear un array de números y mostrar el primer elemento
$arraynumeros="12345" Write-Host $arraynumeros Write-Host $arraynumeros[1]
Arrays que contienen cualquier tipo de carácter y se denominan cadenas.
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:
$palabra1='hola-' $palabra2='adios' $frasecontatenada=$palabra1+$palabra2 $frasecontatenada
'Hola'.Length
'Hola'.ToUpper()
'Hola'.ToLower()
'Hola'.Replace('o', '0')
"Hola buenas Lucas"-replace "hola|buenas","adios"
'Hola,buenas'.Split(',')
'Hola buenas '.TrimStart() 'Hola buenas '.TrimEnd() 'Hola buenas '.Trim()
'Hola'.Substring(0) 'Hola'.Substring(0,2) 'Hola'.Substring(2) 'Hola'.Substring(2,1)
Reducir texto con puntos suspensivos
$LongitudMax = 10
$Texto = 'Texto para acortar'
if ($Texto.Length -gt $LongitudMax)
{
$Texto.Substring(0,$LongitudMax) + '...'
}
else
{
$Texto
}
'Hola'.Insert(2, "oooo")
'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)
'Holasa'.IndexOf('a')
'Holasa'.LastIndexOf('a')
'Hola'.StartsWith('H')
'Hola'.EndsWith('lo')
'Hola'.Contains('a')
'Hola'| Select-String 'o'
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
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.
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:
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
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()
En PowerShell se pueden crear clases y de las clases crear objetos.
En las clases se pueden definir además de lo dicho anteriormente también se pueden crear constructores dentro de las clases.
class Clase
{
[string]$Valor
Constructor([string]$Valor)
{
$this.Valor = $Valor
}
}
Crear una clase con un constructor
class Coche
{
[string]$Marca
[string]$Modelo
#Constructor 1
Coche([string]$Marca, [string]$Modelo)
{
$this.Marca = $Marca
$this.Modelo = $Modelo
}
}Crear el objeto para la clase creada
[Coche]::new("Audi","A3")
Los objetos en PowerShell se pueden sobrecargar, la sobrecarga se refiere a la posibilidad de tener dos o más funciones con el mismo nombre pero funcionalidad diferente. Es decir, dos o más funciones con el mismo nombre realizan acciones diferentes.
Realizar sobrecargas en constructores de una clase
class Coche
{
[string]$Marca
[string]$Modelo
#Constructor 1
Coche([string]$Marca, [string]$Modelo)
{
$this.Marca = $Marca
$this.Modelo = $Modelo
}
#Constructor 2
Coche ([string]$Modelo)
{
$this.Marca = "NS"
$this.Modelo = $Modelo
}
#Constructor 3
Coche ()
{
$this.Marca = "No definido"
$this.Modelo = "No definido"
}
}
Las variables tienen el problema de ser temporales por eso necesitamos poder almacenar datos de forma permanente mediante los ficheros.
Obtener el contenido de un archivo de texto
"Hi" | Out-File file.txt Get-Content file.txt
Obtener las dos primeras líneas de un fichero
Get-Content .\fichero.txt -First 2
Obtener las dos últimas líneas de un fichero
Get-Content .\fichero.txt -Tail 2
Leer el contenido de un fichero en decimal
[System.IO.File]::ReadAllBytes('.\eje.txt')
Con las variables se pueden realizar las siguientes operaciones aritméticas:
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 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 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 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 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
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"
}
Se pueden realizar conversiones entre sistemas de numeración.
Los sistemas numéricos están compuestos por símbolos y por las normas utilizadas para interpretar estos símbolos. El sistema numérico que se usa más a menudo es el sistema numérico decimal, o de Base 10. El sistema numérico que se usa más a menudo es el sistema numérico decimal, o de Base 10. El sistema numérico de Base 10 usa diez símbolos: 0, 1, 2, 3, 4, 5, 6, 7, 8 y 9. Estos símbolos se pueden combinar para representar todos los valores numéricos posibles.
Los ordenadores reconocen y procesan datos utilizando el sistema numérico binario, o de Base 2. El sistema numérico binario usa sólo dos símbolos, 0 y 1, en lugar de los diez símbolos que se utilizan en el sistema numérico decimal. La posición, o el lugar, que ocupa cada dígito de derecha a izquierda en el sistema numérico binario representa 2, el número de base, elevado a una potencia o exponente, comenzando desde 0. Estos valores posicionales son, de derecha a izquierda, 2 potencia 0, 2 potencia 1, 2 potencia 2, 2 potencia 3, 2 potencia 4, 2 potencia 5, 2 potencia 6 y 2 potencia 7, o sea, 1, 2, 4, 8, 16, 32, 64 y 128, respectivamente.
El inconveniente de la codificación binaria es que la representación de algunos números resulta muy larga. Por este motivo se utilizan otros sistemas de numeración que resulten más cómodos de escribir: el sistema octal y el sistema hexadecimal. Afortunadamente, resulta muy fácil convertir un número binario a octal o a hexadecimal.
Otro sistema utilizado es hexadecimal, el sistema hexadecimal usa dieciséis símbolos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E y F. Se utilizan los caracteres A, B, C, D, E y F representando las cantidades decimales 10, 11, 12, 13, 14 y 15 respectivamente, porque no hay dígitos mayores que 9 en el sistema decimal. Cada dígito tiene, naturalmente, un valor distinto dependiendo del lugar que ocupen. El valor de cada una de las posiciones viene determinado por las potencias de base 16.
Convertir un número binario a decimal
$binario = "11111111" [Convert]::ToInt32($binario,2)
Convertir un número decimal a octal
$decimal = 3232 [Convert]::ToString($decimal, 8)
Convertir un número decimal a hexadecimal
$decimal = 3232 [Convert]::ToString($decimal, 16)
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:
Tabla lógica del operador and
| x | y | resultado |
| true | true | true |
| true | false | false |
| false | true | false |
| false | false | false |
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
Tabla lógica del operador or
| x | y | resultado |
| true | true | true |
| true | false | true |
| false | true | true |
| false | false | false |
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
Tabla lógica del operador not
| x | resultado |
| true | false |
| false | true |
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
Algunas operaciones de comparación que se pueden realizar en PowerShell son:
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
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
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
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
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
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
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:
Comprobar si un número es igual a otro utilizando if
$a=5
if($a -eq 5)
{
Write-Host “5”
}
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”
}
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”
}
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
}
}
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:
Mostrar los números de 1 a 10 utilizando el bucle while
$i=1
while($i -lt 11){
$i
$i++
}
Mostrar los números de 1 a 10 utilizando el bucle do-while
$i=1
do{
$i
$i++
}while($i -lt 11)
Mostrar los números de 1 a 10 utilizando el bucle for
for($i=1;$i -lt 11;$i++)
{
$i
}
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 | % {$_}
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
}
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
{
}
}
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-NombreHacer 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ñaHacer 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.
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:
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:
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:
Cmdlet
Get-Package
WMI
Get-WmiObject win32_Product Get-WmiObject -query "select name from win32_product"
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-ObjectIndicar cuántos programas hay por familia
((Get-WmiObject -Class Win32_Product).vendor | Group-Object)
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 PlayerBuscar 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){$_}
}
Cmdlet
Find-Package
Buscar la herramienta ZoomIt
Find-Package zoomit
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
Instalar sofware buscándolo previamente
Find-Package zoomit | Install-Package
Cmdlet
Uninstall-Package
Desinstalar sofware
Uninstall-Package zoomit
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.
Cmdlet
Get-HotFix Get-Package
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
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.
Para no tener que recurrir a la restauración de copias de seguridad o reparación del sistema operativo, hay que detectar los problemas antes de que ocurran.
Desde PowerShell se puede monitorizar el sistema mediante los administradores de tareas y procesos que dan información sobre los procesos y servicios que se ejecutan en el sistema.
Los cmdlets que sirven para monitorizar lo que está relacionado con procesos son:
Ver procesos
Get-Process gps ps Get-WmiObject -Class win32_process
Matar procesos
Stop-Process
Ver hilos
Get-WmiObject -Class Win32_Thread
Ver servicios
Get-Service Get-WmiObject -Class Win32_Service Get-WmiObject -query "select * from win32_service"
En PowerShell se puede gestionar el rendimiento mediante el Monitor de rendimiento, que analiza el rendimiento del sistema operativo. Tiene control de la CPU, el disco, la red y la memoria. Se puede monitorizar el rendimiento en tiempo real o de forma continuada.
Ver todos los nombres de los contadores de rendimiento
Get-Counter -ListSet * | Sort-Object CounterSetName | Format-Table CounterSetName
Ver todas las rutas de los contadores de rendimiento
(Get-Counter -ListSet *).Paths
Ver las rutas de los contadores de rendimiento para el USB
(Get-Counter -ListSet USB).Paths
Ver el número de conexiones TCP establecidas
Get-Counter -Counter "\TCPv4\Conexiones establecidas"
El control de lo que ocurre en el sistema operativo se lleva a cabo mediante los Eventos del sistema, que son acontecimientos que ocurren en el sistema operativo.
El visor de eventos en Windows permite ver y examinar eventos que ocurren en el equipo. Windows tiene definidos tres tipos de registros de eventos o sucesos:
Cmdlet que sirve para administrar registros de eventos
Get-EventLog
Ver eventos disponibles
Get-EventLog -List
Ver información sobre un tipo de evento
Get-EventLog Application Get-EventLog HardwareEvents Get-EventLog "Internet Explorer" Get-EventLog Security Get-EventLog System Get-EventLog "Windows PowerShell"
Agrupar mensajes del log Application
Get-EventLog Application | Group-Object Message Get-EventLog Application | Group-Object Message | Select-Object Name Get-EventLog Application | Group-Object Message | Select-Object Name | Format-Custom
Información sobre IP en los logs
Get-EventLog Application | Where-Object Message -Match "192.168" Get-EventLog Application | Where-Object Message -Match "192.168" | Select-Object Message Get-EventLog Application | Where-Object Message -Match "192.168" | Select-Object Message | Format-Custom
Ver todos los logs desde hace un día
Get-EventLog -LogName System -EntryType Error, Warning -After (Get-Date).AddDays(-1)
Ver intentos de inicio de sesión con credenciales explícitas (información por tipo de log)
Get-EventLog -LogName Security | Where {$_.InstanceID -eq 4648} | Select-Object Message | Format-List
Información sobre el mensaje “explore”, analizar el proceso Explore
Get-EventLog Application | Where-Object Message -Match "explore" | Select-Object Message | Format-Custom
Ver logs sobre la aplicación de PowerShell
Get-WinEvent -LogName "Microsoft-Windows-PowerShell/Operational" -ErrorAction SilentlyContinue
Se entiende por reparar un sistema, corregir los problemas que tenga el sistema operativo. Los sistemas operativos disponen de herramientas que sirven para recuperar, reemplazar y corregir situaciones que impiden utilizarlo correctamente.
En cualquier sistema operativo hay que asegurarse de que no se van a perder datos, y que si se produce la pérdida, por lo menos se podrán restaurar los datos perdidos. La duda no es saber si un disco duro fallará o no, sino cuándo lo hará, y para esto tenemos que estar preparados.
Una copia de seguridad consiste simplemente en tener duplicados los archivos en algún dispositivo o medio de almacenamiento, los archivos pueden ser de los usuarios o propios del sistema operativo.
Tipos de copias se seguridad:
Simular mediante cadenas una copia de seguridad incremental
#Simular copia incremental
$valor1="hola"
$valor2="hola a"
$valor3="hola ad"
$valor4="hola adi"
$valor5="hola adio"
$valor6="hola adios"
$lunesc=$valor2.Replace($valor1,"");$lunesc
$martesi=$valor3.Replace($valor2,"");$martesi
$xi=$valor4.Replace($valor3,"");$xi
$ji=$valor5.Replace($valor4,"");$ji
$vi=$valor6.Replace($valor5,"");$vi
#Qué valores han cambiado
Compare-Object -ReferenceObject $valor2 -DifferenceObject $valor1 | where {$_.SideIndicator -eq "<=" -or $_.SideIndicator -eq "=>"}
Simular mediante cadenas una copia de seguridad diferencial
#Simular copia diferencial $valor1="hola" $valor2="hola a" $valor3="hola ad" $valor4="hola adi" $valor5="hola adio" $valor6="hola adios" $xi=$valor4.Replace($valor1,"");$xi $vi=$valor6.Replace($valor1,"");$vi
Consiste en restaurar archivos y la configuración del sistema, ayuda a corregir problemas. El restaurador utiliza puntos de restauración para hacer que los archivos del sistema y la configuración vuelvan al estado en que se encontraban en un momento anterior, sin que esto afecte a los archivos de los usuarios.
Los puntos de restauración se crean automáticamente todas las semanas (siempre y cuando no esté deshabilitado) y justo antes de los eventos de sistema importantes, como la instalación de un programa o controlador de dispositivo. También puede crear un punto de restauración manualmente.
Crear un punto y restaurar
Get-ComputerRestorePoint Restore-Computer -RestorePoint 255 Get-ComputerRestorePoint -LastStatus
The post 10. Gestión del rendimiento en PowerShell appeared first on Scripting and security.
Add-Type -AssemblyName System.Speech
$synthesizer = New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer
$synthesizer.SelectVoice("Microsoft Zira Desktop")
$synthesizer.Rate=0
$json=Invoke-WebRequest -Uri 'https://en.wikipedia.org/w/api.php?action=parse&format=json&prop=text&page=PowerShell' | ConvertFrom-JSON
$json.parse.text.'*' -replace "<.*?>" | %{
$synthesizer.Speak($_)
}
The post Leer artículos de la Wikipedia mediante la voz del Sistema Operativo con PowerShell appeared first on Scripting and security.
Start-Process ((((Invoke-WebRequest "https://www.alexa.com/siteinfo/jesusninoc.com").Images | ? { $_.outerHTML -match "traffic.alexa.com"})[0]).src).replace("&","&")The post How is this site ranked relative to other sites? appeared first on Scripting and security.
ls *.mp4 | %{
$_.FullName
#Descargar FFmpeg https://ffmpeg.org/download.html
E:\programas\ffmpeg\bin\ffmpeg.exe -i $_.FullName -acodec libmp3lame -ab 128k $_.FullName.replace(".mp4",".mp3")
}
The post Convertir una lista de ficheros MP4 a MP3 con FFmpeg appeared first on Scripting and security.
$urls='https://www.bing.com/search?q=powershell'
$result=Invoke-WebRequest $urls
$valor=($result.AllElements | ? {$_.class -eq “sb_count”}).innerText
$valor
$valor=$valor.replace(".","").replace("resultados","")
switch([Int]$valor)
{
{$_ -ge 0 -and $_ -le 1000}{"Poco importante"}
{$_ -ge 1001 -and $_ -le 10000}{"Algo importante"}
{$_ -ge 10000 -and $_ -le 100000000}{"Muy importante"}
}
The post Conocer la relevancia de una búsqueda en Bing 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 "https://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.
#Cifrar el contenido del fichero
$fichero="fichero.txt"
$cifrado=gc $fichero
$clavecifrado=1
$textocifrado=(0..($cifrado.Length-1) | % {[char]::ConvertFromUtf32([char]::ConvertToUtf32($cifrado[$_].ToString(),0)+$clavecifrado)}) -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.Replace(".","")
$ficherocifrado=(0..($ficherosin.Length-1) | % {[char]::ConvertFromUtf32([char]::ConvertToUtf32($ficherosin[$_].ToString(),0)+$clavecifrado)}) -join ""
$textocifrado | Out-File $ficherocifrado
#Subir un fichero por SSH a un servidor Linux desde PowerShell en Windows
Set-SCPFile -LocalFile $ficherocifrado -ComputerName 192.168.1.162 -RemotePath . -Credential (Get-Credential)
The post Cifrar con un algoritmo sencillo el nombre y el contenido de un fichero de texto y subirlo por SSH a un servidor Linux appeared first on Scripting and security.