Entidad certificadora personal con OpenSSL

Gracias a OpenSSL podemos tener comunicación encriptadas entre diferentes máquinas utilizando criptología asimetrica, es decir, claves públicas y privadas. Además, es posible montar entidades certificadoras que se encarguen de asegurar que una llave pertenece a quien dice pertenecer, de esta forma conseguimos encriptación y autentificación.

Las entidades certificadoras actuales cobrán por el servicio de firma de llaves y no suele ser precisamente asequible. Por otro lado, montar una entidad certificadora oficial también resulta muy costoso ya que se demandan unas ciertas garantias que destrás del negocio hay una cierta seguridad. Por tanto, es habitual que los administradores de pequeñas redes se creen su propios certificados para firmar sus claves. De esta forma podremos disponer de comunicaciones encriptadas sin necesidad de entidades certificadoras.

Estas entidades oficiales pagan para que aparezcan por defecto sus certificados en navegadores como Mozilla Firefox o Internet Explorer. De esta forma el propio navegador puede comprobar automáticamente que cuando se conecta a un sitio seguro, el certificado que recibe ha sido realmente firmado por una entidad oficial. Eso implica que nuestros certificados no serán reconocidos automáticamente por los navegadores a no ser que los añadamos manualmente, el único inconveniente que aporta esto es que el navegador mostrará un aviso extra al usuario (dependiendo de la configuración) advirtiendo que no reconoce la entidad certificadora.

Vamos a ver como configurar OpenSSL para montar nuestro servicio de certificación personal. Lo primero es tener OpenSSL instalado en el sistema (aptitude install openssl), la configuración la encontraremos en “/etc/ssl” y será allí donde editemos el fichero “openssl.cnf”. Os pongo un extracto del archivo con lo más importante:

...

[ ca ]
default_ca  = CA_default

[ CA_default ]
dir     = /etc/ssl/marblestationCA  # Where everything is kept
certs       = $dir/certs  # Where the issued certs are kept
crl_dir     = $dir/crl  # Where the issued crl are kept
database    = $dir/index.txt  # database index file.
new_certs_dir   = $dir/newcerts     # default place for new certs

certificate = $dir/MSca.crt     # The CA certificate
serial      = $dir/serial       # The current serial number
crl     = $dir/crl.pem      # The current CR

private_key = $dir/private/MSca.key # The private key

default_days    = 3650

...

En esta sección del fichero se define donde se va a almacenar toda la información, en mi caso lo guardaré todo en “/etc/ssl/marblestationCA”. Dentro de ese directorio creare toda una serie de subdirectorios que guardaran la información necesaria e imprescindible como por ejemplo el certificado o clave de la entidad (tanto privada como pública). También he puesto que por defecto se generen claves con un periodo de caducidad de 10 años ya que quiero olvidarme de renovar por una buena temporada.

Tendremos que crear la estructura de directorios y ficheros:

mkdir /etc/ssl/marblestationCA/
mkdir /etc/ssl/marblestationCA/certs
mkdir /etc/ssl/marblestationCA/private
mkdir /etc/ssl/marblestationCA/newcerts
mkdir /etc/ssl/marblestationCA/crl
echo "01" > /etc/ssl/marblestationCA/serial
touch /etc/ssl/marblestationCA/index.txt

A continuación crearemos la clave pública/privada de nuestra entidad certificadora:

cd /etc/ssl/marblestationCA/
openssl req -nodes -new -x509 -keyout private/MSca.key -out MSca.crt -days 3650

Es importante especificar el mismo nombre para la clave privada (MSca.key) y pública (MSca.crt) que pusimos en nuestra configuración de OpenSSL. En cuanto a las preguntas que nos haga para generar la clave:

Country Name (2 letter code) [ES]:
State or Province Name (full name) [Catalunya]:
Locality Name (eg, city) []:Tarragona
Organization Name (eg, company) [Marble Station]:
Organizational Unit Name (eg, section) []:Ejemplo
Common Name (eg, YOUR name) []:midominio.com
Email Address []:admin@midominio.com

Cabe destacar que en “Common Name” debemos poner el nombre de dominio correspondiente a la máquina donde estará la entidad certificadora.

Ahora ya tenemos nuestro servicio de certificaciones montado, las claves que hemos generado nos serviran para firmar terceras claves que serán utilizadas por ejemplo por los diferentes ordenadores de nuestra red.

