Instalar PowerShell en Linux

Vamos a instalar PowerShell Core en Linux, esto fué probado en un Debian 9

Primero descargamos el tar.gz:

root@debian:~# curl -L -o /tmp/powershell.tar.gz https://github.com/PowerShell/PowerShell/releases/download/v6.1.0/powershell-6.1.0-linux-x64.tar.gz

Creamos la carpeta donde lo almacenaremos:

root@debian:~# mkdir -p /opt/microsoft/powershell/6.1.0

Descomprimimos:

root@debian:~# tar zxf /tmp/powershell.tar.gz -C /opt/microsoft/powershell/6.1.0

Damos permisos de ejecución:

root@debian:~# chmod +x /opt/microsoft/powershell/6.1.0/pwsh

Creamos en enlace simbólico:

root@debian:~# ln -s /opt/microsoft/powershell/6.1.0/pwsh /usr/bin/pwsh

FUENTE: https://docs.microsoft.com/en-us/powershell/scripting/install/installing-powershell-core-on-linux?view=powershell-6

Conectar con SSH sin clave pública/privada - SSHpass

Qué es SSHpass:

     Cuando utilizamos SSH para conectarnos de un servidor a otro utilizamos un usuario y una contraseña.
   
     Usualmente podemos generar un par de claves pública y privada para que no nos solicite la contraseña. En el caso que no deseemos utilizar estas claves podremos utilizar el SSHPASS que nos servirá para pasar la contraseña por parámetro.

     Esta herramienta podemos utilizarla por ejemplo para poner dentro de scripts sin que tener que configurar las keys SSH.

     También explicaré como utilizar GPG para encriptar la clave y que no quede en texto plano en un archivo.

Instalar el sshpass:

root@debian:~# apt-get install sshpass

Ingresar pasando el password sin tener keys ssh:

root@debian:~# sshpass -p 'Mi_password' ssh 192.168.0.200

Poner la clave dentro de un archivo:

root@debian:~# echo 'Mi_password' > pass.txt
root@debian:~# sshpass -f pass.txt ssh 192.168.0.200

Tener en cuenta para darle permisos de lectura solo al owner, para que nadie más pueda leer la clave.

root@debian:~# chmod 0400 pass.txt

Encriptar el archivo de contraseña con gpg:

root@debian:~# gpg -c pass.txt

Ingresamos una passphrase que nos solicita y la confirmamos. Esto nos genera un archivo .gpg

root@debian:~# ls -lat pass.txt.gpg
-rw-r--r-- 1 root root 94 ene  2 11:15 pass.txt.gpg

Eliminamos el que no está encriptado:

root@debian:~# rm -rf pass.txt

Usamos el sshpass con la clave encriptada:

root@debian:~# gpg -d -q pass.txt.gpg > pass.txt; sshpass -f pass.txt ssh 192.168.0.200; rm pass.txt

Parallel SSH - Ejecutar comandos remotos en multiples servidores

Todos sabemos que es SSH y que podemos hacer con él, pero hoy vamos a ver Parallel SSH.

Que es Parallel SSH:

Es un comando ó herramienta que nos permite conectarnos a varios servidores simultáneamente mediante SSH y poder ejecutar comandos sin ingresar uno por uno para ejecutarlos.

Instalamos el parallel-ssh:

root@debian:~# apt-get install pssh

Vemos como usarlo: 

root@debian:~# parallel-ssh --help
Usage: parallel-ssh [OPTIONS] command [...]
Options:
  --version             show program's version number and exit
  --help                show this help message and exit
  -h HOST_FILE, --hosts=HOST_FILE
                        hosts file (each line "[user@]host[:port]")
  -H HOST_STRING, --host=HOST_STRING
                        additional host entries ("[user@]host[:port]")
  -l USER, --user=USER  username (OPTIONAL)
  -p PAR, --par=PAR     max number of parallel threads (OPTIONAL)
  -o OUTDIR, --outdir=OUTDIR
                        output directory for stdout files (OPTIONAL)
  -e ERRDIR, --errdir=ERRDIR
                        output directory for stderr files (OPTIONAL)
  -t TIMEOUT, --timeout=TIMEOUT
                        timeout (secs) (0 = no timeout) per host (OPTIONAL)
  -O OPTION, --option=OPTION
                        SSH option (OPTIONAL)
  -v, --verbose         turn on warning and diagnostic messages (OPTIONAL)
  -A, --askpass         Ask for a password (OPTIONAL)
  -x ARGS, --extra-args=ARGS
                        Extra command-line arguments, with processing for
                        spaces, quotes, and backslashes
  -X ARG, --extra-arg=ARG
                        Extra command-line argument
  -i, --inline          inline aggregated output and error for each server
  --inline-stdout       inline standard output for each server
  -I, --send-input      read from standard input and send as input to ssh
  -P, --print           print output as we get it
