Páginas

Mostrando entradas con la etiqueta Openssh. Mostrar todas las entradas
Mostrando entradas con la etiqueta Openssh. Mostrar todas las entradas

martes, 17 de enero de 2023

Montar Directorios Usando SSHFS en FreeBSD 13.1

NFS Sistema de Archivos en Red FreeBSD
Montaje de Sistema de Archivos NFS Usando Autofs
Replicar, Recuperar Pool Root ZFS FreeBSD

Envío y recepción de datos ZFS

El comando zfs send crea una representación de flujo de datos de una instantánea que se graba en una salida estándar. De forma predeterminada, se crea un flujo de datos completo. Puede redirigir la salida a un archivo u otro sistema.

El comando zfs receive crea una instantánea cuyo contenido se especifica en el flujo de datos que figura en la entrada estándar. Si se recibe un flujo de datos completo, también se crea un sistema de archivos. Con estos comandos puede enviar y recibir datos de instantáneas ZFS y sistemas de archivos.

El hostname solaris será el cliente y tormenta el servidor. Ambos corren FreeBSD 13.1.

solaris:~/bsdfetch-main % ./bsdfetch


OS: FreeBSD
Release: 13.1-RELEASE-p3
Version: FreeBSD 13.1-RELEASE-p3 GENERIC
Host: solaris
Arch: amd64
Shell: csh
User: carlos
Packages: 1245
Uptime: 0d 0h 47m
RAM: 16221 MB
Loadavg: 0.17 0.17 0.20
CPU: Intel(R) Core(TM) i5-8350U CPU @ 1.70GHz
Cores: 8 of 8 processors online
 -> Core [1]: 39.0 °C
 -> Core [2]: 39.0 °C
 -> Core [3]: 39.0 °C
 -> Core [4]: 39.0 °C
 -> Core [5]: 40.0 °C
 -> Core [6]: 40.0 °C
 -> Core [7]: 41.0 °C
 -> Core [8]: 41.0 °C

Archivo config ssh (cliente)



 cat .ssh/config
Host tormenta
        HostName 192.168.88.160
        User carlos
        IdentityFile ~/.ssh/id_rsa
        Port 22422
        AddressFamily inet
        BindInterface em0

        CASignatureAlgorithms ssh-ed25519,ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,sk-ssh-ed25519@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,rsa-sha2-512,rsa-sha2-256

        Ciphers  chacha20-poly1305@openssh.com,aes128-ctr,aes192-ctr,aes256-ctr,aes128-gcm@openssh.com,aes256-gcm@openssh.com

        CheckHostIP yes

Entrar vía ssh al servidor.



tormenta % ./bsdfetch


OS: FreeBSD
Release: 13.1-RELEASE-p3
Version: FreeBSD 13.1-RELEASE-p3 GENERIC
Host: tormenta
Arch: amd64
Shell: csh
User: carlos
Packages: 472
Uptime: 25d 23h 3m
RAM: 32084 MB
Loadavg: 0.40 0.28 0.20
CPU: Intel(R) Celeron(R) N5105 @ 2.00GHz
Cores: 4 of 4 processors online

tormenta:~ % uname -a


FreeBSD tormenta 13.1-RELEASE-p3 FreeBSD 13.1-RELEASE-p3 GENERIC amd64

solaris:~ % uname -a


FreeBSD solaris 13.1-RELEASE-p3 FreeBSD 13.1-RELEASE-p3 GENERIC amd64

Red cableada


#
::1                 localhost localhost.my.domain
127.0.0.1           localhost localhost.my.domain
192.168.88.247      synology  # nas synology
192.168.88.160      tormenta  # servidor freebsd
192.168.88.51       solaris   # cliente freebsd
192.168.88.200		raspberry # servidor dns
192.168.88.205		switch    # switch gestionado
192.168.88.43       macbook	  # cliente 
192.168.88.1		mikrotik  # router firewall
192.168.1.1			router2   # red 2 
...

Crear un conjunto de datos en solaris (cliente)


 zfs create -o mountpoint=/usr/tormentabck zroot/usr/tormentabck

Instalar sshfs (servidor)


 pkg search sshfs
fusefs-sshfs-3.7.3_1           Mount remote directories over ssh

 pkg install fusefs-sshfs

Permitir acceso a través de ssh. Habilitar ssh en solaris (cliente)


 sysrc ssh_enable=YES

Tener el mismo usuario en ambos sistemas

Crear conjunto de datos en el cliente


 solaris: # zfs create zroot/usr/tormentabck

Montar directorio en el servidor


[tormenta:~] carlos@pts/0 % sudo sshfs -o allow_other \
carlos@192.168.88.51:/usr/tormentabck /mnt/solaris

Realizar comprobación


[tormenta:~] carlos@pts/0 % mount
 --> /dev/fuse on /mnt/solaris (fusefs.sshfs)
 ...

Crear una instantánea recursiva en el servidor


 [tormenta:~] zfs snapshot -r zroot@tormenta_120123

Enviar el conjunto de datos al cliente (solaris)


 [tormenta:~] zfs send -Rv zroot@tormenta_120123 | gzip > \
 /mnt/solaris/zroot.tormenta.snap1.gz

Llegados a este punto tenemos una copia del sistema completo del servidor en el cliente.


 [tormenta:~] % ls -l /mnt/solaris
 total 64934092
 -rw-r--r--  1 carlos  carlos  66492508708 Jan 12 21:51 zroot.tormenta.snap1.gz

Desmontar el directorio


sudo umount /mnt/solaris/

En la maquina cliente (donde físicamente está el fichero)


ls -l /usr/tormentabck/
total 64954481
-rw-r--r--  1 carlos  carlos  66492508708 Jan 12 21:51 zroot.tormenta.snap1.gz

FreeBSD es genial!.

martes, 14 de septiembre de 2021

Firewall IPFW Freebsd

 https://docs.freebsd.org/en/books/handbook/firewalls/#firewalls-ipfw

Nota: Extensiones imprescindibles Firefox 78.14.0 esr (64-bit)

IPFW - proteger una estación de trabajo freeBSD y permitir acceso remoto vía SSH.

IPFW es un cortafuegos stateful escrito para FreeBSD que soporta tanto IPv4 como IPv6. Está formado por varios componentes: el procesador de reglas de filtrado del kernel y su función integrada de contabilidad de paquetes, la función de registro, NAT, el conformador de tráfico dummynet(4), una función de reenvío, una función de puente y una función ipstealth.

# sysrc firewall_enable="YES"
# sysrc firewall_script="/etc/ipfw.rules"
# sysrc firewall_logging="YES"
# echo "net.inet.ip.fw.verbose_limit=5" >> /etc/sysctl.conf
# sysrc firewall_logif="YES"
# service ipfw start
# sysctl net.inet.ip.fw.verbose_limit=5
% cat /etc/ipfw.rules
###################################
#!/bin/sh
ipfw -q -f flush

LAN="192.168.88.0/24"
cmd="/sbin/ipfw -q add"
pif="re0"

$cmd 00100 allow ip from any to any via lo0
$cmd 00200 deny ip from any to 127.0.0.0/8
$cmd 00300 deny ip from 127.0.0.0/8 to any
$cmd 00400 deny ip from any to ::1
$cmd 00500 deny ip from ::1 to any
$cmd 00600 allow ipv6-icmp from :: to ff02::/16
$cmd 00700 allow ipv6-icmp from fe80::/10 to fe80::/10
$cmd 00800 allow ipv6-icmp from fe80::/10 to ff02::/16
$cmd 00900 allow ipv6-icmp from any to any icmp6types 1
$cmd 01000 allow ipv6-icmp from any to any icmp6types 2,135,136
$cmd 01100 check-state :default
$cmd 01200 allow tcp from me to any established
$cmd 01300 allow tcp from me to any setup keep-state :default
$cmd 01400 allow udp from me to any keep-state :default
$cmd 01500 allow icmp from me to any keep-state :default
$cmd 01600 allow ipv6-icmp from me to any keep-state :default
$cmd 01700 allow udp from 0.0.0.0 68 to 255.255.255.255 67 out
$cmd 01800 allow udp from any 67 to me 68 in
$cmd 01900 allow udp from any 67 to 255.255.255.255 68 in
$cmd 02000 allow udp from fe80::/10 to me 546 in
$cmd 02100 allow icmp from any to any icmptypes 8
$cmd 02200 allow ipv6-icmp from any to any icmp6types 128,129
$cmd 02300 allow icmp from any to any icmptypes 3,4,11
$cmd 02400 allow ipv6-icmp from any to any icmp6types 3
$cmd 02500 allow tcp from $LAN to me 22 in via $pif setup limit src-addr 2
$cmd 65000 count ip from any to any
$cmd 65100 deny { tcp or udp } from any to any 135-139,445 in
$cmd 65200 deny { tcp or udp } from any to any 1026,1027 in
$cmd 65300 deny { tcp or udp } from any to any 1433,1434 in
$cmd 65400 deny ip from any to 255.255.255.255
$cmd 65500 deny ip from any to 224.0.0.0/24 in
$cmd 65500 deny udp from any to any 520 in
$cmd 65500 deny tcp from any 80,443 to any 1024-65535 in
$cmd 65500 deny ip from any to any
$cmd 65535 deny ip from any to any
###################################




FreeBSD es genial!.

sábado, 10 de marzo de 2018

Instalación y configuración de vsftpd

vsftpd servidor en Centos 6.9

FTP

