::. Moleculax - Programming free online - Data Base NoSQL - OOP - Deep Web- Dark Web - BigData - PostgreSQL - MySQL - Programming - OOP freebitcoin.:: Moleculax - TECHNOLOGY AND KNOWLEDGE Information technology, Structured programming

Copiar una clave SSH a un host para que permita logins SSH sin password:
```
ssh-copy-id user@host
```
Con el comando ssh-keygen podemos generar las claves.
Iniciar un túnel SSH desde el puerto 80 de un host remoto al puerto 2001 de nuestra máquina local:
ssh –N –L2001:localhost:80 host_remoto

Ahora puedes acceder al sitio web remoto desde http://localhost:2001/
Enviar el sonido del micrófono local a los altavoces de un host remoto:
dd if=/dev/dsp | ssh –c arcfour –C user@host dd of=/dev/dsp

Esto enviará el sonido del puerto del micrófono como salida al puerto de los altavoces del equipo objetivo por SSH. La calidad del sonido es muy mala, por lo que se escuchará con mucho ruido de fondo.
Comparar un archivo remoto con uno local:
```
ssh user@host cat /ruta/del/archive_remoto | diff /ruta/del/archive_local
```
Útil para comprobar si un archivo local y otro remoto tienen diferencias.
Montar carpeta/sistema de ficheros por medio de SSH:
```
sshfs name@server:/ruta/de/carpeta /ruta/de/punto/de/montaje
```
Es necesario instalar SSHFS.

Con esto podremos montar una carpeta por red de forma segura
Conexión SSH por medio de “host in the middle”:
```
ssh –t host_alcanzable ssh host_inalcanzable
```
El host inalcanzable no está disponible desde la red local pero si es alcanzable desde la red del host alcanzable. Este comando crea una conexión al host inalcanzable por medio de una conexión oculta desde el host alcanzable.
Copiar desde host1 a host2 desde tu host:
ssh root@host1 “cd /directorio/a/copiar/ && tar –cf -.” | ssh root@host2 “cd /directorio/destino/de/copia/ && tar –xf –“
Útil si solo tú tienes acceso a host1 y host2 pero ellos no tienen acceso a tu host (por lo que ncat no funciona) y no tienen acceso entre ellos.
Correr cualquier aplicación GUI remotamente:
```
ssh –fX user@host [aplicación]
```
La configuración del server SSH requiere:

X11 Forwarding yes #por defecto en Debian

Compression delayed #configuración conveniente
Crear una conexión persistente a una máquina:
```
ssh -MNf user@host
```
Crear una conexión SSH persistente a un host en background. Combinar con tu configuración SSH en ~/.ssh/config:

Host host

ControlPath ~/.ssh/master-%r@%h:%p

ControlMaster no

Todas las conexiones SSH a la máquina irán por el socket SSH persistente. Esto es muy útil si usas SSH para sincronizar archivos (con rsync, sftp, cvs, svn…) de forma regular ya que no se crearán nuevos sockets cada vez que se abra una conexión SSH.
Adjuntar la pantalla por SSH:
```
ssh –t remote_host screen –r
```
Directamente adjunta la pantalla de una sesión remota (guarda un proceso bash padre inútil).
Llamar a puertos (port knocking):
```
knock [host] 3000 4000 5000 && ssh –p [port] user@host && knock [host] 5000 4000 3000
```
Llama a los puertos 3000 4000 5000 para abrir el puerto de un servicio (ssh por ejemplo) y vuelve a llamar a los puertos 5000 4000 3000 para cerrar el acceso al dicho servicio. Para esto es necesario tener instalado knockd.

Un ejemplo de configuración del servicio knockd mediante el archivo knockd.conf para que interpretase las llamadas anteriores sería:

[options]

Logfile = /var/log/knockd.log

[openSSH]

sequence = 3000,4000,5000

command = /sbin/iptables –A input –i eth0 –s %IP% -p tcp –dport 22 –j accept

tcpflags = syn

[closeSSH]

sequence = 5000,4000,3000

seq_timeout = 5

command = /sbin/iptables –D input –i eth0 –s %IP% -p tcp –dport 22 –j accept