Example: pssh -h hosts.txt -l irb2 -o /tmp/foo uptime

Editamos el archivo donde pondremos ip's de los servidores donde ejecutaremos los comandos:

root@debian:~# vi hosts.txt
192.168.0.100
192.168.0.200

Ejecutamos el comando en ambos servidores:

root@debian:~# parallel-ssh -h hosts.txt -l root -o /tmp/salida uptime
[1] 09:52:12 [SUCCESS] 192.168.0.100
[2] 09:52:12 [SUCCESS] 192.168.0.200 

-h listado de servidores donde ejecutaremos los comandos
-l usuario con el que se conectará por ssh. Tener en cuenta que debe tener configuradas las keys ssh para que no pida password.
-o directorio de salida donde mostrará la salida de cada comando
uptime el comando que ejecutará en cada servidor remoto

Vemos la salida de cada ip en la ruta que le pasamos con el -o: 

root@debian:~# ls -lat /tmp/salida.txt/
total 1930
drwxrwxrwt 7 root root 1971200 Dec 28 09:55 ..
-rw-r--r-- 1 root root      74 Dec 28 09:52 192.168.0.100
-rw-r--r-- 1 root root      73 Dec 28 09:52 192.168.0.200
drwxr-xr-x 2 root root    1024 Dec 28 09:51 .

Vemos el resultado de cada server:

root@debian:~# cat /tmp/salida.txt/192.168.0.100
  9:52am  up 100 day(s), 16:24,  9 users,  load average: 0.06, 0.07, 0.06 

root@debian:~# cat /tmp/salida.txt/192.168.0.200
  9:52am  up 85 day(s), 17:12,  0 users,  load average: 0.11, 0.18, 0.19

En caso que no tengamos las keys ssh podremos ingresar el password:

root@debian:~# parallel-ssh -h hosts.txt -A -O PreferredAuthentications=password uptime
Warning: do not enter your password if anyone else has superuser
privileges or access to your account.
Password: acáVaLaClaveDeRoot
[1] 12:08:27 [SUCCESS] 192.168.0.100
[2] 12:08:27 [SUCCESS] 192.168.0.200

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

Controlando un LED con Raspberry Pi en Python con GPIO

La Raspberry Pi que voy a utilizar es el Modelo B:

Led 5 volt, resistencia para ese led y un protoboard, solderless ò breadboard MB-102, una tarjeta SD un cable de red para conectar al modem/router y un cargador de celular USB.

El sistema operativo que tengo instalado es Kali Linux, pero puede hacerce con cualquier otro, si quieren istalarle este, les dejo acá el link: https://redes-seguridad.blogspot.com.ar/2017/03/instalando-kali-linux-en-raspberry-pi.html

La conexión que hacemos será lo siguiente:

Para que se entienda mejor les hice el planito en paint:

Ahora explico la conexión:

1) El pin identificado con la letra A del GPIO del raspberry pi (contamos 6 pines de derecha a izquierda de la fila de arriba) y lo conectamos a la letra B en naranja (en el protoboard tipo batalla naval sería la fila B y la columna 20),

2) El pin identificado con la letra C del GPIO del raspberry pi (contamos 3 pines de derecha a izquierda de la fila de abajo) y lo conectamos en la letra D (en el protoboard tipo batalla naval sería fila A y columna 31).

3) Para conectar el LED tenemos que tener en cuenta que tiene un conector más largo que el otro. El lado más corto lo conectamos a la derecha E (en el protoboard tipo batalla naval sería fila C y columna 31) y el lado más largo del LED a la izquierda conectado al F (en el protoboard tipo batalla naval sería fila C y columna 29)