Imaginemos que en el mismo servidor donde hemos montado nuestros certificados para firmar, tenemos un servidor web Apache seguro (SSL) y necesitamos un certificado firmado por nuestra entidad personal. Lo primero que tendremos que hacer será crear una petición de certificado junto a una clave privada:

openssl req -nodes -new -keyout midominio.key -out midominio.csr

Nos volverá a realizar las respectivas preguntas, debemos responder acorde para la máquina donde se va a utilizar la clave. En “midominio.key” tendremos la clave privada generada y en “midominio.csr” la petición de certificado. La entidad certificadora solo necesita acceso al segundo, vamos a generar ahora el certificado firmado por nuestra entidad personal:

openssl ca -out midominio.crt -in midominio.csr

Esto generará el archivo “midominio.crt” con el certificado firmado listo para ser usado por el solicitante. Además se guardará información referente al certificado firmado en “/etc/ssl/marblestationCA/” de forma que siempre tendremos un listado de todo lo que hemos firmado, también podremos revocar firmas (man openssl) en caso de que sea necesario.

Como comenté, ibamos a utilizarlo para nuestro servidor Apache pero también podria ser compartido por otros servicios en la misma máquina, como por ejemplo un servicio de POP3/IMAP (recomiendo dovecot) y SMTP (recomiendo exim). Es importante asegurarnos que estas aplicaciones tengan acceso de lectura al certificado y que el resto de usuarios del sistema no puedan leerlo (sobretodo la llave privada .key).

Habitualmente suelo ubicar los certificados de servicios en /etc/ssl/certs y /etc/ssl/private de la máquina que los vaya a usar:

mv midominio.crt /etc/ssl/certs
mv midominio.key /etc/ssl/private

La petición de certificado midominio.csr no lo vamos a necesitar más puesto que ya hemos generado el certificado.

Ahora podriamos seguir generando nuevos certificados para después firmarlos y repartirlos entre las máquinas de nuestra red que dispongan de servicios con conexión segura.

En resumen, hemos llevado a cabo dos acciones:

1. Generación de los certificados de nuestra entidad certificadora no oficial (clave pública “MSca.crt” y clave privada “MSca.key”), se guardará toda la información en “/etc/ssl/marblestationCA/”
2. Generación de certificados firmados para los servicios o máquinas de nuestra red, se guardará automáticamente la información necesaria en “/etc/ssl/marblestationCA/” y la clave pública/certificado firmado se guardarán en la máquina que los vaya a usar (”/etc/ssl/certs”, “/etc/ssl/private” respectivamente):
   1. Generación de una clave privada (midominio.key) con peticion de certificado (midominio.csr).
   2. Firma de la petición con nuestro certificado de entidad.
   3. El solicitante recibirá su certificado firmado (midominio.crt) que usará en conjunto con su clave privada para su servicio (podremos eliminar la petición midominio.csr).

Autor: marble

SILC: Protocolo de conferencias seguro

SILC es un protocolo libre (y en un futuro standard) que viene acompañado de su respectiva implementación (servidor, clientes, librerias…) y tiene como objetivo permitir la comunicación de forma segura. Su desarrollo se inició en 1997 aunque de forma discontinua, no tomó fuerza hasta el 1999 saliendo la primera versión en el 2000. Su precursor fue el finlandes Pekka Riikonen, especialista informático en el campo de la seguridad.

Podriamos definir SILC como un híbrido entre IRC y la mensajería instantanea ya que hereda funcionalidades de ambas ramas, sin embargo ha sido diseñado desde el inicio pensando en la seguridad. SILC proporciona seguridad a unos niveles superiores a la seguridad que puede ofrecer la combinación de cualquier protocolo no seguro (e.g. IRC, Jabber, MSN Messenger…) junto con tecnologías como TLS/SSL y GnuPG/PGP. El principal motivo que dan en su web es que es muy difícil hacer seguro un protocolo inseguro utilizando un añadido (e.g. SSL) por encima, sin embargo se puede conseguir una seguridad superior si diseñamos desde 0 un protocolo con esas características. Por ejemplo, SSL es ideal para comunicaciones entre 2 máquinas, pero cuando han de intervenir más nodos como por ejemplo ocurriria en un canal (como los del IRC) su funcionamiento no es tan bueno (por ejemplo nadie te asegura que todas las personas han conectado con SSL al servidor).

Continuar llegint SILC: Protocolo de conferencias seguro…

Breve introducción a Iptables

Enllaç a la versió en català

Hoy en dia la seguridad es imprescindible, sobretodo si tenemos una
conexión 24/7. Usar un cortafuegos es una de las primeras
medidas que deberíamos tomar con tal de hacer un poco más
segura nuestra maquina/red.

En este pequeño artículo veremos como se ponen en marcha
las Iptables a fin de cerrar i abrir los puertos según nuestras
necesidades.

Por suerte para nosotros, y a diferencia de algunos sistemas operativos
propietarios (o privativos como dirían algunos), casi todos (al
menos los principales) sistemas operativos href="http://www.gnu.org/philosophy/free-sw.es.html">libres
incorporan de serie algún mecanismo de cortafuegos. Nosotros nos
limitaremos a explicar las Iptables, que es el mecanismo “oficial”
desde la rama 2.4 del kernel de gnu/linux.

La instalación por la parte que respecta al kernel no la
comentaremos en detalle, puesto que todas las distribuciones actuales
las llevan activadas de serie en el nuclio (y si hay alguien que gusta
de compilar sus propios nuclios, seguramente ya sabrá las
opciones a activar. A modo de pista diré: Networking
Options–>IP:
Netfilter Configuration). Por la parte de usuario hay que instalar el
paquete “iptables” (apt-get, emerge, …). Nada más.

Hay gente a la que le gusta hacer servir scripts i aplicaciones
extrañas y esotéricas para configurar Iptables. Nosotros
lo haremos a mano, así de paso veremos como funciona y podremos
comprobar que no es para nada difícil.

Antes de meternos de lleno, daré un enlace sobre los
conocimientos mínimos que hay que tener de Iptables: que es,
lógica de funcionamiento y una base.

href="http://www.netfilter.org/documentation/HOWTO/es/packet-filtering-HOWTO.html">HOWTO
de filtrado de paquetes

Bien, como queremos que las Iptables se pongan en marcha ellas solas al
encender el sistema y que podamos parar y volver a poner en marcha
rapida y sencillamente, usaremos los scripts de init.d. Normalmente
estos se instalan solos al instalar el paquete “iptables” (el script
debería estar en /etc/init.d/iptables, o dondequiera que
tengáis el directorio init.d en vuestra distribución). En
caso de no existir dicho script, podéis encontrar uno de ejemplo
aquí.

Ahora hay que asegurarse de que el script se lanzará al encender
el sistema de la siguiente forma (si es que no lo había hecho
vuestro instalador de paquetes al instalar el paquete “iptables”):

En Debian sería un cosa así:update-rc.d iptables defaults

Mientras que en Gentoo sería:rc-update add iptables default

Si no tenéis ninguna de estas dos utilidades, simepre lo podéis hacer a mano de la forma tradicional:

  1) mirar que runlevel es el que ejecutamos con el siguiente comando:    runlevel

  2) ir al directorio del runlevel en cuestión:    cd /etc/rcX.d    o en algunas distribuciones:    cd /etc/init.d/rcX.d    substituyendo la  “X” de “rcX.d” por el número de runlevel que nos ha dado el comando del punto 1

  3) crear el enlace sombólico apropiado:    ln -s /etc/init.d/iptables S20iptables

Una vez instalado, configurado y listo para usar, nos aseguraremos que
no hay ninguna regla de Iptables cargada:

iptables -F

Y procederemos a añadir nuestras reglas (aquí pongo un
ejemplo básico):

iptables -A INPUT -i lo -s 127.0.0.0/8 -j ACCEPTiptables -A INPUT -i eth0 -p TCP –dport 22 -m state –state NEW -j ACCEPTiptables -A INPUT -i eth0 -m state –state RELATED,ESTABLISHED -j ACCEPTiptables -A INPUT -p icmp -j ACCEPTiptables -A INPUT -j DROP

La primera línea sirve para que se permitan las conexiones de la máquina consigo misma mediante la interfaz de red de loopback.La segunda línea, indica que queremos abrir el puerto 22. Esto es a modo de ejemplo. Deberíamos substituir el “22″ por el número del puerto que queramos abrir. Repetir esta línea con todos los puertos que se desee abrir. Hay que tener en cuenta, que es posible indicar rangos de puertos en el siguiente formato: inicio-fin. Por ejemplo, si indicaramos 22-80 en el número de puerto, estaríamos diciendo que queremos abrir todos los puertos entre el 22 y el 80, ambos incluídos. Hay que cambiar eth0 por el dispositivo adecuado

La tercera línea permite que las conexiones que establezcamos hacia el exterior puedan entrar. Hay que cambiar eth0 por eldispositivo adecuado. Sin esta línea no nos volvería ningún paquete (no lo dejaríamos entrar).

La cuarta línea permite que entren los paquetes ICMP (principalmente pings).

La última línea impide que entre cualquier otra cosa.

Si tenéis reglas propias (prerouting, postrouting, …) metedlas
donde convenga en el orden adecuado, teniendo presente que primero
permitimos y con la última línea impedimos el resto de
conexiones. Al hacerlo de esta manera nos aseguramos de no dejarnos
nada abierto; lo que no hayamos permitido explicitamente no
podrá entrar.

Finalmente, para conseguir que estas reglas se activen automaticamente
al encender el sistema, haremos lo siguiente:

Primero nos aseguraremos de tener el directorio de destino /var/lib/iptables, y si hiciera falta lo crearíamos:
mkdir /var/lib/iptables

Y a continuación hacemos un:
/etc/init.d/iptables save active

Y para cuando queramos pararlas hay dos opciones a saber:

a) Que al parar las Iptables via “/etc/init.d/iptables stop” dejemos el
cortafuegos sin ninguna regla (todo abierto):

iptables -F/etc/init.d/iptables save inactive

b) O que dejemos solo la regla que impide todas las conexiones
entrantes (todo cerrado):

iptables -Fiptables -A INPUT -j DROP/etc/init.d/iptables save inactive

Una vez hecho esto, encontraremos en /var/lib/iptables dos
ficheros: “active” y “inactive”, que podremos modificar posteriormente
para modificar/quitar/añadir reglas a cualquiera de los dos
estados (active
cuando hacemos el start e inactive cuando hacemos el stop).

Para finalizar haremos un:

iptables -F/etc/init.d/iptables restart

Y ya las tendremos funcionando. Convendría asegurar-nos de su
funcionamiento con herramientas tales como el href="http://www.insecure.org/nmap/">nmap (si no las sabeis hacer
funcionar siempre podéis preguntar a vuestro man o a google.
Autor: sergi

Breu introducció a Iptables

Enlace a la versión en castellano



Avui en dia la seguretat és gairebé imprescindible, sobretot si tenim una connexió 24/7. Fer servir un tallafocs és una de les primeres passes que hauríem de fer per tal de començar a fer una mica més segura la nostra màquina/xarxa.



En aquest breu article veurem com es posen en marxa les Iptables per tal de tancar i obrir els ports segons les nostres necessitats.



Per sort per a nosaltres, i a diferència d’alguns sistemes operatius propietaris, gairebé tots (al menys els principals) els sistemes operatius lliures porten de sèrie algun mecanisme de tallafocs. Nosaltres ens limitarem a explicar les Iptables, que és el mecanisme “oficial” des de la branca 2.4 del nucli.



La instal·lació per la banda del kernel no la comentarem massa, donat que gairebé totes les distribucions actuals ho porten de sèrie al nucli (i si algú es compila els nuclis ell mateix segurament ja sabrà quines opcions activar. Pista: Networking Options–>IP: Netfilter Configuration).
Per la banda d’usuari cal baixar el paquet “iptables” (apt-get, emerge, …). Res més.



Aquí hi ha gent que li agrada fer servir scripts i aplicacions estranyes i mig esotèriques per a configurar les Iptables. Nosaltres, per començar ho farem a mà. Així de passada veurem una mica com funciona.



Abans de ficar-nos de cap, donaré un enllaç sobre els coneixements mínims que cal tindre d’Iptables: que és, lògica de funcionament i base.



HOWTO de filtrat de paquets



Bé, com que volem que les Iptables s’engeguin soletes a l’encendre el sistema i les puguem aturar i engegar ràpidament, farem servir els scripts d’init.d. Normalment aquests s’instal·len sols al instal·lar el paquet d’iptables (l’script hauria d’estar a /etc/init.d/iptables o, si la vostra distribució té el directori init.d a un altre lloc, a aquest altre lloc). En cas de no ser així, en podeu trobar un exemple aquí.



Ara cal assegurar-nos que l’script s’engegarà al iniciar el sistema amb la següent ordre (si no ho teníeu fet automàticament per la vostra distribució a l’instal·lar el paquet):

A Debian seria un cosa així:
update-rc.d iptables defaults

Mentre que a Gentoo seria:
rc-update add iptables default

Si no teniu cap d'aquestes dos utilitats, sempre ho podeu fer a mà a la manera tradicional:
  1) mirar quin runlevel és el que executem amb la següent comanda:
    runlevel

  2) anar al directori del runlevel:
    cd /etc/rcX.d
    o a algunes altres distribucions:
    cd /etc/init.d/rcX.d
    substituint la  "X" de "rcX.d" el número de runlevel que ens ha dit la comanda del punt 1

  3) crear l'enllaç simbòlic adequat:
    ln -s /etc/init.d/iptables S20iptables