FTP (File Transfer Protocol) o Protocolo de Transferencia de Archivos (o archivos informáticos) es uno de los protocolos estándar más utilizados en Internet siendo el más idóneo para la transferencia de grandes bloques de datos a través de redes que soporten TCP/IP. El servicio utiliza los puertos 20 y 21, exclusivamente sobre TCP. El puerto 20 es utilizado para el flujo de datos entre cliente y servidor. El puerto 21 es utilizando para el envío de órdenes del cliente hacia el servidor. Prácticamente todos los sistemas operativos y plataformas incluyen soporte para FTP, lo que permite que cualquier computadora conectada a una red basada sobre TCP/IP pueda hacer uso de este servicio a través de un cliente FTP.

Modo activo

En modo Activo, el servidor siempre crea el canal de datos en su puerto 20, mientras que en el lado del cliente el canal de datos se asocia a un puerto aleatorio mayor que el 1024. Para ello, el cliente manda un comando PORT al servidor por el canal de control indicándole ese número de puerto, de manera que el servidor pueda abrirle una conexión de datos por donde se transferirán los archivos y los listados, en el puerto especificado.

Lo anterior tiene un grave problema de seguridad, y es que la máquina cliente debe estar dispuesta a aceptar cualquier conexión de entrada en un puerto superior al 1024, con los problemas que ello implica si tenemos el equipo conectado a una red insegura como Internet. De hecho, los cortafuegos que se instalen en el equipo para evitar ataques seguramente rechazarán esas conexiones aleatorias. Para solucionar esto se desarrolló el modo pasivo.

Modo pasivo

Fue creado como una alternativa al problema que representa el modo activo. A diferencia de éste último, el modo pasivo envía un mandato PASV en lugar del mandato PORT
a través del puerto de control del servidor. Éste devuelve como respuesta el número de puerto a través del cual debe conectarse el cliente para hacer la
transferencia de datos. El servidor puede elegir al azar cualquier puerto entre 1024 y 65535 o bien el rango de puertos determinado por el administrador del sistema. En el caso de Vsftpd, se puede definir un rango arbitrario de puertos para conexiones pasivas utilizando las opciones pasv_min_port y pasv_max_port. Éste es el método recomendado para servidores de acceso público.

Protocolo FTPS (FTP/SSL)

FTPS es la forma de designar diferentes maneras a través de las que se pueden realizar transferencias seguras de archivos mediante FTP utilizando SSL o TLS.

Aunque existen dos métodos para realizar una conexión SSL/TLS a través de FTP el utilizado por vsftpd es FTPS Explícito (FTPES), donde el cliente realiza la conexión normal por medio del puerto 21 y permitiendo negociar, de manera opciona, una conexión TLS.

RSA

RSA, acrónimo de los apellidos de sus autores, creado por Ron Rivest, Adi Shamir y Len Adleman, es un algoritmo para cifrar claves públicas Publicado por el MIT en 1977 y utilizado en todo el mundo para los protocolos destinados al comercio electrónico.

OpenSSL

Es una implementación libre de los protocoles SSL, (Secure Sockets Layer) y TLS (Transport Layer Security), continuación del proyecto SSLeay, iniciado por Eric Young y Tim Hudson.

Acerca de X.509

X.509 es un estándar ITU-T para infraestructura de claves públicas (PKI). Entre otras, establece los estándares para certificados de claves públicas y un algoritmo para validación de ruta de certificación.

vsftpd

vsftpd (Very Secure FTP Daemon) es utlizado para implementar servidores de archivos a través del protocolo FTP. Es sencillo y seguro.

Instalación de vsftpd

# yum -y install vsftpd

Configuración

/etc/vsftpd/chroot_list es el archivo que define la lista de usuarios a enajaular o no, (depende de la configuración).

Crear el archivo

# touch /etc/vsftpd/chroot_list


Iniciar el servicio

# service vsftpd start

Activar el servicio al arranque del sistema

# chkconfig vsftpd on


Abrir los puerto 20 y 21 (TCP). El primero FTP-DATA y el segundo FTP y el rango de puertos para conexiones pasivas que se defina.

Agregar las reglas de iptables

# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 20 -j ACCEPT
# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 21 -j ACCEPT
# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 30300:30309 -j ACCEPT

# servicce iptables save

O agregue al archivo /etc/sysconfig/iptables lo siguiente

-A INPUT -m state --state NEW -m tcp -p tcp --dport 20 -j ACCEPT
-A INPUT -m state --state NEW -m tcp -p tcp --dport 21 -j ACCEPT
-A INPUT -m state --state NEW -m tcp -p tcp --dport 30300:30309 -j ACCEPT

# service iptables restart

SELinux y el servicio vsftpd

Obtenga la lista de valores (booleanos) actuales de SELinux para ftp

# getsebool -a | grep ftp
allow_ftpd_anon_write --> off
allow_ftpd_full_access --> off
allow_ftpd_use_cifs --> off
allow_ftpd_use_nfs --> off
ftp_home_dir --> off
ftpd_connect_db --> off
ftpd_use_fusefs --> off
ftpd_use_passive_mode --> off
httpd_enable_ftp_server --> off
tftp_anon_write --> off
tftp_use_cifs --> off
tftp_use_nfs --> off


Para establecer un valor específico por ejemplo, ftp_home_dir, teclee

# setsebool -P ftp_home_dir on

SELinux aumenta el nivel de seguridad de vsftpd

Ejecute lo siguiente para permitir que el servidor FTP pueda asociarse a cualquier puerto sin reservar al funcionar en modo pasivo:

# setsebool -P ftpd_use_passive_mode 1

Ejecute lo siguiente para permitir que los usuarios anónimos puedan realizar procesos de escritura sobre el sistema de archivos:

# setsebool -P allow_ftpd_anon_write 1

Si se necesita permitir el acceso utilizando las cuentas de usuarios del anfitrión local, a fin de que éstos puedan acceder a sus directorio de inicio, se debe habilitar la política ftp_home_dir

# setsebool -P ftp_home_dir 1

Ejecute lo siguiente para hacer que SELinux permita acceder a los usuarios locales al resto del sistema de archivos:

# setsebool -P allow_ftpd_full_access 1

Ejecute lo siguiente para permitir que el servicio vsftpd pueda hacer uso de sistemas de archivos remotos a través de CIFS (Samba) o NFS y que serán utilizados para compartir a través del servicio

setsebool -P allow_ftpd_use_cifs 1
setsebool -P allow_ftpd_use_nfs 1


# getsebool -a | grep ftp

allow_ftpd_anon_write --> on
allow_ftpd_full_access --> on
allow_ftpd_use_cifs --> on
allow_ftpd_use_nfs --> off
ftp_home_dir --> on
ftpd_connect_db --> off
ftpd_use_fusefs --> off
ftpd_use_passive_mode --> on
httpd_enable_ftp_server --> off
tftp_anon_write --> off
tftp_use_cifs --> off
tftp_use_nfs --> off


Archivo de configuración de vsftpd.

Opción anonymous_enable

Define si se permitirán accesos anónimos al servidor.

anonymous_enable=YES

Opcion local_enable

Establece si se permiten accesos autenticados de los usuarios locales del sistema

local_enable=YES

Opción write_enable

Permite escritura en el servidor

write_enable=YES

Opción anon_upload_enable

Determina si los usuarios anónimos pueden subir contenido al servidor. No es una función deseada, por lo que se acostumbra a desactivarla.

Opción anon_upload_enable=NO


Opción anon_mkdir_write_enable

Igual que la anterior normalmente esta función no es deseada por lo que se desactiva

anon_mkdir_write_enable=NO

Opción ftpd_banner

Establece el banderín que será mostrado al acceder un usuario al servidor. La frase no debe contener signos de puntuación.

ftpd_banner=Bienvenido al servidor FTP

Establecer jaulas para los usuarios

Opciones chroot_local_user y chroot_list_file

Los usuarios del sistema que se autentiquen tendrán acceso a otros directorios del sistema fuera de su directorio personal. Para limitar a los usuarios a sólo utilizar su propio directorio, puede hacerse con la opción chroot_local_user que habilita la función chroot() y las opciones chroot_list_enable y chroot_list_file para establecer el archivo con la lista de usuarios que quedarán excluidos de la función chroot().

chroot_local_user=YES
chroot_list_enable=YES
chroot_list_file=/etc/vsftpd/chroot_list

Crear el archivo /etc/vsftpd/chroot_list si aún no lo ha hecho

# touch /etc/vsftpd/chroot_list

A partir de ahora cada vez que un usuario local se autentique en el servidor FTP sólo tendrá acceso a su directorio personal y lo que este contenga.

Si el usuario regular tiene acceso al intérprete de comandos del sistema (/bin/bash o /bin/sh) y privilegios de escritura sobre el directorio raíz de su propia jaula (su directorio de inicio) la función chroot() puede ser peligrosa. Los directorios de inicio de los usuarios involucrados deben tener permiso 755, propiedad de root y asignar al usuario /bin/false o /sbin/nologin como intérprete de comandos.

Modificar una cuenta de usuario regular para la cual se quiere dar acceso al servidor FTP utilizando chroot() con vsftpd

# chroot 755 /home/fulano
# chown root:root /home/fulano
# mkdir /home/fulano/uploads
# chown fulano:fulano /home/fulano/uploads
# usermod -s /sbin/nologin fulano

Opciones pasv_min_port y pasv_max_port