4) Para conectar la resistencia la conectamos en el G (en el protoboard tipo batalla naval sería fila D y columna 20) y en el H (en el protoboard tipo batalla naval sería fila D y columna 29).


Instalación de Python y GPIO en Kali Linux:

root@kali:~# apt-get install python-dev python3-dev gcc

root@kali:/home# wget https://pypi.python.org/packages/e2/58/6e1b775606da6439fa3fd1550e7f714ac62aa75e162eed29dbec684ecb3e/RPi.GPIO-0.6.3.tar.gz 

root@kali:/home# tar xzvf RPi.GPIO-0.6.3.tar.gz 

root@kali:/home# cd RPi.GPIO-0.6.3 

root@kali:/home/RPi.GPIO-0.6.3# python setup.py install 

root@kali:~# python
Python 2.7.13 (default, Jan 19 2017, 14:48:08)
[GCC 6.3.0 20170118] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import RPi.GPIO

Armamos un python para encender y otro para apagar el LED:

root@kali:/home# vi prender_led.py
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(17, GPIO.OUT)
GPIO.output(17,1)

En la ultima linea le indicamos con el 1 que lo enciende, si lo cambiamos por cero lo apaga:

root@kali:/home# vi apagar_led.py
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(17, GPIO.OUT)
GPIO.output(17,0)

Prendemos el led ejecutando el python:

root@kali:/home# python prender_led.py

Apagamos el led ejecutando el otro python:

root@kali:/home# python apagar_led.py

Armamos otro script que recibe un parametro, si es 1 prende y si es 0 apaga:

root@kali:/home# vi prende_Con_1_Apaga_con_0.py
import RPi.GPIO as GPIO
import sys
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
LED=17
print sys.argv[1]
ESTADO=int(sys.argv[1])
GPIO.setup(LED, GPIO.OUT)
GPIO.setwarnings(False)
if ESTADO == 0:
        print('Apagando el LED')
        GPIO.output(LED,ESTADO)
else:
        print('Prendiendo el LED')
        ESTADO = 1;
        GPIO.output(LED,ESTADO)

Prendemos:

root@kali:/home# python prende_Con_1_Apaga_con_0.py 1

Apagamos:

root@kali:/home# python prende_Con_1_Apaga_con_0.py 1

Hacerlo titilar dentro de un while infinito:

root@kali:/home# vi titila.py

import RPi.GPIO as GPIO

import time

GPIO.setmode(GPIO.BCM)

GPIO.setwarnings(False)

while 1:

        GPIO.setup(17,GPIO.OUT)

        GPIO.output(17,1)

        time.sleep(0.5)

        GPIO.setup(17,GPIO.OUT)

        GPIO.output(17,0)

        time.sleep(0.5)

SOS con codigo Morse:

root@kali:/home# vi SOS.py
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
while 1:
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,1)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,0)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,1)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,0)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,1)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,0)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,1)
        time.sleep(2)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,0)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,1)
        time.sleep(2)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,0)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,1)
        time.sleep(2)

Video prediendo y apagando los LEDs:

Y el Santulon jugando con el nuevo chiche:

FUENTES:

https://www.raspberrypi.org
https://geekytheory.com
http://rsppi.blogspot.com.ar/
http://robologs.net/
http://www.aprendeprogramacion.net/

Configurando WiFi en Raspberri Pi con Adaptador USB Philips

1) Prendemos la raspberry pi con el cable de red conectado.

2) Una vez que booteó nos conectamos por ssh por la ip que nos dió.

3) Insertamos el adaptador wifi philips y vemos si lo detecta el S.O.

root@kali:~# lsusb

4) Editamos el archivo de configuración

root@kali:~# vi /etc/network/interfaces

Y ponemos lo siguiente para configurarla, reemplazando Mi_Nombre_de_la_Red por el SSID (nombre de la wifi a conectar)
Y cambiar Mi_Nombre_de_la_Red por la clave con la cual nos conectamos a la wifi. Dejar las comillas:

auto wlan0
allow-hotplug wlan0
iface wlan0 inet dhcp
wpa-ssid "Mi_Nombre_de_la_Red"
wpa-psk "La_clave_para_Conectar"