Un cop instalat, configurat i a punt, ens assegurarem que no hi ha cap regla d’iptables molestant:

iptables -F

I procedirem a afegir les nostres regles (aquí dono un exemple bàsic):

iptables -A INPUT -i lo -s 127.0.0.0/8 -j ACCEPT
iptables -A INPUT -i eth0 -p TCP --dport 22 -m state --state NEW -j ACCEPT
iptables -A INPUT -i eth0 -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -A INPUT -p icmp -j ACCEPT
iptables -A INPUT -j DROP

La primera línia ens indica que volem que es puguin establir connexions amb un mateix, via l'interfície de loopback.

La línia de --dport 22, indica que el port 22 en aquest cas volem que estigui obert. Justament desprès de la primera línia haurem d'afegir tantes com vulguem amb la mateixa forma i canviant el 22 pel port que vulguem deixar obert. També es poden enumerar rangs amb el format inici-fi (exemple: el rang "22-80" serien tots els ports entre el 22 i el 80, ambdós inclosos).Cal canviar eth0 pel dispositiu adequat.

La tercera línia permet que les connexions que nosaltres establim cap a l’exterior tinguin permís per entrar. Cal canviar eth0 pel dispositiu adequat. Sense aquesta línia no ens retornaria cap paquet (no el deixaríem entrar).

La quarta línia permet que entrin els paquets ICMP (principalment pings).

La darrera línia impedeix que entri qualsevol altra cosa.

Si teniu regles pròpies (prerouting, postrouting, …), fiqueu-les on convingui en l’ordre adequat, tenint en compte que primer permetem unes quantes coses i amb la darrera línia impedim tota la resta. Així permetent explícitament ens estalviem maldecaps per haver-nos deixat quelcom obert.



Finalment, per tal d’aconseguir que aquestes regles s’activin automàticament a l’engegar el sistema, farem el següent:

Primer ens assegurarem que tenim el directori destí /var/lib/iptables, i si fes falta el crearíem:
mkdir /var/lib/iptables

I a continuació fem un:
/etc/init.d/iptables save active

I per a quan vulguem parar-les hi ha dues possibilitats a saver:

a) Que al parar les iptables via “/etc/init.d/iptables stop” deixem el tallafocs sense cap regla:

iptables -F
/etc/init.d/iptables save inactive

b) O que deixem només la regla que impedeix totes les connexions entrants:

iptables -F
iptables -A INPUT -j DROP
/etc/init.d/iptables save inactive

Un cop fet això, trobarem a /var/lib/iptables dos fitxers: “active” i “inactive”, que podrem modificar posteriorment per a modificar/treure/afegir regles a qualsevol dels dos estats (active quan fem un start i inactive al fer l’stop).



Per finalitzar fem un:

iptables -F
/etc/init.d/iptables start

I ja les tindrem funcionant.
Convindria assegurar-nos del seu funcionament amb eines tals com l’nmap (si no les sabeu fer anar, sempre us podeu passar pel servidor irc.freenode.org, canal #gplurv i demanar que us facin un escaneig).
Autor: sergi

Explore2Fs - Explorar el sistema de fitxers des de Win32

Moltes vegades ha aparegut la necessitat d’accedir a les particions (ext2 o ext3) del vostre sistema Linux des de un altre sistema operatiu instal·lat a la vostra màquina, ja sigui per raons de comoditat o per rescatar els fitxers importants després d’adonar-vos que no hi ha forma de carregar el kernel o simplement que el sistema de fitxers no es pot muntar per alguna raó. Fa poc temps un amic em va recomanar aquest software gratuit que ens permet des de Win32 accedir en mode lectura a les particions del Linux i rescatar els fitxers. Es diu Explore2Fs i el podeu descarregar a http://uranus.it.swin.edu.au/~jn/linux/.

Aquest software moltes vegades s’utilitza també per rescatar el /etc/shadow i un cop té el fitxer a un diskette, amb calma (i segurament a casa seva) aplicar un mecanisme de força bruta per coneixer la password de root o d’un altra usuari (John The Ripper). La técnica més habitual és executar-lo des de un diskette amb un arranc des de cd-live de Win32, o sigui que pareu compte amb la seguretat física, moltes vegades descuidada a canvi de la seguretat remota.

GNU/Linux

Autor: cdelphi96