Establece el rango arbitrario de puertos utilizados para las conexiones pasivas. Cualquier rango de puertos es válido entre 1024 y 65535

pasv_min_port=30300
pasv_max_port=30309

Controlar el ancho de banda

Opción anon_max_rate

Utilizada para limitar la tasa de transferencia en bytes por segundo, para los usuarios anónimos, muy útil en servidores FTP de acceso público. En este caso 500 kb por segundo.

anon_max_rate=524288

Opción local_max_rate

Limita la tasa de transferencia en bytes por segundo para los usuarios locales del servidor. En este caso a 1 MB

local_max_rate=1048576

Opción max_clients

Establece el número máximo de clientes accediendo simultáneamente al servidor FTP. En este caso 20

max_clients=20

Opción max_per_ip

Evita que algunos accesos queden bloqueados, como en el caso de redes que acceden a través de un Proxy (servidor intermediario) o puerta de enlace.

max_per_ip=10

Soporte SSL/TLS  

Todos los datos enviados mediante el protocolo FTP lo hacen en texto simple (nombre de usuario y claves de acceso), lo cual es muy peligroso, vsftpd se puede configurar para utilizar los protocolos SSL y TLS a través de un certificado RSA.

Como usuario root acceda al directorio /etc/pki/tls

# cd /etc/pki/tls

Generar el certificado y firma digital

Utilizando una estructura X.509, algoritmo de cifrado RSA de 2048 bits, sin Triple DES que permite iniciar sin interacción alguna al servicio vsftpd, con una validez de 1825 días (5 años):


# openssl req -x509 -nodes -days 1825 -newkey rsa:2048 \
> -keyout private/vsftpd.key \
> -out certs/vsftpd.crt

Ingrese los siguientes datos

Código de dos letras para el país.
Estado o provincia.
Ciudad.
Nombre de la empresa o bien la razón social.
Unidad o sección responsable del certificado.
Nombre del anfitrión (FQDN) o bien dominio con comodín.
Dirección de correo electrónico de la persona responsable del certificado


Generating a 2048 bit RSA private key

....+++

...........+++

writing new private key to 'private/vsftpd.key'

-----

You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.

-----