5) Reiniciamos el demonio de red:

root@kali:~# /etc/init.d/networking restart

6) Una vez que reinició, desconectamos el cable de red (no lo volvemos a enchufar).

7) Desconectamos el cable de alimentación y volvemos a conectarlo.

8) Cuando finalizó el booteo vemos que ya linkea la luz del adaptador wifi.

9) Nos conectamos por ssh por la ip que nos dió fijandonos en el modem/router ó vamos pingueando hasta que alguna ip nos responda ó lo escaneamos con nmap.

10) Si queremos ponerle ip fija:

root@kali:~# vi /etc/network/interfaces

auto wlan0
#allow-hotplug wlan0
#iface wlan0 inet dhcp
iface wlan0 inet static
address 192.168.1.43
netmask 255.255.255.0
network 192.168.1.0
broadcast 192.168.1.255
gateway 192.168.1.1
wpa-ssid "Nombre_Wifi"
wpa-psk "Contraseña"

root@kali:~# /etc/init.d/networking restart

Instalando Kali Linux en Raspberry Pi

Antes que nada prepararé la imagen booteable en una SD de 16Gb desde Windows 7:


1) Conectamos la tarjeta de memoria SD en una pc con windows 7, no es necesario formatearla.


2) Descargamos el Win32diskimagen y lo instalamos en windows, la instalación es tan compleja, como dar siguiente, siguiente, siguiente. Lo descargamos del siguiente enlace:  https://sourceforge.net/projects/win32diskimager/files/latest/download


3) Descargamos la imagen de kali para raspberry pi de: https://www.offensive-security.com/kali-linux-arm-images/ Yo me descargué esta:

kali-2.1.2-rpi.img.xz  => https://images.offensive-security.com/arm-images/kali-2.1.2-rpi.img.xz

        Ya que tengo este modelo para probar:

4) La descomprimi con el winrar y queda el file: kali-2.1.2-rpi.img

5)  Abrimos el Win32DiskImager y seleccionamos la imagen que descomprimimos en el punto anterior y seleccionamos la unidad que tomó la tarjeta SD, en mi caso el H:\, clickeamos en write:

Verificamos que realmente la ruta donde queremos escribir y click en yes:

Luego ok y exit. Ya tenemos la memoria con el booteable de kali:

6) Ponemos la memoria SD en el raspberry, le conectamos un cable de red. Para darle energía conectamos una punta del cable usb de un cargador de celular al 5v/1ADDC y la otra punta al USB de la compu.

     Si vemos que prenden las luces roja y verde es que está booteando correctamente.

     Cuando terminó de bootear vemos que quedan las 4 luces prendidas, naranja, verde, verde y roja.

7) Como se que ip tomó? 

     Desde otro linux que tengo corriendo en un virtualbox ejecutamos un barrido con nmap:

root@linuxillo:~# nmap -sP 192.168.1.0-255 | grep -2 Raspberry | head -1

     Obtendremos la dirección ip del dispositivo, al cual nos conectaremos por ssh por putty con:

usuario:     root

password:  toor

     También podríamos conectarnos al modem y ver que ip asignó el DHCP por su mac.

8) Como me conecto si no tengo monitor para conectarle?

Instalamos VNC server:

root@kali:~# apt-get update

root@kali:~# apt-get install x11vnc
Do you want to continue? [Y/n] Y

root@kali:~# x11vnc -storepasswd
Enter VNC password:
Verify password:
Write password to /root/.vnc/passwd?  [y]/n y
Password written to: /root/.vnc/passwd
root@kali:~#

root@kali:~# x11vnc -ncache q0 -auth guess -nap -forever -loop -repeat -rfbauth /root/.vnc/passwd -rfbport 5900

 Nos logueamos con el vncviewer desde el windows ó desde el plugin del chrome:

Ingresamos la ip del kali y la sesión que nos mostró por pantalla al iniciar el x11vnc:

Tildamos la opción y le damos connect:

Ingresamos el password que seteamos para el vnc cuando ejecutamos el -storepasswd y damos ok:

Nos logueamos con la mismos datos que ingresamos por ssh: root y toor:

Y taraaaaaaaaan, tenemos el Kali corriendo en el Raspberry pi sin monitor: