La wiki de TempWin

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
====== 110.3 Securing data with encryption ======

Pertenece a [[informatica:certificaciones:lpic:lpic-1:110_security|Topic 110: Security]]

  * **Weight**: 4
  * **Description**: The candidate should be able to use public key techniques to secure data and communication.
  * **Key Knowledge Areas**:
    * Perform basic OpenSSH 2 client configuration and usage.
    * Understand the role of OpenSSH 2 server host keys.
    * Perform basic GnuPG configuration, usage and revocation.
    * Use GPG to encrypt, decrypt, sign and verify files.
    * Understand SSH port tunnels (including X11 tunnels).
  * The following is a partial list of the used files, terms and utilities:
    * ''ssh''
    * ''ssh-keygen''
    * ''ssh-agent''
    * ''ssh-add''
    * ''~/.ssh/id_rsa'' and ''id_rsa.pub''
    * ''~/.ssh/id_dsa'' and ''id_dsa.pub''
    * ''~/.ssh/id_ecdsa'' and ''id_ecdsa.pub''
    * ''~/.ssh/id_ed25519'' and ''id_ed25519.pub''
    * ''/etc/ssh/ssh_host_rsa_key'' and ''ssh_host_rsa_key.pub''
    * ''/etc/ssh/ssh_host_dsa_key'' and ''ssh_host_dsa_key.pub''
    * ''/etc/ssh/ssh_host_ecdsa_key'' and ''ssh_host_ecdsa_key.pub''
    * ''/etc/ssh/ssh_host_ed25519_key'' and ''ssh_host_ed25519_key.pub''
    * ''~/.ssh/authorized_keys''
    * ''ssh_known_hosts''
    * ''gpg''
    * ''gpg-agent''
    * ''~/.gnupg/''




===== SSH =====

Linux soporta el acceso remoto a través de varios servidores diferentes, incluyendo Telnet, VNC, e incluso X. Desafortunadamente, la mayoría de estos métodos sufren de un inconveniente importante: **la transferencia de todos los datos a través de la red es no cifrada**.

Esto significa que cualquiera que pueda monitorear el tráfico de red puede arrebatar fácilmente datos sensibles, como las contraseñas. Esto limita la utilidad de estos inicios de sesión remoto, si ponemos en peligro la seguridad del sistema.

**SSH** es la respuesta a esos problemas al realizar conexiones cifradas. SSH permite canalizar a través de su túneles otros servicios y protocolos para asegurarlos.

==== Servidor OpenSSH ====

En Debian, si instalamos el paquete ''ssh'' tendremos tanto el cliente como el servidor.

Configuración del servidor: ''/etc/ssh/sshd_config''

Directivas importantes:

  * ''Protocol'': Los valores posibles son 1 y 2
  * ''Port'': Numero de puerto en el cual se levanta el servicio. Por defecto es el puerto **22**.
  * ''ListenAddress'': por defecto, SSH responde peticiones a través de todas las direcciones presentaes en todas las interfaces de red del sistema. Si solo queremos que sea accedido por una, usamos esta opción (''ListenAddress 192.168.1.254'').
  * ''PermitRootLogin'': si esta opción se establece en ''yes'', permite a OpenSSH aceptar conexiones directas por parte de root.
  * ''X11Forwarding'': Si se desea permitir que los usuarios remotos ejecuten programas X a través de SSH, debe establecer esta opción a ''yes''.
  * ''AllowUsers <usuario1> <usuario2>'': permite especificar qué usuarios podrán acceder por SSH. Podemos limitarlo a accesos desde cierta máquina: ''AlowUsers fulanito@192.168.1.20''

Tras realizar cambios en el fichero de configuración del servicio SSH, debemos reiniciarlo:

  * SysV: ''/etc/init.d/sshd restart'' o ''service sshd restart''
  * Systemd: ''systemctl restart sshd.service''