tcpflags = syn
Eliminar una línea de un fichero de texto. Muy útil para solucionar ssh host key warnings (ver alternativas):
```
ssh-keygen -R [host_objetivo]
```
En este caso es mejor usar una herramienta dedicada.
Ejecutar comandos de consola remotos por SSH sin comillas de escape:
```
ssh host -l user $(
```
```
 
```
Método mas simple y mas portable:
```
ssh host -l user “`cat cmd.txt`”
```
Copiar una base de datos MySQL a un nuevo servidor vía SSH con un comando:
mysqldump –add-drop-table –extended-insert –force –log-error=error.log -uUSER -pPASS OLD_DB_NAME | ssh -C user@newhost “mysql -uUSER -pPASS NEW_DB_NAME”
Volcar una base de datos MySQL por un túnel SSH comprimido y usarlo como entrada a MySQL. Parece ser la forma más rápida de migrar una base de datos a un nuevo server.
Eliminar una línea de un fichero de texto. Útil para corregir warnings tipo “ssh host key change“:
```
sed -i 8d ~/.ssh/known_hosts
```
Copiar nuestra clave pública SSH a un servidor desde una máquina que no tenga ssh-copy-id:
```
cat ~/.ssh/id_rsa.pub | ssh user@machine “mkdir ~/.ssh; cat >> ~/.ssh/authorized_keys”
```
Si usas Mac OS X o cualquier otra variante *nix que no venga con ssh-copy-id esta línea te será útil para añadir tu clave pública a una maquina remota para poder así acceder a ella por SSH sin usar password.
Nota: En el grupo “Debian Administrator” de Linkedin hay un debate muy interesante acerca de este comando.
Test de rendimiento del canal SSH en tiempo real:
```
yes | pv | ssh $host "cat > /dev/null"
```
Conecta a un host vía SSH y muestra la velocidad de transferencia en tiempo real enviando todos los datos transferidos a /dev/null
Necesita tener pv (pipe viewer) instalado.
Debian:
```
apt-get install pv
```
```
 
```
Fedora:
```
yum install pv
```
```
 
```
(necesita tener habilitados los repositorios ‘extras’)
Como establecer una sesión remota con GNU screen a la que puedas reconectar:
```
ssh -t user@some.domain.com /usr/bin/screen -xRR
```
Mucho antes de que existieran las terminales etiquetadas la gente solía usar GNU screen para abrir varias consolas en una única terminal de texto. Esto combinado con SSH nos da la posibilidad de tener abiertas varias consolas usando una única conexión remota con las opciones de arriba. Si se separa con “Ctrl-a d” o si la sesión SSH se termina de forma accidental, todos los procesos que corren en las consolas remotas permanecen ininterrumpidos y preparados para poder reconectar. Otro comando de screen útil son “Ctrl-a d” (abrir nueva consola) y “Ctrl-a a” (alternar entre consolas). Se recomienda la lectura de esta guía rápida para más comandos screen.
Reanudar SCP (secure copy) de un fichero grande:
```
rsync –partial –progress –rsh=ssh $file_source $user@$host:$destination_file
```
```
 
```
Puede reanudar una copia segura hecha con SCP que haya fallado usando rsync, muy útil cuando se transfieren grandes archivos como volcados de bases de datos por VPN
Requiere tener instalado rsync en ambos hosts.

rsync –partial –progress –rsh=ssh $file_source $user@$host:$destination_file local -> remote
o
rsync –partial –progress –rsh=ssh $user@$host:$remote_file $destination_file remote -> local
Analizar tráfico de forma remota por SSH con Wireshark:
```
ssh root@server.com ‘tshark -f “port !22″ -w -’ | wireshark -k -i -
```
Este comando captura el tráfico en una máquina remota con tshark, envía los datos pcap raw caturados por el canal SSH y los muestra en Wireshark. Pulsando Ctrl-c se para la captura y desafortunadamente se cierra la ventana de Wireshark. Esta conducta se puede arreglar pasándole -c # a tshark para que solo capture un # número de paquetes o también redireccionando los datos por un canal determinado distinto al SSH en vez de devolverlos a Wireshark por el mismo canal SSH. Se recomienda filtrar todo lo posible en el comando tshark para conservar el ancho de banda. También se puede reemplazar tshark por tcpdump asi:
```
ssh root@example.com tcpdump -w – ‘port !22′ | wireshark -k -i -
```
Mantener abierta una sesión SSH para siempre:
```
autossh -M50000 -t server.example.com ‘screen -raAd mysession’
```
Se abre una sesión SSH que permanece abierta indefinidamente. Muy útil para dispositivos portátiles que usen conexión WIFI en los que se pueden producir cortes de conectividad o cambios de spot WIFI.
Clientes SSH más rápidos, más duros y más fuertes:
```
ssh -4 -C -c blowfish-cbc
```
Forzamos IPv4, compresión del flujo y especificamos que Blowfish sea el algoritmo de cifrado del flujo de datos. Se supone que también se puede usar aes256-ctr como especificación de cifrado. También se omiten temas como control de sesiones master y otros temas que no estarán disponibles en la consola aunque esto hará que la velocidad del canal también mejore.
Acelerador de ancho de banda con cstream:
```
tar -cj /backup | cstream -t 777k | ssh host ‘tar -xj -C /backup’
```
```
 
```
El comando comprime en bzip una carpeta y la transmite al host por la red a 777Kbit/s. cstream puede hacer mucho más, ver http://www.cons.org/cracauer/cstream.html#usage
Por ejemplo:
```
echo w00t, i’m 733+ | cstream -b1 -t2
```
Transferir la clave pública SSH a otra máquina en un solo paso:
```
ssh-keygen; ssh-copy-id user@host; ssh user@host
```
Esta secuencia permite la configuración simple de logins SSH sin contraseña. Cuidado ya que si ya se tiene un par de claves SSH en el directorio ~/.ssh de la maquina local es posible que ssh-keygen la sobrescriba. ssh-copy-id copia la clave pública a la máquina remota y la añade como clave autorizada en el archivo remoto ~/.ssh/authorized_keys. Cuando se prueba la conexión SSH, si no se ha usado contraseña en la generación de la clave, la consola remota aparece en cuanto se invoca con SSH user@host.
Copiar la entrada estándar stdin al buffer X11:
```
ssh user@host cat /path/to/some/file | xclip
```

Buscar en moleculax

Comandos/trucos SSH

Sabiduria Justicia Templanza Coraje.

Hay que contemplar las potenciales consecuencias de nuestros planes, para impedir que nos sorprendan. De esta manera, tendremos más control sobre las situaciones difíciles.