Country Name (2 letter code) [XX]:ES
State or Province Name (full name) []:Catalunya
Locality Name (eg, city) [Default City]:Barcelona
Organization Name (eg, company) [Default Company Ltd]:Empresa S.L. 
Organizational Unit Name (eg, section) []:Direccion Comercial
Common Name (eg, your name or your server's hostname) []:*.linux.bcn
Email Address []:webmaster@linux.bcn


El archivo del certificado y de la firma digital, deben tener permisos de sólo lectura para el usuario root.

# chmod 400 certs/vsftpd.crt private/vsftpd.key

# cd

Edite el archivo de configuración de vsftpd.conf

# vim /etc/vsftpd/vsftpd.conf

# Habilita el soporte de TLS/SSL
ssl_enable=YES
# Deshabilita o habilita utilizar TLS/SSL con usuarios anónimos
allow_anon_ssl=NO
# Obliga a utilizar TLS/SSL para todas las operaciones, es decir, 
# transferencia de datos y autenticación de usuarios locales.
# Establecer el valor NO, hace que sea opcional
# utilizar TLS/SSL.
force_local_data_ssl=YES
force_local_logins_ssl=YES
# Se prefiere TLSv1 sobre SSLv2 y SSLv3
ssl_tlsv1=YES
ssl_sslv2=NO
ssl_sslv3=NO
# Rutas del certificado y firma digital
rsa_cert_file=/etc/pki/tls/certs/vsftpd.crt
rsa_private_key_file=/etc/pki/tls/private/vsftpd.key
# Los desarrolladores de FileZilla decidieron eliminar 
# el soporte para el algoritmo de cifrado 3DES-CBC-SHA, 
# agregue la siguiente línea para solucionarlo
ssl_ciphers=HIGH
# Filezilla además requiere desactivar la siguiente opción
require_ssl_reuse=NO

Aplicar los cambios

# service vsftpd restart
# service vsftpd restart
Apagando vsftpd:   [  OK  ]
Iniciando vsftpd para vsftpd: [  OK  ]

Asigne una contraseña al usuario fulano

$ ssh 192.168.0.1
carles@192.168.0.1's password: 
Last login: Fri Mar  9 19:52:01 2018 from 192.168.0.53

# passwd fulano

Cambiando la contraseña del usuario fulano.
Nueva contraseña: 
Vuelva a escribir la nueva contraseña: 
passwd: todos los tokens de autenticación se actualizaron exitosamente.

Cliente para acceder a FTPES

# yum -y install lftp

El mandato lftp con las opciones -e 'set ftp:ssl-force true' y -e set ssl:verify-certificate no' como argumentos y un nombre anfitrión o dirección IP como último argumento. Inicie una conexión hacia la dirección del servidor 192.168.0.1.

[carles@aldos ~]$ lftp -e 'set ftp:ssl-force true' -e 'set ssl:verify-certificate no' 192.168.0.1

En el intérprete de comandos de LFTP teclee el comando user seguido del nombre de usuario que quiera utilizar. En este caso fulano, le pedirá la contraseña.

lftp 192.168.0.1:~> user fulano
Clave:

Teclee el comando pwd

lftp fulano@192.168.0.1:~> pwd

Devolverá una salida similar a la siguiente

ftp://fulano@192.168.0.1

Cree una carpeta llamada prueba

lftp fulano@192.168.0.1:~> mkdir prueba

Lo anterior devuelve una salida como esta

mkdir ok, `prueba' creado           

Ejecute un ls

lftp fulano@192.168.0.1:/> ls

La salida es la siguiente

drwxr-xr-x    2 504      504   4096 Mar 09 20:41 prueba

Salir de lftp

lftp fulano@192.168.0.1:/> bye


Filezilla cliente FTP
# yum -y install filezilla


Red Hat System Administrator Guide
Protocolo de transferencia de archivos

Centos es genial!.

viernes, 16 de febrero de 2018

Samba en un Servidor Centos Linux

Configuración de Samba en Centos

Protocolo SMB

SMB (Server Message Block), también llamado CIFS (Common Internet File System), es un protocolo del nivel de presentación del modelo OSI de TCP/IP creado por IBM en el año 1985.

Samba

SAMBA es un conjunto de programas originalmente creados por Andrew Tridgell y mantenidos por The Samba Team.

Instalar a través de yum

# yum -y install samba samba-client samba-common

Abrir los puertos 135 al 139 (TCP Y UDP) y el puerto 445 (TCP).

Utilizando desde la consola el mandato iptables


# ptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 135:139 -j ACCEPT

# iptables -A INPUT -m state --state NEW -m udp -p udp --dport 135:139 -j ACCEPT

# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 445 -j ACCEPT

# service iptables save

O editar el archivo /etc/sysconfig/iptables y añadir lo siguiente

-A INPUT -m state --state NEW -m tcp -p tcp --dport 135:139 -j ACCEPT

-A INPUT -m state --state NEW -m udp -p udp --dport 135:139 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 445 -j ACCEPT

# service iptables restart

SELinux y el servicio smb

Con la finalidad de que SELinux permita al servicio smb la escritura como usuario anónimo, ejecute:

# setsebool -P allow_smbd_anon_write 1

A fin de que SELinux permita al servicio smb funcionar como Controlador Primario de Dominio (PDC)

# setsebool -P samba_domain_controller 1

Para que SELinux perminta al servicio smb compartir los directorios de inicio de los usuarios locales del sistema, ejecute:

# setsebool -P samba_enable_home_dirs 1

A fin de que SELinux desactive la protección para los directorios de inicio de los usuarios a través de smb, ejecute:

# setsebool -P use_samba_home_dirs 1

Con la finalidad de que SELinux permita al servicio smb crear nuevos directorios de inicio para los usuarios a través de PAM (operación común en PDC, ejecute

# setsebool -P samba_create_home_dirs 1

Para que SELinux permita al servicio smb funcionar como un organizador de mapa de puertos (portmapper):

# setsebool -P samba_portmapper 1

Para que SELinux permita al servicio smb ejecutar guiones dentro del directorio /var/lib/samba/scripts sin confinamiento:

# setsebool -P samba_run_unconfined 1

Con el fin de que SELinux permita al servicio smb compartir todos los recursos en modo de sólo lectura:

# setsebool -P samba_export_all_rw 1

Para que SELinux perminta al servicio smb compartir todos los recursos en modo de lectura y escritura:

# setsebool -P samba_export_all_rw 1

Mandato chcon

Para definir que un directorio será compartido a través del servicio smb y que debe considerarse como contenido Samba, por ejemplo /var/samba/publico:

# chcon -t samba_share_t /var/samba/publico

Antes de configurarse en el el archivo /etc/samba/smb.conf, cada nuevo directorio que se vaya a compartir debe ser configurado como se ha descrito anteriormente.

Iniciar el servicio

# service nmb start
# service smb start

Añadir el servicio al arranque del sistema

# chkconfig nmb on
# chkconfig smb on

Después de aplicar cambios al archivo de configuración de Samba es necesario reiniciar el servicio smb

# service smb restart

El servicio nmb es el encargado de proveer el servidor de nombre para los clientes a través de NetBios sobre IP. Por tanto, debe reiniciar el servicio nmb si realiza cualquier cambio en la configuración de la opción netbios name

# service nmb restart

Alta de cuentas de usuario

Primero asigne una contraseña al usuario root (no tiene que ser la misma utilizada en el sistema).

# smbpasswd -a root

La sincronización de cuentas entre el servidor Samba y las estaciones Windows se realiza ingresando el mismo nombre de usuario y contraseña tanto en el servidor Samba como en la máquina Windows.

La mayoría de las cuentas de usuario que se utilizan para acceder a Samba no requieren acceso al intérprete de comandos del sistema, no hace falta asignar una contraseña con el mandato passwd. El intérprete de comandos quedará definido como /sbin/nologin o /bin/false para la cuenta de usuario. Esta cuenta en cuestión estará inactiva para el resto de servicios.

# useradd -s /sbin/nologin andrius
# smbpasswd -a andrius

Archivo lmhosts

Se utiliza para resolver de manera local los nombres NetBios, asociándolos con su dirección IP correspondiente. El nmbre NetBios no debe exceder los doce caracteres alfanuméricos. Como mínimo debe definirse el nombre del anfitrión del servidor Samba junto a su dirección IP.

# vi /etc/samba/lmhosts
127.0.0.1      localhost
192.168.0.1      servidor

Configuración básica del archivo smb.conf

# vi /etc/samba/smb.conf

La opción workgroup define el grupo de trabajo

workgroup = MYGROUP

Opción netbios name

Define un nombre de anfitrión distinto al detectado automáticamente. Debe ser el mismo que aparece en el archivo /etc/samba/lmhosts

netbios name = servidor

Opción server string

server string = Servidor Samba %v en %L

Opción hosts allow

En esta entrada del archivo smb.conf se pueden definir direcciones IP o redes que tendrán permiso de acceso hacia el servidor. Por tanto, una red con anfitriones con direcciones IP desde 192.168.0.1 hasta 192.168.0.254, el rango de direcciones IP definido en hosts allow será 192.168.0., (los tres primeros octetos).

Vamos a definir las redes 192.168.0.0/24, 102.168.1.0/24 y 192.168.3.0/24 como vimos con anterioridad utilizando los tres primeros octetos de la dirección IP de red, en el caso de cualquier dirección IP de la red 127.0.0.0/8 se define sólo el primer octeto de dicho segmento.

hosts allow = 127., 192.168.0., 192.168.1., 192.168.3.

Opción name resolve order

Define el orden en que se intenta de resolver los nombres NETBIOS. Primero con la información del archivo /etc/samba/lmhosts, luego el archivo /etc/hosts, a continuación de consultas en el servidor WINS y, si todo lo anterior falla, a través de la dirección IP de difusión de la red local.

name resolve order = lmhosts hosts wins bcast

Gestor de archivos Nautilus

Esta configuración es necesaria para el gestor de archivos predeterminado de Gnome, Nautilus y además que se especifique wins en el orden de resolución de nombres del archivo /etc/nsswitch.conf del anfitrión desde el cual se ejecute.

# vi /etc/nsswitch.conf

hosts:    files dns

al final agregje wins

hosts:    files dns wins

Opción remote announce

remote announce = 192.168.3.127, 192.168.1.255

Reinicie los servicios para aplicar los cambios.

# service smb restart
# service nmb restart

Compartir directorios

Crear el directorio /var/samba/publico

# mkdir -p /var/samba/publico

Cambiar el contexto de SELinux para que este directorio sea considerado como contenido Samba.

# chcon -t samba_share_t /var/samba/publico


[publico]

comment = Recurso compartido publico

path = /var/samba/publico

guest ok = yes

read only = yes

write list = andrius

directory mask = 0755

create mask = 0644

Listas de control de acceso ACL

setfacl se utiliza para cambiar los permisos en las listas de control de acceso de un archivo o directorio dado. Asignar cambiar permisos de lectura, escritura y ejecución al usuario andrius

Crear el usuario y agregarlo al grupo samba

# useradd -s /sbin/nologin andrius
# smbpasswd -a andrius
# passwd andrius

# setfacl -m u:andrius:rwX /var/samba/publico

Se utilizó X mayúscula para indicar que sólo se aplicará el bit de acceso a directorios evitando aplicar el bit de ejecución a los archivos.

getfal se utiliza para determinar los permisos establecidos en las listas de control de acceso de un archivo o directorio.

# getfacl /var/samba/publico/

getfacl: Eliminando '/' inicial en nombres de ruta absolutos

# file: var/samba/publico/

# owner: root

# group: root

user::rwx

user:andrius:rwx

group::r-x

mask::rwx

other::r-x


Estos permisos que se establecieron en la lista de control de acceso del directorio /var/samba/publico son exclusivamente para éste. Cualquier nuevo archivo o directorio creado carecerá de estos nuevos permisos. Si se desea que éstos permisos se vuelvan los predeterminados para los nuevos archivos y directorios que sean creados en lo sucesivo dentro del directorio /var/samba/publico, se ejecuta el mismo mandato setfacl, pero añadiendo la opción -d para definir que serán los permisos  predeterminados  para nuevos archivos  y directorios.

Lo anterior muestra que sólo el propietario del directorio tiene permisos de lectura, escritura y acceso. Para lograr que un usuario en particular pueda acceder también a este directorio, se ejecuta el mandato setfacl, con la opción -m para modificar la lista de control de acceso, [u,g,o]:[usuario,grupo]:[r,w,x] y la ruta del directorio como argumentos. Ejemplo:

setfacl -m u:usuario:rX /var/samba/publico

En el ejemplo anterior se utilizó X mayúscula para indicar que sólo se aplicará el bit de acceso de a directorios evitando aplicar el bit de ejecución a los archivos.

Lo mismo en notación octal

# setfacl -m u:usuario:5 /var/samba/publico

Editar el archivo /etc/samba/smb.conf y al final añada el siguiente contenido


[publico]

comment = Recurso compartido publico 

path = /var/samba/publico

guest ok = yes

read only = yes

write list = andrius

directory mask = 0755

create mask = 0644


# service smb restart

Ocultando archivos que empiezan por punto.

Los archivos cuyo nombre comienza con un punto (archivos de configuración, normalmente), como es el caso del directorio de inicio del usuario en el servidor Samba (.bash_profile, .bashrc, .bash_history entre otros) pueden ocultarse con la opción hide dot files y el valor Yes.

[homes]
    comment = Home Directories
    browseable = no
    writable = yes
    valid users = %S
    inherit acls = yes
    hide dot files = yes

Reinicie el servidor smb para que los cambios tengan efecto

# service smb restart


Montar recursos compartidos desde un cliente Linux

$ cat /etc/hosts
127.0.0.1        localhost.localdomain localhost
::1        localhost6.localdomain6 localhost6
192.168.0.1    servidor

# mkdir /mnt/publico

# mount.cifs -o username=andrius //servidor/publico /mnt/publico

Solicitará la contraseña del usuario utilizado en el servidor Samba

Password for andrius@//servidor/publico:

# mount | grep publico
//servidor/publico on /mnt/publico type cifs (rw)

Cree el archivo /etc/acreditar para hacer permanente lo anterior.

# vim /etc/acreditar

Especifique el nombre de usuario y contraseña utilizados con el recurso compartido.

username=andrius
password=password

Cambiando los permisos de acceso al archivo para que sólo el usuario root pueda ver y modificar el contenido.

# chmod 600 /etc/acreditar

# vim /etc/fstab

Este recurso será montado automáticamente en el siguiente reinicio del sistema. Agregue la siguiente línea incluyendo las opciones uid y gid

//servidor/publico /mnt/publico cifs credentials=/etc/acreditar,uid=501,gid=501 0 0

Utilizar smbclient desde Linux

Lo más práctivo y sencillo para hacer pruebas es el mandato smbclient. Permite acceder hacia cualquier servidor Samba y Windows.

# smbclient -U andrius -L servidor


Conectar un cliente Windows al servior Samba

Esta máquina está en la red 192.168.3.0/25 detrás de un firewall router Soekris y OpenBSD.






https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/7/pdf/system_administrators_guide/Red_Hat_Enterprise_Linux-7-System_Administrators_Guide-en-US.pdf

Centos es genial!.

domingo, 4 de febrero de 2018

Servidor Centos 6.9

Samba en un servidor Centos
Servidor NTP Centos


Este servidor consta de dos tarjetas de red: Una con la que se conecta a Internet desde el router del proveedor de acceso a Internet (ISP) y otra para la red interna. El sistema operativo es Centos 6.9 excelente sistema con una extensa documentación. DHCP, DNS, Samba, Iptables, etc..

eth0 = Internet
eth1 = Red interna

Centos 6.9 puede instalarse desde un dvd o una memoria USB en modo gráfico (conectando el servidor a un monitor). A partir de la mínima configuración puede continuar vía ssh desde una máquina de la red. La opción a elegir es servidor.


Estructurar la red eth0 eth1. /etc/sysconfig/network-scripts/ifcfg-eth0 /etc/sysconfig/network-scripts/ifcfg-eth1


DEVICE=eth0
HWADDR=00:22:4D:A5:9D:06
TYPE=Ethernet
UUID=2288f191-aa67-420a-b23c-ad5ce6bc1736
ONBOOT=yes
NM_CONTROLLED=no
BOOTPROTO=dhcp
DEFROUTE=yes
PEERDNS=yes
PEERROUTES=yes
IPV4_FAILURE_FATAL=yes
IPV6INIT=no

DEVICE=eth1
HWADDR=00:22:4D:A5:9D:0A
TYPE=Ethernet
UUID=6f52e738-8c50-4c34-9f47-399086d5406f
ONBOOT=yes
NM_CONTROLLED=no
BOOTPROTO=static
IPADDR=192.168.0.1
NETMASK=255.255.255.0
PEERDNS=no



Servidor DHCP para entregar direcciones de red a los equipos de la red interna /etc/dhcp/dhcpd.conf


# DHCP Server Configuration file.
#   see /usr/share/doc/dhcp*/dhcpd.conf.sample
#   see 'man 5 dhcpd.conf'
#
ddns-update-style interim;
ignore client-updates;
authoritative;
default-lease-time 900;
max-lease-time 7200;
option ip-forwarding off;
option domain-name "linux.bcn";

ddns-update-style none;
subnet 192.168.0.0 netmask 255.255.255.0 {
option routers 192.168.0.1;
option subnet-mask 255.255.255.0;
option broadcast-address 192.168.0.255;
option domain-name-servers 8.8.8.8,8.8.4.4,192.168.0.1;
option ntp-servers 192.168.0.1;
range 192.168.0.50 192.168.0.99;
}

Habilitar ssh y prohibir la autenticación como usuario root
PermitRootLogin no
AllowUsers carles

Activar el reenvío de paquetes IP

# sysctl net.ipv4.ip_forward = 1

En el archivo /etc/sysctl.conf cambiar
# Controls IP packet forwarding
net.ipv4.ip_forward = 0

por
# Controls IP packet forwarding
net.ipv4.ip_forward = 1

Iptables para administrar Netfilter

# Generated by iptables-save v1.4.7 on Fri Feb  9 23:38:57 2018
*mangle
:PREROUTING ACCEPT [1128:95583]
:INPUT ACCEPT [1033:84832]
:FORWARD ACCEPT [95:10751]
:OUTPUT ACCEPT [722:117312]
:POSTROUTING ACCEPT [789:118879]
COMMIT
# Completed on Fri Feb  9 23:38:57 2018
# Generated by iptables-save v1.4.7 on Fri Feb  9 23:38:57 2018
*nat
:PREROUTING ACCEPT [11:704]
:POSTROUTING ACCEPT [1:116]
:OUTPUT ACCEPT [32:9528]
-A PREROUTING -i eth1 -p tcp -m tcp --dport 80 -j REDIRECT --to-ports 8080 
-A POSTROUTING -o eth0 -j MASQUERADE 
COMMIT
# Completed on Fri Feb  9 23:38:57 2018
# Generated by iptables-save v1.4.7 on Fri Feb  9 23:38:57 2018
*filter
:INPUT DROP [9:353]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A INPUT -i eth1 -p udp -m udp --dport 67:68 -j ACCEPT 
-A INPUT -i lo -j ACCEPT 
-A INPUT -i eth0 -m state --state RELATED,ESTABLISHED -j ACCEPT 
-A INPUT -s 192.168.0.0/24 -i eth1 -j ACCEPT 
-A INPUT -p icmp -m icmp --icmp-type 8 -j ACCEPT 
-A INPUT -p icmp -m icmp --icmp-type 11 -j ACCEPT 
-A INPUT -p icmp -m icmp --icmp-type 3 -j ACCEPT 
-A INPUT -s 192.168.0.0/24 -i eth1 -p tcp -m tcp --sport 1024:65535 --dport 22 -m state --state NEW -j ACCEPT 
-A INPUT -p tcp -m state --state NEW -m tcp --dport 135:139 -j ACCEPT 
-A INPUT -p udp -m state --state NEW -m udp --dport 135:139 -j ACCEPT 
-A INPUT -p tcp -m state --state NEW -m tcp --dport 445 -j ACCEPT 
-A INPUT -p tcp -m state --state NEW -m tcp --dport 53 -j ACCEPT 
-A INPUT -p udp -m state --state NEW -m udp --dport 53 -j ACCEPT 
-A INPUT -i eth0 -j LOG 
-A INPUT -i eth1 -j LOG --log-prefix "From LAN:" 
-A INPUT -i eth1 -p tcp -m state --state NEW -m tcp --dport 8080 -j ACCEPT 
-A FORWARD -o eth0 -m state --state NEW,RELATED,ESTABLISHED -j ACCEPT 
-A FORWARD -i eth0 -m state --state RELATED,ESTABLISHED -j ACCEPT 
-A FORWARD -o eth0 -p tcp -m tcp --sport 31337 --dport 31337 -j DROP 
-A FORWARD -j LOG --log-prefix "forward:" 
-A OUTPUT -o lo -j ACCEPT 
-A OUTPUT -d 192.168.0.0/24 -o eth1 -j ACCEPT 
-A OUTPUT -o eth0 -p tcp -m tcp --sport 31337 --dport 31337 -j DROP 
-A OUTPUT -s 192.168.0.0/24 -o eth1 -p udp -m udp --sport 1024:65535 --dport 53 -j ACCEPT 
-A OUTPUT -s 192.168.0.0/24 -o eth1 -p udp -m udp --dport 67:68 -j ACCEPT 
-A OUTPUT -s 192.168.0.0/24 -o eth1 -p udp -m udp --sport 53 --dport 1024:65535 -j ACCEPT 
-A OUTPUT -s 192.168.0.0/24 -o eth1 -p udp -m udp --dport 5353 -j ACCEPT 
-A OUTPUT -s 192.168.0.0/24 -o eth1 -p udp -m udp --dport 67:68 -j DROP 
-A INPUT -m state --state NEW -m udp -p udp --dport 123 -j ACCEPT 
-A OUTPUT -o WAN_IFACE -p tcp -m tcp --sport 1:1024 -j DROP 
-A OUTPUT -o WAN_IFACE -p udp -m udp --sport 1:1024 -j DROP 
-A OUTPUT -o eth0 -p udp -m udp --sport 1:1024 -j DROP 
COMMIT
# Completed on Fri Feb  9 23:38:57 2018

Reiniciar el servicio iptables
# service iptables restart

Linux es genial!.

jueves, 29 de octubre de 2015

Tráfico protegido con una VPN basada en BSD

Cuando estás en una red insegura, la última cosa que quiere es que alguien registre todo el tráfico. Hacer la mayor parte de su trabajo a través de SSH es probablemente la mejor solución, a veces desea encapsular todo su tráfico en un túnel. OpenSSH puede hacer eso con un poco de trabajo extra, pero OpenVPN es una herramienta hecha para este propósito exacto. OpenVPN funciona en todos los BSD. Vamos a utilizar FreeBSD 9 en este tutorial, pero se puede adaptar las ubicaciones de los archivos y la configuración a otros BSD muy fácilmente. Instalar OpenVPN desde ports o paquetes.

Escenario: Un servidor FreeBSD con dos tarjetas de red:
Wan -em1 (192.168.1.250)
Lan - em0 (192.18.3.1).
Dhcp - activado
Firewall - ipfilter

El ordenador cliente ejecuta openBSD 5.6, pf firewall.

se conecta a la red Lan a través de un Switch. Ahora asignamos la dirección IP y el gateway con los siguientes comandos:


Luego, añadiremos OpenVPN para los elementos de inicio, en el cliente y el servidor:

En el sevidor (FreeBSD)
# echo 'openvpn_enable="YES"' >> /etc/rc.conf
# echo 'openvpn_if="tun"' >> /etc/rc.conf

En el cliente (OpenBSD)
# echo 'openvpn_enable=YES' >> /etc/rc.conf.local
# echo 'openvpn_if=tun' >> /etc/rc.conf.local

Vamos a configurar el registro (log) adecuado:
# ssh carles@192.168.1.254
Password:

# vi /etc/syslog.conf:
Agregue al final de /etc/syslog.conf algo como esto:

!openvpn
*.* /var/log/openvpn.log
!*

Crear el archivo openvpn.log y releer el archivo de configuración:

# touch /var/log/openvpn.log
# /etc/rc.d/syslogd reload
Rotación de registro (log) para que no se quede sin espacio en disco:

# cat << END >> /etc/newsyslog.conf  \
/var/log/openvpn.log  600  30    *    @T00  ZC  \
END

Ahora vamos a crear los certs, conectando via ssh al servidor FreeBSD. El port OpenVPN instala easy-rsa, es una herramienta para generar certificados. Haremos nuestra propia copia de trabajo del directorio easy-rsa en un lugar seguro :

# pkg_add -v openvpn
# cp -r /usr/local/share/easy-rsa /root/easy-rsa
# cd /root/easy-rsa

Editar las variables en el archivo "vars" para establecer los valores predeterminados para los certificados. La mayor parte de lo que se quiere cambiar es en la parte inferior. "KEY_SIZE" y "KEY_CN" son los más utilizados, "KEY_CN" se utiliza como el nombre de host del servidor predeterminado para los certificados. No pueden estar en blanco.

export KEY_SIZE=2048
export KEY_COUNTRY="ES"
export KEY_PROVINCE="CA"
export KEY_CITY="Barcelona"
export KEY_ORG="server-carles-freebsd"
export KEY_EMAIL="me@myhost.mydomain"
export KEY_CN="freebsdsvr.linux.bcn"
export KEY_NAME=changeme
export KEY_OU="bsdalways"

Preparar un entorno de Bourne shell para la creación de certificados:

# sh
# . ./vars
Debe ejecutar clean-all la primera vez antes de crear certificados. Si usted ya tiene algunos, serán eliminados .

# ./clean-all
Generar el CA certificado que se utilizará para firmar los otros. Basta con aceptar los valores predeterminados a menos que usted desee anularlos.

# ./build-ca
Generar el certificado de servidor utilizando un nombre de host NC 'openvpn-server'. Es conveniente utilizar el nombre de host del servidor de la NC, pero no es obligatorio. Una vez más, acepte los valores predeterminados.

# ./build-key-server openvpn-server
Generar DH claves:

# ./build-dh
Generar un certificado de cliente para cada cliente, en este caso 'openvpn-openBSD-client. Es conveniente utilizar el nombre de host del cliente de la NC, se utiliza como un identificador.

# ./build-key openvpn-client
Almacenar permanentemente las claves de servidor en un lugar seguro :

# mkdir -p /usr/local/etc/openvpn/keys
# chmod 700 /usr/local/etc/openvpn/ /usr/local/etc/openvpn/keys
# cp /root/easy-rsa/keys/ca.crt /usr/local/etc/openvpn/keys/
# cp /root/easy-rsa/keys/dh*.pem /usr/local/etc/openvpn/keys/
# cp -p /root/easy-rsa/keys/openvpn-server.crt /usr/local/etc/openvpn/keys/
# cp -p /root/easy-rsa/keys/openvpn-server.key /usr/local/etc/openvpn/keys/
En cada cliente, crear un lugar seguro para el archivo de configuración y las claves:

# mkdir -p /usr/local/etc/openvpn/keys
# chmod 700 /usr/local/etc/openvpn/ /usr/local/etc/openvpn/keys

Advertencia de Permiso denegado:
scp: /usr/local/etc/openvpn/keys/: Permission denied

Voy al cliente para cambiar los permisos "solo" para la copia de claves:
# chmod 777 /usr/local/etc/openvpn/ /usr/local/etc/openvpn/keys

Copiar de forma segura el siguiente certificado de cliente y archivos de clave de openvpn-server, en cada cliente en /usr/local/etc/openvpn/keys:

Desde el servidor teclear los siguientes comandos:
# scp /root/easy-rsa/keys/ca.crt carles@192.168.3.60:/usr/local/etc/openvpn/keys/
# scp /root/easy-rsa/keys/openvpn_openBSD_client.crt carles@192.168.3.60:/usr/local/etc/openvpn/keys/
# scp /root/easy-rsa/keys/openvpn_openBSD_client.key carles@192.168.3.60:/usr/local/etc/openvpn/keys/

No olvide revertir los cambios, en el cliente, después de realizar la copia segura (scp):
# chmod 700 /usr/local/etc/openvpn/ /usr/local/etc/openvpn/keys

Garantizar permisos de seguridad en el archivo clave del cliente :
# chmod 600 /usr/local/etc/openvpn/keys/*.key
Next, we'll edit the server configuration for openvpn.conf:

Archivo de configuracióon del servidor:
# cp /usr/local/share/examples/openvpn/sample-config-files/server.conf \
   /usr/local/etc/openvpn/openvpn.conf
# chmod 600 /usr/local/etc/openvpn/openvpn.conf
# vi /usr/local/etc/openvpn/openvpn.conf
Reemplace:

ca ca.crt
cert server.crt
key server.key  # This file should be kept secret
Por:

ca /usr/local/etc/openvpn/keys/ca.crt
cert /usr/local/etc/openvpn/keys/openvpn-server.crt
key /usr/local/etc/openvpn/keys/openvpn-server.key
Luego reemplace:

dh dh2048.pem
Por:

dh /usr/local/etc/openvpn/keys/dh2048.pem
Finalmente:

comp-lzo
Por:

comp-lzo no
push "comp-lzo no"
LZO compression fue desactivado debido a posibles chosen-plaintext ataques.

Archivo de configuración del cliente - client.conf:

# mkdir /etc/openvpn
# cp /usr/local/share/examples/openvpn/sample-config-files/client.conf \
  /etc/openvpn/client.conf
# chmod 600 /etc/openvpn/client.conf
# vi /etc/openvpn/client.conf
Remplace:

remote my-server-1 1194
Por:

remote 192.168.3.1 1194
topology subnet
:
Utilice el nombre real de su servidor o IP por '192.168.3.1'. Luego, remplace

ca ca.crt
cert client.crt
key client.key  # Este archivo debe ser mantenido en secreto
Por:

ca /usr/local/etc/openvpn/keys/ca.crt
cert /usr/local/etc/openvpn/keys/openvpn-client.crt
key /usr/local/etc/openvpn/keys/openvpn-client.key
Finalmente:

comp-lzo
Por:

comp-lzo no

Ahora podemos iniciar conexiones.

En el servidor, ejecute:

# service openvpn start
$ hostname
freebsdsvr.linux.bcn
$ ps ax |grep openvpn
1503 ??  Ss     0:00.30 /usr/local/sbin/openvpn --cd /usr/local/etc/openvpn --d
4689  0  R+     0:00.00 grep openvpn

Compruebe ifconfig, debería aparecer una nueva interfaz tun. Haga lo mismo en el cliente
# ifconfig -tun0


Iniciar openvpn en el cliente openBSD:

Es necesario el archivo  /etc/rc.d/openvpn

Este es un script rc normal utilizado por openbsd. Lo encontrará en,
http://www.openbsdsupport.org/openvpn-on-openbsd56.html

#######################################
#!/bin/sh
#
# openvpn rc.d script for OpenBSD - by Chris Pfaff
#
# This script acts like normal rc script if the openvpn_flags in rc.conf.local ar
# But if openvpn_flags are set to special string "-use-etc-hostname-" then script
#  It starts the openvpns configured in /etc/hostname.if (eg in /etc/hostname.tun
#  It will start multiple openvpn - each with its own config defined in /etc/host
#  If script detects that a process is already running - it does not try to start
#  It supports usual parameters like: start, check, stop, restart, reload
#
# -d = debug mode - use to see verbose information about executed commands
#

daemon="/usr/local/sbin/openvpn"

. /etc/rc.d/rc.subr

if [ "$daemon_flags" != "-use-etc-hostname-" ]; then 
    # handle as usual
    rc_cmd $1
else
    #special unusual handling
    #start openvpns defined in /etc/hostname.*

    # Edit if necessary
    # This pattern is being used for scanning /etc/hostname.tun*
    # and for finding running openvpn processes
    # and for searching individual openvpn process - then patter is appended with: [^a-zA-Z]${hnif}([^0-9]|$)
    processpattern='openvpn.*--daemon.*'

    [ -n "${_RC_DEBUG}" ] || _n="-n"
    PGREPFLAG="-f"
    PKILLFLAG="-f"
    [ -z "${_RC_DEBUG}" ] && PKILLFLAG="$PGREPFLAG -q"  # quiet if not debug mode
    [ -z "${_RC_DEBUG}" ] && PGREPFLAG="$PGREPFLAG -q"  # quiet if not debug mode
    [ -n "${_RC_DEBUG}" ] && PGREPFLAG="$PGREPFLAG -l"  # list process name in debug mode
    case "$1" in
    start|check)
        [ "$1" == "start" ] && echo $_n "${INRC:+ }${_name} "
        if [ X"${daemon_flags}" = X"NO" ]; then
            _rc_err "$0: need -f to force $1 since ${_name}_flags=NO"
            exit 1
        fi
        allprocstatus=0
        # search all hostname.tun* files which contain openvpn startup command
        hostnamepattern="/etc/hostname.tun*"
        for hostnamefile in $hostnamepattern; do
            if [ "$hostnamefile" = "$hostnamepattern" ]; then
                [ -n "${_RC_DEBUG}" ] && echo "no files $hostnamepattern"
                [ "$2" == "quiet" ] && exit 1
                _rc_exit failed
            fi
            [ -n "${_RC_DEBUG}" ] && echo
            if grep -v "^[  ]*#" "$hostnamefile" | grep -q "$processpattern" ; then
                [ -n "${_RC_DEBUG}" ] && echo "File $hostnamefile is openvpn file - will be started/checked"
            else
                [ -n "${_RC_DEBUG}" ] && echo "File $hostnamefile is not related to openvpn - skipping"
                continue
            fi
            # extract interface name from filename
            hnif=${hostnamefile##/etc/hostname\.}
            if [ -z "$hnif" ]; then
                [ -n "${_RC_DEBUG}" ] && echo "Cannot get interface name from $hostnamefile"
                hnifstatus=1
                allprocstatus=1
                continue
            fi

            # check if process is already running for this network interface - if yes, do nothing and result is ok 
            hnifprocesspattern="${processpattern}[^a-zA-Z]${hnif}([^0-9]|$)"  # eg server_tun0.conf or client_tun0.conf or -dev tun0
            [ -n "${_RC_DEBUG}" ] && echo "Executing: pgrep ${PGREPFLAG} \"$hnifprocesspattern\""
            pgrep ${PGREPFLAG} "$hnifprocesspattern" && continue

            if [ "$1" == "check" ]; then
                [ -n "${_RC_DEBUG}" ] && echo "Missing openvpn process for ${hnif} - see $hostnamefile"
                hnifstatus=1
            else
                echo -n "$hnif "  # write name of started if
                # if process is not running for this interface - start it
                [ -n "${_RC_DEBUG}" ] && echo "Executing: /bin/sh /etc/netstart $hnif "
                /bin/sh /etc/netstart $hnif; hnifstatus=$?
                [ -n "${_RC_DEBUG}" ] && echo " status: $hnifstatus"  # etc/hostname scripts may return 0 even if error occurred
            fi
            [ $hnifstatus -ne 0 ] && allprocstatus=1
        done
        # if ANY failed then return failure - (simple exit if check in quiet mode)
        [ "$2" == "quiet" -a $allprocstatus -ne 0 ] && exit 1
        [ $allprocstatus -ne 0 ] && _rc_exit failed
        [ "$2" == "quiet" ] && exit 0
        _rc_exit ok
        ;;
    stop)
        echo $_n "${INRC:+ }${_name} "
        [ -n "${_RC_DEBUG}" ] && echo "Executing: pkill ${PKILLFLAG} \"$processpattern\""
        pkill ${PKILLFLAG} "$processpattern"
        countdown=10
        while [ "((countdown--))" -gt 0 ]; do
            pgrep ${PKILLFLAG} "$processpattern" >/dev/null || continue
            sleep 1;
        done;
        [ -n "${_RC_DEBUG}" ] && echo "Executing: $0 ${_RC_DEBUG} ${_RC_FORCE} check quiet"
        $0 ${_RC_DEBUG} ${_RC_FORCE} check quiet && _rc_exit failed
        _rc_exit ok
        ;;
    reload)
        echo $_n "${INRC:+ }${_name} "
        [ -n "${_RC_DEBUG}" ] && echo "WARNING: Reload might crash the process if process is chrooted"
        [ -n "${_RC_DEBUG}" ] && echo "Executing: pkill -HUP ${PKILLFLAG} \"$processpattern\""
        pkill -HUP ${PKILLFLAG} "$processpattern" || _rc_exit failed
        sleep 10;
        [ -n "${_RC_DEBUG}" ] && echo "Executing: $0 ${_RC_DEBUG} ${_RC_FORCE} check quiet"
        [ -n "${_RC_DEBUG}" ] && echo "WARNING: Reload might crash the process if process is chrooted"
        $0 ${_RC_DEBUG} ${_RC_FORCE} check quiet || _rc_exit failed
        _rc_exit ok
        ;;
    restart)
        $0 ${_RC_DEBUG} ${_RC_FORCE} stop &&
            $0 ${_RC_DEBUG} ${_RC_FORCE} start
        ;;
    *)
        _rc_usage
        ;;
    esac
fi
########################################


Hacer el script ejecutable:
# chmod +x /etc/rc.d/openvpn

Este script rc /etc/rc.d/openvpn sólo funciona si openvpn_flags se define en rc.conf.local

Con el fin de tener el guión openvpn rc compatible con archivos /etc/hostname.*

Añadir a /etc/rc.conf.local:
openvpn_flags = "- use-etc-hostname -"

Luego agregamos estas lineas al archivo /etc/hostname.msk0 (NIC Ethernet):
dhcp
up
!/usr/local/sbin/openvpn --config /etc/openvpn/client.conf

Puerta de enlace por defecto - gateway:
# cat /etc/mygate
192.168.3.1

Probar conexión al servidor openvpn:
# openvpn --config /etc/openvpn/client.conf


Iniciar openvpn cliente como demonio:
Añadir al archivo /etc/openvpn/client.conf

# Make the server daemonize after initialization
daemon openvpn


# ps ax | grep openvpn
 7085 ??  Ss      0:00.04 openvpn --config /etc/openvpn/client.conf
 8952 p1  R+      0:00.00 grep openvpn (ksh)
# hostname
openBSD.my.domain

# ifconfig tun0


El cliente debe poder hacer ping 10.8.0.1.
$ hostname
openBSD.my.domain
$ ping -c5 10.8.0.1


$ tail /var/log/openvpn.log


En este punto al iniciar el cliente openBSD conectará automáticamente al servidor openvpn:



# tcpdump -i msk0 -np

-p Don't put the interface into promiscuous mode
-n Don't convert addresses to names


Es posible que desee mover /root/easy-rsa fuera del servidor a un lugar seguro para reducir el riesgo de que un keylogger esté copiando las pulsaciones del teclcado. Es autónomo y todavía se puede utilizar para generar más claves en otros lugares. Si lo desea, puede utilizar la opción 'cipher ' para elegir el cifrado fuerte y 'auth' plus 'tls -auth' para permitir HMAC en los paquetes. Si lo habilita

push "redirect-gateway def1 bypass-dhcp"
en el servidor, los clientes conectados anularán temporalmente la puerta de enlace predeterminada y se fijará una nueva puerta de enlace predeterminada en el servidor VPN a través del túnel. El servidor VPN debe estár configurado como un router (gateway_enable="YES" en rc.conf ) y NAT para enrutar tráfico adecuadamente a la red externa (Internet). Si reinicia el servidor, los clientes se vuelven a conectar una vez pasado el tiempo de espera definido en la configuración del cliente.

Key Files

Una explicación de los archivos relevantes, (howto openvpn)
Filename Needed By Purpose Secret
ca.crt server + all clients Root CA certificate NO
ca.key key signing machine only Root CA key YES
dh{n}.pem server only Diffie Hellman parameters NO
server.crt server only Server Certificate NO
server.key server only Server Key YES
client1.crt client1 only Client1 Certificate NO
client1.key client1 only Client1 Key YES
client2.crt client2 only Client2 Certificate NO
client2.key client2 only Client2 Key YES
client3.crt client3 only Client3 Certificate NO
client3.key client3 only Client3 Key YES

Bibliografía:
Originally written by Adam McDougall
https://openvpn.net/index.php/open-source/documentation/howto.html

http://networkfilter.blogspot.com.es/2015/01/be-your-own-vpn-provider-with-openbsd.html
http://www.bsdnow.tv/tutorials/openvpn
https://wiki.freebsd.org/
http://www.openbsd.org/faq/

Unix es genial!.

martes, 21 de abril de 2015

Openvpn raspberry pi 2

Nivel avanzado.

Fuente:

Eric Jodoin (Sans) http://www.sans.org/
Eric Jodoin tutorial (formato pdf) http://www.sans.org/reading-room/whitepapers/hsoffice/soho-remote-access-vpn-easy-pie-raspberry-pi-34427
How to Lauren Orsini Parte una y Parte dos:
http://readwrite.com/2014/04/10/raspberry-pi-vpn-tutorial-server-secure-web-browsing
http://readwrite.com/2014/04/11/building-a-raspberry-pi-vpn-part-two-creating-an-encrypted-client-side

Construir un servidor que cifra sus datos web de miradas indiscretas.

Portátil Dell Inspiron 1525 OpenBSD KDE 3.5 Intel SSD 40GB sata II. Me encanta!


VPN en Raspberry Pi 2 con Openvpn.

Wifi gratis y sin cifrar se encuentran en todas partes, aunque no es buena idea comprobar su cuenta bancaria a menos que no le importe que alguien esté husmeando. Como evitarlo ? una VPN (red privada virtual). Extiende su propia red privada en lugares públicos, de manera que si utiliza la conexión Wifi del establecimiento en que está, su navegación permanece encriptada y segura.

Lo más económico para mantener sus datos seguros es abstenerse de utilizar acceso Wifi, poco prático, aunque sí podemos construir nuestro propia VPN en casa, ejecutarla en un dispositivo del tamaño de un teléfono móvil, de muy bajo costo y consumo, Raspberry Pi 2.

Que necesita:
Tener instalado Raspbian
Una IP estática para la Raspberry Pi o un servicio DDNS (yo utilizo freedns.afraid.org). Utiliza su propia configuración, por tanto no necesita la utilidad ddclient. Es gratis, funciona perfecto desde 2007 y en la actualidad cuenta con mas de 2,500,000 de miembros.

Nota: Para mantener nuestro subdominio activo en freedns.afraid.org, debemos autentificarnos por lo menos una vez en 6 meses. Aunque es posible reactivarlo pasado este período de tiempo.

Configurar ddns freedns.afraid:
Es un DDNS gratis basado en servidores FreeBSD.
Primero se realiza el registro y a continuacion desde la entrada Subdomains, se crea un subdominio.
Ahora, desde la pestaña Dynamic DNS,  podrá actualizar automáticamente cada 5 minutos utilizando cron :
2 dynamic update candidates! (A and AAAA records).

Al clicar sobre quick cron example ver
á algo como esto:

El texto que aparece seleccionado (al final de la página), lo pegaremos llamando la tabla de tareas crontab, revisada por cron (un administrador regular de procesos en segundo plano (demonio) que ejecuta guiones a intervalos regulares (por ejemplo, cada minuto, día, semana o mes):
pi@server $ sudo /etc/crontab -e


Guardar y cerrar.

Consideraciones si utiliza no-ip: 
1. Abrir puerto 8245 en la Raspberry Pi (iptables)
2. no-ip no necesita de ddclient. Utiliza un tar.gz descargable desde su cuenta de usuario - noip-duc-linux.tar.gz. Las instrucciones de Instalación se encuentra en el archivo README.FIRST

Necesita tener habilitado SSH para conectar a la Raspberry Pi desde otro ordenador.
Redirigir puerto 1194 (UDP) a la IP interna de la Raspberry Pi (NAT en su router, port mapping).
Configurar servicio DDNS en el router de acceso a Internet.
Redirigir puerto 22 a la IP de su Raspberry Pi, para realizar conexión remota a la Raspberry Pi.

Si precisa de ddclient:
ddclient asume que está conectado directamente a Internet. Como su Raspberry Pi está dentro de su red interna, tiene que editar el archivo ddclient manualmente y reemplazar use=if, if=eth0 por use=web, if=myip.dnsdynamic.org

# cat /etc/ddclient.conf
##############
daemon=300
protocol=dyndns2
use=web, if=myip.dnsdynamic.org
server=freedns.afraid.org
login=username@gmail.com
password=' '
MyPiVPN.dnsdynamic.com
##############

Re-ejecutar ddclient:
# sudo pkg-reconfigure ddclient

Conectar con la Raspberry Pi via SSH desde otro pc y cambie su contraseña y/o nombre de usuario


Vamos a actualizar la Raspberry Pi con estos comandos:

pi@server ~ $ sudo apt-get update && sudo apt-get upgrade


Instalar OpenVPN

pi@server ~ $ sudo apt-get install openvpn

No quiere que cualquiera que encuentre la direccion del servidor VPN se pueda conectar. Vamos a crear una llave para el servidor utilizando Easy RSA, metodo de cifrado incluido en OpenVPN.

Obtener permisos de superusuario
pi@server ~ $ sudo -s
root@server:/home/pi#

Copiar el directorio 2.0 a /etc/openvpn/easy-rsa de manera recursiva

# cp -R /usr/share/doc/openvpn/examples/easy-rsa/2.0 /etc/openvpn/easy-rsa

Editar el archivo vars:
# cd /etc/openvpn/easy-rsa
# nano vars



Es el momento de construir el certificado CA y Root CA certificado, autofirmado:

En criptográfica, una autoridad de certificación (CA) es una entidad que emite certificados digitales. El certificado digital certifica la posesión de una clave pública.

# source ./vars

# ./clean-all

# ./build-ca

El nombre del servidor es server:
root@server:/etc/openvpn/easy-rsa# ./build-key-server server

Una vez tecleado Intro aparecen algunas lineas y sus valores por defecto, preste atencion a:

Common Name server (o el que usted tecleo con anterioridad)

A challenge password? debe dejarlo en blanco

Sign the certificate? y

1 out of 1 certificate requests certified, commint? y

...
CA creation complete and you may now import and sign cert requests.
Your new CA certificate file for publishing is at:
/usr/local/etc/openvpn/easy-ra/pki/ca.crt
...

Acabada la contruccion del servidor, es el momento de crear las claves para los clientes, una por cada dispositivo:

# ./build-key-pass NombreUsuario

Donde NombreUsuario es:
client1, client2, client3, client4, client5, client6, client7, client8, client9

De nuevo más intrucciones

Enter PEM pass phrase Ingrese una contrasena que recuerde

A challenge password? Deje en blanco

Sign the certificate? y

# cd keys

El cifrado des3, un algoritmo de cifrado complejo que se aplica tres veces para cada bloque de datos. OpenSSl un metodo estandar para la crreacion de una conexion segura. Es necesario realizar este paso para cada cliente que configure:

# openssl rsa -in client1.key -des3 -out client1.3des.key

He utilizado el mismo password anterior y las dos veces siguientes.

Enter pass phrase for cliente1.key:
writing RSA key
Enter PEM pass phrase:
Verifying - Enter PEM pass phrase:

Ahora vamos a generar el intercambio de claves Diffie-Hellman. Un intercambio que permite a dos entidades sin conocimiento previo de una, claves secretas a la otra. El cifrado es de 1024-bit que es el valor por defecto, (este valor se establece en el archivo vars, se puede cambiar a 2048-bit).

# cd /etc/openvpn/easy-rsa/
# ./build-dh

Finalmente, vamos a implementar OpenVPN build-in para la proteccion de ataques DoS (Denegacion de Servicio), generando la llave estatica HMAC con el comando siguiente:

# openvpn --genkey --secret keys/ta.key

Falta generar el archivo de configuracion de OpenVPN donde le diremos a OpenVPN, que direccion IP y puerto utilice, donde va a estar conectado, tipo de conexion, etc., utilizando el archivo de configuración de Lauren Orsini y que puede descargar del enlace siguiente. Copie y guárdelo en su servidor local, no tiene formato y funciona perfectamente:

https://gist.github.com/laurenorsini/9925434

Archivo server.conf

# nano /etc/openvpn/server.conf

Hay que activar el reenvio de paquetes IPv4 en el archivo /etc/sysctl.conf descomentando la linea:

net.ipv4.ip_forward=1

Aplicar los cambios sin reiniciar:

# sysctl -p

Raspbian integra un firewall que bloquea las conexiones entrantes de fuentes desconocidas e inesperadas. Queremos seguir protegidos pero necesitamos una regla que permita el tráfico que genera OpenVPN y que recuerde (después de un reinicio) que la conexión OpenVPN siempre esta permitida utilizando un script que se ejecuta en el arranque:

# nano /etc/firewall-openvpn-rules.sh
#!/bin/sh
ipt=/sbin/iptables
#La RPi proporcionará NAT entre OpenVPN cliente subred (10.8.0.0/24) y la soho (small office
#home office) subnet 192.168.1.0/24.
$ipt -t nat -A POSTROUTING -s 10.8.0.0/24 -o eth0 -j SNAT --to-source 192.168.1.130
#utilizado por no-ip (ver README.FIRST)
$ipt -A INPUT -p tcp --dport 8245 -j ACCEPT
#permitir conexiones remotas via SSH.
$ipt -A INPUT -p tcp --dport 22 -j ACCEPT
$ipt -A INPUT -p udp --dport 22 -j ACCEPT
#################

# chmod root /etc/firewall-openvpn-rules.sh
# chmod 0700 /etc/firewall-openvpn-rules.sh
# cd /etc
# sh ./firewall-openvpn-rules.sh
$ sudo iptables -L -n -v


o lo que es lo mismo:



/sbin/iptables -L -n -v

La direccion 10.8.0.0 es la predeterminada de Raspberry Pi para los clientes conectados a la VPN. eth0 es el puerto Ethernet. El archivo creado no tiene permisos de ejecucion y por seguridad solo sera ejecutado por su propietario root.


IP fija y pre-up script firewall:
# cat /etc/network/interfaces
auto lo

iface lo inet loopback
iface eth0 inet static
address 192.168.1.130
netmask 255.255.255.0
gateway 192.168.1.1
pre-up /etc/firewall-openvpn-rules.sh
allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet dhcp

Ya tiene un servidor VPN (OpenVPN) completamente funcional que puede utilizar para conectarse de una manera segura a su red domestica y acceder a archivos compartidos almacenados en su red.

Falta decir a los clientes donde encontrar el servidor, como conectar, etc. Hemos creado diferentes claves de cliente para cada uno de los dispositivos que desea conceder acceso VPN. Para no generar un nuevo archivo de configuracion para cada cliente a partir de cero, vamos a utilizar un ingenioso guion escrito por ERIC JDOIN del instituto SANS. Lo que hara este script, es generar un archivo para cada cliente por nosotros.

Lo primero es crear un archivo de texto en el que los ajustes por defecto se pueden leer, se llamará default.txt y está localizado dentro de keys:

No se confunda yo siempre utilizo minúsculas, por tanto el nombre del archivo al que se hace refencia en el script MakeOpenVPN.sh "default.txt" deberá cambiarlo:

DEFAULT="Default.txt" por
DEFAULT="default.txt"

# nano /etc/openvpn/easy-rsa/keys/default.txt
##########
client
dev tun
proto udp
remote IPPUBLICA 1194
resolv-retry infinite
nobind
persist-key
persist-tun
mute-replay-warnings
ns-cert-type server
key-direction 1
cipher AES-128-CBC
comp-lzo
verb 1
mute 20
#############

su ip pública es información privada que no debería compartir. Si usted no tiene IP pública debera utilizar un servicio de sistema dinámico de nombres de dominio (DDNS) y ejecutar dhclient, (si utilza no-ip no necesita ddclient), en raspberry pi para actualizar su registro DDNS de forma automática.

Un script escrito por Eric Jodoin corriendo desde un archivo shell ejecutable, automatiza las tareas incluidas en este caso. Puede descargarlo desde este enlace proporcionado por Lauren Orsini:

https://gist.github.com/laurenorsini/10013430

# nano /etc/openvpn/easy-rsa/keys/MakeOVPN.sh
copiar, pegar y guardar

Haciendo el script ejecutable solo para root:
# cd /etc/openvpn/easy-rsa/keys/
# chmod 700 MakeOVPN.sh

Por último, ejecute el script:
# ./MakeOVPN.sh

A medida que el script se ejecuta le preguntará el nombre de los clientes existentes para los que generó claves con anterioridad. Si todo ha ido bien debería aparecer una línea como esta:

Done! client1.ovpn Successfully Created.

Repita este paso para cada cliente existente.

Ahora conecte a la raspberry pi, copie los archivos clientes al directorio /home/pi/ y luego transfiera estos archivos a su ordenador vía scp.

# cd /etc/openvpn/easy-rsa/keys
# mkdir /home/pi/openvpn-keys
# cp *.ovpn /home/pi/openvpn-keys/
# ls /home/pi/openvpn-keys/
client1.ovpn  client2.ovpn  client3.ovpn  client4.ovpn



Finalmente envíe un archivo *.ovpn a cada cliente para conectarse a la VPN (OpenVPN).

Android utiliza OpenVPN Connect, los binarios se instalan a traves de OpenVPN Installer:





Un cliente Ipad se conecta utlizando OpenVPNConnect

Conectar remota SSH desde Android con la app ConnectBot:

Unix es genial!.