<WRAP center round info 60%>
Para revisar la configuración del archivo ''/etc/ssh/sshd_config'' podemos ejecutar ''sshd -t''.
</WRAP>

==== Cliente SSH ====

Aparte del servicio OpenSSH, también tenemos el cliente para conectarnos.

Sintaxis:

<code>
ssh usuario:contraseña@<host>
</code>

<WRAP center round info 60%>
El usuario es de la máquina remota, no de la local. Si no lo indicamos, intentará conectarse con el usuario actual, pero si no existe en la máquina remota, dará error.
</WRAP>

Podemos especificar a qué puerto nos conectamos:

<code>
ssh -p 2222 <host>
</code>

Podemos hacer túneles para redirigir puertos:

<code>
ssh -L 80:<host_remoto>:80 <host>
</code>

Por ejemplo:

<code>
ssh -L 80:192.168.0.10:80 usuario@serverssh
</code>

Con el comando anterior nos conectaríamos al puerto 80 del host_remoto a través de la conexión SSH con host y la conexión quedaría establecida en el puerto 80 de nuestro equipo local.

Podemos ejecutar comandos en máquinas remotas:

<code>
ssh <host_remoto> comando
</code>

<WRAP center round info 60%>
Si hemos usado alguna vez el cliente, tendremos un directorio ''.ssh'' en el directorio personal del usuario. Dentro, podemos encontrar el fichero ''known_hosts'' que contendrá las claves públicas de los servidores a los que nos conectamos.
</WRAP>


==== SCP ====

SCP es la implementacion segura de FTP, a través de SSH. Nos permite enviar o descargar ficheros a una máquina remota a través de una conexión ssh

  * Descargar: ''scp user:pass@host_remoto:/ruta/file /ruta/file''
  * Enviar: ''scp /ruta/file user:pass@host_remoto:/ruta/file''

<WRAP center round important 60%>
No es recomendable indicar la contraseña en el propio comando. Lo ideal es no escribirla y que luego nos la pregunte el sistema.
</WRAP>

<code>
scp tempwin@192.168.1.10:/home/tempwin/fichero.txt .
</code>

Si usamos un puerto diferente al 22, lo indicamos con la opción ''-P'':

<code>
scp algo.txt -p -P 52341 usuario@192.168.0.99:/home/usuario
</code>

<WRAP center round tip 60%>
La opción ''-p'' mantiene el tiempo de modificación, acceso y los modos del archivo original.
</WRAP>

==== SFTP ====

Transferir ficheros. Entramos en una sesión como con FTP.

<code>
sftp usuario@servidor
</code>

Especificando un puerto:

<code>
sftp -o Port=54321 usuario@servidor
</code>
==== ssh-keygen ====

Nos permite generar una **key**, haciendo posible una conexión automática sin necesidad de introducir un contraseña:

<code>
ssh-keygen -t rsa
</code>

  * ''-t'': indicamos el algoritmo de cifrado.

<WRAP center round info 60%>
Si queremos indicar un tamaño de clave de cifrado (por defecto es 2048 bits), usamos la opción ''-b'': ''ssh-keygen -t rsa -b 4096''.
</WRAP>

Dicho comando genera un par de claves (pública y privada) dentro del directorio ''$HOME/.ssh'' del usuario donde se ejecutó:

  * ''id_rsa'': clave privada.
  * ''id_rsa.pub'': clave pública.

<WRAP center round info 60%>
El comando anterior también nos pregunta si queremos introducir una contraseña para asegurar la clave
</WRAP>

Debemos copiar la clave pública (contenido de ''id_rsa.pub'') dentro del fichero ''$HOME/.ssh/authorized_keys'' de la maquina remota:

<code>
ssh-copy-id -i ~/.ssh/id_rsa.pub <remote_user>@<remote_host>
</code>

<WRAP center round tip 60%>
También podríamos haber copiado la clave pública con ''scp'', por ejemplo, y luego ''cat /tmp_remoto/id_rsa.pub %%>>%% /$HOME/.ssh/authorized_keys''.
</WRAP>

Así nos conectamos al servidor **sin necesidad de introducir la contraseña**, lo cual no solo es cómodo para el humano sino muy útil para los scripts.

===== GPG =====

**GPG** (//Gnu Privacy Guard//) es un clon libre de **PGP** (//Pretty Good Privacy//).

Implementa los algoritmos de cifrado RSA y DSA.

PGP es objeto de una norma que GPG respeta. Esto significa que las dos implementaciones son compatibles: las llaves generadas por el uno o el otro se pueden intercambiar.

El objetivo de GPG es cifrar una comunicación gracias a un cifrado por claves asimétricas. Una clave permite firmar el texto, otra clave sirve para encriptar el texto.

El cifrado por claves asimétricas utiliza dos claves, una pública y otra privada:

  * **Clave pública**: difundida públicamente, permite al destinatario descifrar el mensaje que usted ha firmado (con la clave privada del destinatario).
  * **Clave privada**: le permite firmar un mensaje. La persona que lo recibe comprueba su firma con la ayuda de la clave pública que usted le ha proporcionado, demostrando así que usted es realmente el autor del mensaje.

==== GPG – Generar claves ====

<code>
gpg --gen-key
</code>

GPG empieza con crear, si no existen ya, el directorio raíz de GPG propio de cada usuario (''$HOME/.gnupg'') y los ficheros que contendrán los elementos gestionados por gpg.

Ejemplo:

<code>
seb@slyserver:~> gpg --gen-key
gpg (GnuPG) 2.0.9; Copyright (C) 2008 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
gpg: directorio ’/home/seb/.gnupg’ creado
gpg: nuevo fichero de configuración ’/home/seb/.gnupg/gpg.conf’ creado
gpg: ADVERTENCIA: las opciones de ’/home/seb/.gnupg/gpg.conf’ aún no están activas esta vez
gpg: la clave ’/home/seb/.gnupg/secring.gpg’ ha sido creada
gpg: la clave ’/home/seb/.gnupg/pubring.gpg’ ha sido creada
</code>

Luego seleccionamos el tipo de clave deseada y el cifrado:

<code>
Seleccione el tipo de clave deseado:
(1) DSA y Elgamal (por defecto)
(2) DSA (firma sola)
(5) RSA (firma sola)
¿Su eleccion? 1
</code>

Luego debe elegir el tamaño, en bits, de la clave que hay que generar. Cuánto más larga es la clave, más complejo es el cifrado (y más difícil de romper). Se puede elegir una clave de 1024 bits por ejemplo:

<code>
El par de claves DSA dará 1024 bits.
las claves ELG pueden tener entre 1024 y 4096 bits de longitud.
¿Qué tamaño de clave desea? (2048) 1024
El tamaño pedido es 1024 bits
</code>

Posteriormente hay que indicar la duración de las claves (0 para duración infinita):

<code>
Especifique cuánto tiempo debería ser válida esta clave.
0 = la clave no expira
<n> = la clave expira en n días
<n>w = la clave expira en n semanas
<n>m = la clave expira en n meses
<n>y = la clave expira en n años
¿La clave es válida para? (0)
La clave no expira.
¿Es correcto? (s/N) s
</code>

Luego habrá que añadir una serie de datos como nombre, email, etc. El email es importante porque va a ser el identificador que utilicemos para utilizar las claves:

<code>
Necesita un nombre de usuario para identificar su clave, el programa lo construye a partir del nombre real, de un comentario y de una dirección de email, de la manera siguiente: «Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>»
Nombre real: Manolito Gafotas
Dirección de e-mail: manolitog@notengomail.com
Comentario: MG
Usted utiliza el juego de caracteres ’utf-8’.
Ha seleccionado este nombre de usuario:
"Manolito Gafotas (MG) <manolitog@notengomail.com>"
Cambiar el (N)ombre, el (C)omentario, el (E)-mail o (O)K/(S)alir ? O
</code>

La **passphrase** se pedirá esta frase a cada envío o recepción de mensaje privado encriptado. También asegura, al menos mientras no la encuentren, una cierta seguridad de la clave privada, incluso si la roban, ya que esta clave no se puede utilizar sin esta passphrase.

<code>
Necesita una frase de contraseña para proteger su clave secreta.
Inserte la frase de contraseña:
Repita la frase de contraseña:
</code>

Se debe generar un gran número de bytes aleatorios. Tendría que hacer otra cosa (teclear, mover el ratón, utilizar discos) durante la generación de los primeros números. Eso da al generador de nombres aleatorios más oportunidad de tener bastante entropía.

Lo recomendable es generar las claves en una máquina con entorno gráfico o puede tardar muchísimo

<code>
gpg: clave 13E021A8 marcada como si tuviera una confianza última.
se ha creado y firmado las claves pública y secreta.
gpg: comprobar la base de confianza
gpg: 3 marginale(s) necesarias, 1 completa(s) necesarias, modelo
de confianza PGP
gpg: profundidad: 0 válida: 1 firmado: 0
confianza: 0-. 0g. 0n. 0m. 0f. 1u
pub 1024D/13E021A8 2009-05-04
Huella de la clave = 6115 DE46 2678 40AB 0AB2 B8B9 1F12 D427 13E0 21A8
uid Manolito Gafotas (MG) <manolitog@notengomail.com>
sub 1024g/BA311C5C 2009-05-04
</code>

Las últimas cuatro líneas resumen toda la información relativa al trabajo efectuado por GPG:

  * **pub**: clave de firma
  * **huella**: es el «fingerprint» que permite determinar la validez de la clave pública, un poco como la suma md5 de cualquier fichero. Es casi imposible (pero no del todo), que claves de gran tamaño tengan una huella idéntica.
  * **uid**: información nominativa (nombre, comentario o alias/seudo, dirección email).
  * **sub**: clave de cifrado

Podemos volver a ver la información anterior con:

<code>
gpg --list-keys
</code>

Más opciones:

  * ''gpg (-k) %%--%%list-key'': lista las claves generadas por GPG
  * ''gpg %%--%%list-sigs'': lista de la firmas con sus claves
  * ''gpg %%--%%keyserver <server> %%--%%recv-keys <ID>'': importar la clave desde un servidor
  * ''gpg %%--%%keyserver <server> %%--%%send-keys'': exportar su clave pública hacia un servidor de claves GPG
  * ''pgp.mit.edu'': key server del MIT
  * ''gpg %%--%%gen-revoke alias'': Revocar la clave (alias es el email usado para generarla).

  * Exportar la clave pública: ''gpg %%--%%output [miclave.gpg] %%--%%armor %%--%%export [ID clave pública]'' (con ''%%--%%armor'' se exporta en formato ASCII, que es lo que se suele usar).
  * Importar una clave pública: ''gpg %%--%%import XXX.gpg''
  * Cifrado simétrico: ''gpg -c <FICHERO>''
  * Para cifrar con clave publica: ''gpg %%--%%output (-o) encrypted-file %%--%%recipient (-r) uid %%--%%armor (-a) %%--%%encrypt (-e) original-file'' (''%%--%%armor'': utilizar formato ASCII)
  * Descifrar: ''gpg %%--%%decrypt (-d) XXX.gpg''

Ejemplo cifrando el fichero ''secreto.png'':

<code>
gpg --output secreto.gpg --recipient manolitog@notengomail.com --armor --encrypt secreto.png''
</code>

Si intentamos abrir el fichero ''secreto.gpg'' veremos algo como:

<code>

</code>

Para descrifrarlo (usamos nuestra clave privada):

<code>
gpg --decrypt secreto.gpg
</code>

==== Firmar ====

  * Firmar con clave privada: ''gpg -u ID %%--%%sign <FICHERO>''
  * Para verificar: ''gpg %%--%%verify <FICHERO>''