Hola compañeros ya es tiempo sin escribir ni nada, pero siempre os leo en las sombras 

No sé si se habrá preguntado antes pero estoy aquí para proponer la idea de lanzar una revista ¿mensual? donde usuarios del foro compartan sus conocimientos en distintas secciones.

La revista se organizaría en secciones, el contenido de las mismas tendrá que hacer referencia al título de los subforos de este foro. Así quedaría una sección para Seguridad, Bugs/Exploits, Análisis de Malware, Programación (todos los lenguajes), Win/Linux, Crypto etc

Los usuarios no tendrían porque ser parte del staff, aquellos usuarios que no formen parte podrían aplicar para escribir un artículo. Se acordarían unas pautas de redacción y presentación como: fuente y tamaño, márgenes y demás.

No me enrollo más porque no se si gustará, tengo más ideas para este proyecto pero primero he de saber si la gente será capaz de aportar.

Make elhacker great again.

Saludos !

S.P.O.K

Versión Actual: v1.0.4

Simple Production Of Keys es una herramienta de cracking de contraseñas la cual implementa un algoritmo altamente eficiente para la generación de diccionarios de palabras formadas a partir de un alfabeto personalizable. La tool ha sido codeada en C++11 en GNU/Linux Fedora 24 x86_64, pero es multiplataforma.

ANTES DE NADA: Recomiendo leer el paper de mi investigación sobre este ámbito, ya que podreís encontrar ideas muy positivas y vanguardistas a parte de ver las entrañas de mi herramienta como son: las definiciones matemáticas, implementación y diseño, benchmark, coste operacional, escenarios de cracking, ahorro y comparativas con métodos tradicionales. Os invito a meteros en mi cabeza por unos minutos (El paper está en Inglés y consta de 16 páginas).

Una vez invitados a leer el paper, si aún no lo habeís leído, el método de S.P.O.K ahorra un 6% comparado con el método tradicional de generación de palabras de longitud i,j generándo todas las palabras entre i y j usando sólo las de longitud j. En la sección de ideas futuras un metodo del 94% de ahorro es comentado. La versión Release en este mismo momento genera 2.5 mil millones de palabras por minuto en mi pc al escribir en fichero.

Ahora veremos que funcionalidades aporta la herramienta:

- Modo Verbose para imprimir el total de palabras por minuto, segundo y el tamaño escrito sobre el tamaño final del diccionario (ver fórmulas matemáticas en el paper).

- Modo de generación de palabras escritas a un diccionario. Por defecto genera todas las palabras de longitud 1 hasta 5 (utilizando sólo las palabras de longitud 5 (ver paper)). Si no se especifica se imprimen las words por pantalla (para uso de pipe por ejemplo).

- Modo customizable de alfabeto. Por defecto es abcdefghijklmnopqrstuvwxyz.

- Modo customizable de intervalo de generación de palabras. Permite especificar la longitud i,j de las palabras a generar utilizando sólo las palabras de máxima longitud.

- Modo de hasheado de palabras escritas a un diccionario. Si se especifica este parámetro y el modo verbose esta presente, se utilizará la fórmula matemática correspondiente para calcular el tamaño del diccionario. La herramienta permite hashear cada palabra con 1, 2 o 3 primitivas siendo estas: MD5, SHA-1 y SHA-256.

- Modo de guardado y carga de sesiones. Esta joyita os permite cerrar la herramienta durante su ejecucción sin preocupaciones guardando todo el input especificado y la última palabra generada. Al volverla abrir se retomará el progreso anterior. Tampoco generará palabras repetidas que ya hayan sido guardadas (ver paper).

Si después de emplear la herramienta o leer el paper quereís colaborar escribid aquí. También para reportar bugs: kub0x@elhacker.net

Cualquier duda sobre uso -> leer el paper ya que tiene su propia sección de uso aunque la misma herramienta incluye un apartado de help al no introducir ningún parametro.

Link al PAPER -> https://github.com/FreeJaus/gea-PRISM/blob/master/Research/spok_v.1.0.3.pdf (falta upgradear a 1.0.4, coming soon)
Link al SOURCE -> https://github.com/FreeJaus/gea-PRISM/tree/master/Programming/SPOK
Link descarga PROYECTO+SOURCES+EJECUTABLE GNU/LINUX -> https://github.com/FreeJaus/gea-PRISM/releases/tag/v.1.0.4

USUARIOS DE WINDOWS: Lo he compilado satisfactoriamente en 32bit pero al ser incapaz de encontrar las librerías y .lib de OpenSSL para x64, la versión para Windows tendrá que esperar.

Linkar con librerías: libssl, libcrypto, libpthread (En Linux). En Windows con las de OpenSSL bastaría.

Saludos, disfrutadlo y sed buenos

Buenas,

el título lo dice todo. Va a hacer tres años desde que compre los componentes para mi PC, y hoy, pensándolo bien decidí instalar la update del firwmare para UEFI del fabricante. Para sorpresa al arrancar el PC tras la update me dice que "CPU is not in CPU supported list".

Por lo tanto busqué si mi CPU es soportada por el fabricante y por sorpresa, en la página oficial no es listada, pero entonces, ¿por qué con la versión del firmware por defecto es soportada y con la nueva actualización no?.

Motherboard: Asrock Pro 970 r2.0 versión firmware UEFI 2.80 (tras actualizar, esta versión es la que da problemas en la CPU). La versión inicial del firwmare era 1.80 creo recordar y con la misma funcionaba de maravilla.
CPU: AMD FX-9370.

Probraré a flashear con la versión 2.60 ya que la 1.80 no la encuentro en la página oficial. Me gustaría al menos saber por que una version mas moderna del firmware no soporta mi CPU y una más antigua si lo hace.

EDIT: Ando sin suerte, probando la 2.60 sigue saliendo el mismo mensaje de que no soporta mi CPU. He creado un post en el foro técnico de Asrock para ver si alguien puede facilitarme la versión original del firmware que venía al comprar la motherboard, la versión 1.80, ya que realmente necesito hacer un rollback   El link al post en cuestión es: http://forum.asrock.com/forum_posts.asp?TID=4604&PID=25124&#25124

EDIT2: Bueno buscando di con este enlace a la v1.80 y flasheando el firmware he tenido suerte y todo ha vuelto a la normalidad (http://drivers.softpedia.com/get/BIOS/Asrock/ASRock-970-Pro3-R20-BIOS-180.shtml). Ahora, la cuestión sigue en pie, porque deja mi CPU no soportada al actualizar a las versiones más modernas, mi entendimiento sobre firmware y low level me dice que el código del microcontrolador de UEFI ha cambiado no pudiendo comunicarse/reconocer la CPU. Seguiré probando versiones más modernas ya que los que me conocen saben que antepongo la seguridad ante cualquier otra cosa.

Saludos!

Hola compañeros, hace tiempo que no creo un post tratando mis inquietudes y me gustaría que me intentaraís ayudar:

Hace ya unos años me picó el gusano de la matemática, a partir de estudiar a fondo las ramas de la criptografía que mas interés me generan, ya que si quieres crear contenido primero has de entenderlo, cuestionarlo, trabajarlo y conectarlo con tu pensamiento. Por muchas herramientas que te den es imposible que construyas una casa el primer día.

Muchas veces al estar contemplando los teoremas y métodos matemáticos de un campo concreto me sorprendo a mi mismo debatiendo internamente sobre el origen de los mismos y el por que de su existencia, a esto lo conocemos como Metamatemática, donde se discuten dichos axiomas y su aplicación en el mundo real, científico pero también ideal. Es la clave que a la mayoría de los estudiantes o amateurs les falta por analizar, ya que es donde más se afianza el conocimiento, pero bueno el tema de enseñarnos como a máquinas (aprendete esto y lo otro) iría en otro post y tampoco me interesa debatir aquí sobre el criterio académico-social (total todo seguirá igual y nosotros cada vez más viejos ).

Últimamente leo bastante material académico para afianzar mis bases y poder progresar sin tener que estar un mes con un problema, pero me gustaría también incluir la Metamatemática en mis lecturas y quisiera preguntaros si conoceís autores tanto contemporáneos y antiguos que en sus obras discuta el por que de los métodos y su conexión con la naturaleza y la "realidad". Al ser posible incluir la obra que más os llame la atención. Conozco varias decenas de autores pero me interesaría leer vuestras recomendaciones.

Gracias por vuestra atención y un saludo!

Buenas tardes compañeros,

llevo cosa de un año usando Fedora como OS principal, aunque tuve experiencias previas con otras distros, esta es la que más se ajusta a mis necesidades (por el momento).

Me gustaría saber que suites de seguridad u aplicaciones son las más utilizadas para esta temática (HIPS, IDS, AVs, Firewalls, anti-rootkits etc).

En Fedora 24 ahora mismo cuento con SELinux que por lo que veo es como un HIPS ya que monitorea ciertos recursos del sistema y previene en caso de mal funcionamiento o de compromiso, vi que también cumple la opción de Firewall.
Para rootkits cuento con RootkitHunter y chkrootkit. No tengo AV, no creo que sea necesario en Linux algo así al menos en mi caso ya que no descargo nada raro y si me explotan el navegador u otro servicio el AV no serviría de nada.

En Windows solía utilizar la suite de COMODO ya que tenía AV+FW+HIPS+Sandbox+CloudScan.

Saludos!

Buenas.

Hoy os traigo uno de los pilares matemáticos más impresionantes descubierto múltiples veces en la historia. Se le atribuye al gran Sun Tzu, es por eso que lo suelen nombrar Chinese Remainder Theorem (Teorema del resto chino), aunque otras culturas lo reinventaran con otro enunciado diferente ( para los amantes de la historia revisad: http://www.math.harvard.edu/~knill/crt/lib/Kangsheng.pdf )

¿De que trata este teorema? El siguiente planteamiento del mismo no difiere del planteamiento ancestral descrito por aquellas intrigantes culturas:

¿Cómo podemos hallar el número X que al dividir por 3 nos deja resto 2, al dividir por 5 nos deja resto 3 y al dividir por 7 nos deja resto 2? Simple, ¿verdad?. Es como si hubiera repartido una serie de objetos entre varias personas y hubiera olvidado la cantidad de objetos y solo me acuerdo de a cuantas personas he repartido y el resto de dichas operaciones.

El gran Grauss formalizó los teoremas de Euler, Lagrange, Fermat y Legendre entre tantos, formalizando de esta forma la aritmética modular en su obra maestra Disquisitiones Arithmeticae (si teneís una biblioteca en la uni corred a leerlo), y cómo no, no pudo dejar pasar la ocasión de plantear este mismo teorema, en su caso con calendarios y ciclos lunares.

Explicado el planteamiento, empecemos a adentrarnos en las profundidades matemáticas (ojalá algún día pongan LateX en este foro ... )

ATENCIÓN: Tanto la explicación algebraíca general como el ejemplo posterior son fruto de mi conocimiento y práctica, pudiendo haber mínimas diferencias con el proceso estándar/general.

Primero definamos lo que es una relación de congruencia:

lo expresamos como "3 es congruente a 7 módulo 4" porque "(4*1)+3=7" y porque "4 divide a 7-3".
"4 divide a 11-3" además "4*2 + 3 = 11"

De forma general tenemos:

, su expresión en forma de ecuación sería "a = n*k + b", además "n | a-b" es decir "a-b es el múltiplo k de n". Si "a" es divisible entre "n" tendríamos

Si no entendiste la parte anterior, tranquilo, revisa este tema https://en.wikipedia.org/wiki/Modular_arithmetic y vuelve cuando quieras.

Por lo tanto el CRT se basa en resolver el siguiente sistema de congruencias:

Dada una coleción de pares (a_i, n_i) tal que a_i < n_i donde a_i es el residuo y n_i el módulo de cada congruencia,

hallar x tal que:




...


Es decir, x dejará residuo al dividir por , residuo  al dividir por etc.

Para que este sistema tenga solución, los módulos desde hasta deben de ser coprimos es decir gcd(n₁...n_i)=1. En cristiano, ninguno de los módulos puede estar compuesto por factores primos de otro módulo.

Si la coprimalidad se cumple, entonces expresaremos el módulo total como:



y aplicamos la siguiente fórmula:

Donde y denota la multiplicativa modular inversa,

Si lo reescribimos tenemos:



Una vez calculadas y almacenadas en "q" las sucesivas iteraciones, obtenemos el residuo de nuestro nuevo sistema de la siguiente forma:

por lo tanto nuestra solucion al sistema final quedaría:



Ejemplo:




Primero probamos que los módulos son coprimos entre sí. Para ello comprobamos que gcd(3,5)=1 gcd(3,7)=1 gcd(5,7)=1.
Ahora calculamos el módulo total o variable multiplicativa del módulo:



y aplicamos la fórmula arriba descrita paso por paso:



Empezamos por k=1, por lo tanto tenemos:


=> para ello calculamos "t₁" mediante la multiplicativa modular inversa de N₁ en n₁, , a través de euler por lo tanto t₁=2. Si hacemos 1=35*2 (mod 3) se satisface la relación.

Ahora multiplicamos a1*N1*t1 y lo dejamos en q:

q = 2*35*2 = 140

Sigamos

i=1

a₂ = 3
n₂ = 5
N₂ = N / n₂ = 105 / 5 = 21
[(N₂)^-1]_n2 -> Resolvemos t₂ para hallar la mult. inv. mod. 1=21*t₂ (mod 5) de la siguiente forma: t₂ = 21^phi(5)-1 (mod 5), que equivale a t₂ = 21³ (mod 5), por lo tanto t₂=1.

y sumamos en q:

q = q + a₂*N₂*t₂ = q + 63 = 140 + 63 = 203

Última iteración

i = 2

a₃ = 2
n₃ = 7
N₃ = N / n₃ = 105 / 7 = 15
[(N₃)^-1]_n3 -> Resolvemos t₃ para hallar la mult. inv. mod. 1=15*t₃ (mod 7) de la siguiente forma: t₃ = 15^phi(7)-1 (mod 7), que equivale a t₃ = 15⁵ (mod 7), por lo tanto t₃=1.

y sumamos en q:

q = q + a₃*N₃*t₃ = q + 30 = 203 + 30 = 233

Ahora falta el último paso para obtener la solución al sistema inicial:

Para ello computamos:

u = q (mod N)

u = 233 (mod 105)

u = 23

y la solución al sistema inicial sería:

x = u (mod N)

x = 23 (mod 105)

Para comprobar que la solución es fidedigna sustituimos x por 23 en el sistema inicial:

2 = 23 (mod 3)
3 = 23 (mod 5)
2 = 23 (mod 7)

Y como vemos se satisfacen las congruencias en su totalidad. Otras soluciones para X serían x = 105*k + 23 -> {23, 128, 233...}

Cosas a tener en cuenta:

En la vida real las multiplicativas modulares inversas se computan mediante el Extended Euclidean y no cómo yo he hecho en mi ejemplo, ya que necesitas la factorización de cada módulo mediante el procedimiento de Euler.

CONCEPTOS A TENER EN CUENTA:

https://en.wikipedia.org/wiki/Congruence_relation
https://en.wikipedia.org/wiki/Modular_multiplicative_inverse
https://en.wikipedia.org/wiki/Modulo_operation
https://en.wikipedia.org/wiki/Euler's_totient_function
https://en.wikipedia.org/wiki/Chinese_remainder_theorem
https://en.wikipedia.org/wiki/Pairwise_coprime
https://en.wikipedia.org/wiki/Disquisitiones_Arithmeticae
https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm#Computing_multiplicative_inverses_in_modular_structures

He implementado una función en C# la cual dadas dos listas que representan un sistema de congruencias, una de residuos y otra de módulos, devuelve una lista donde el primer elemento es X y el segundo elemento es N = n₁*n₂*..*n_i. La multiplicativa inversa modular se computa de forma iterativa sin el Extended Euclidean, ya que "a_i*t_i" dejarán un múltiplo "k_i" de "n_i" pequeño.

private static BigInteger MultInv(BigInteger a, BigInteger b)
        {
            BigInteger inv = BigInteger.Zero, rem = BigInteger.Zero;
            BigInteger i = BigInteger.One;
            bool found = false;
            while (!found)
            {
                inv = BigInteger.DivRem(BigInteger.Add(BigInteger.Multiply(b, i), BigInteger.One), a, out rem);
                if (rem == BigInteger.Zero)
                    found = true;
                i++;
            }
            return inv;
        }
 
        private static List<BigInteger> ChineseRT(List<BigInteger> residues, List<BigInteger> modules)
        {
            List<BigInteger> sol = new List<BigInteger>(2);
            BigInteger N = BigInteger.One, ai = BigInteger.Zero, Ni = BigInteger.Zero, res = BigInteger.Zero;
            foreach (BigInteger m in modules)
                N = BigInteger.Multiply(N, m);
            for (int i = 0; i < modules.Count; i++)
            {
                ai = residues[i];
                Ni = BigInteger.Divide(N,modules[i]);
                res += BigInteger.Multiply(BigInteger.Multiply(ai, Ni), MultInv(Ni, modules[i]));
            }
            res = BigInteger.Remainder(res, N);
            sol.Add(res);
            sol.Add(N);
            return sol;
        }
 
        static void Main(string[] args)
        {
            List<BigInteger> residues = new List<BigInteger>();
            List<BigInteger> modules = new List<BigInteger>();
            residues.Add(2); residues.Add(3); residues.Add(2);
            modules.Add(3); modules.Add(5); modules.Add(7);
            List<BigInteger> sol = ChineseRT(residues, modules);
        }

EDIT: Seguiré adaptándolo a LateX.

Saludos!

Buenas gente,

siempre ha sido tedioso escribir notación matemática en este foro, y apuesto a que no soy el único que lo sufre, seguro que muchos de vosotros sufristeís o lo seguís haciendo. No tengo constancia de si esto se ha debatido anteriormente, pero me gustaría lanzar la siguiente propuesta:

¿Podría integrarse un plugin para LateX? Así como teneís GeSHi para representar múltiples lenguajes de marcado/programación/scripting, seguro que hay un plugin para LateX en SMF que solucione el tema. Otra cosa es que sea trivial ponerlo.

Espero vuestros comentarios.

Saludos!

Buenas tardes foreros,

esta consulta va hacia mis compañeros del Staff de elhacker.net pero publico aquí para que otros usuarios, si lo desean, comenten.

A media tarde he cambiado mi avatar por los dos grandes del flamenco, he subido la foto a imgur.com, donde ellos usan HTTPS y para mi sorpresa no he podido realizar dicho cambio de  avatar a través de HTTPS por lo que he tenido que especificar HTTP, probadlo por vosotros mismos https://i.imgur.com/uDpxu8H.jpg

El tema es que sale un warning en el candado de la versión HTTPS del foro lo cual nos indica que hay contenido "no seguro" concretamente contenido que viaja a través de HTTP (la imagen del avatar) y no me gusta nada ver como algo va en plano, los que me conocen saben por que.

Espero respuestas y como no, solución, HTTPS no vale de nada si hay un mixed content

Saludos!

Buenas a todos, especialmente a drvy  

Tengo un campo con primary key con el charset utf8_spanish_ci y el problema es que al ser case insensitive no distingue 'A' de 'a' por lo tanto no crea entradas si la upper o la lowercase ya existen. He visto que se arregla con el collate, pero cree la DB con phpMyAdmin porque mi tiempo es oro y la DB es algo trivial.

Agradecería cualquier tipo de ayuda, básicamente quiero algo case sensitive para solventar el problema con la clave primaria.

Os dejo un extracto del code SQL:

  `WORD` VARCHAR(30) CHARACTER SET utf8 COLLATE utf8_spanish_ci NOT NULL DEFAULT '',

Saludos.

Muy buenas a todos, sé que hace tiempo que no entro al foro pero sigo leyendo todo cada día desde modo invitado.

Hoy os traigo lo mejor de lo mejor, hace algo más de una semana, LetsEncrypt, una iniciativa de la EFF (Electronic Frontier Foundation), anunció su nueva herramienta la cual promueve el uso e instalación de certificados de forma gratuita. Bueno, ya en las charlas de mi git hablé de ello, pero todavía estaban en pañales y bueno ahora está en beta.

Haré una breve introducción del porque es una gran iniciativa que realmente está orientando el control de internet hacia nosotros, los usuarios, ya que la privacidad ahora está de nuestra parte.

INTRODUCCIÓN:

HTTPS se basa en la utilización de PKI + SSL/TLS. A través de estos estándares podemos garantizar la integridad, confiabilidad y la autenticidad de la conexión pertinente, gracias a la criptografía de clave pública y a los certificados X509v3. No os quiero aburrir con tecnicismos, podeís pedirme si quereis un tutorial extendido sobre criptografía asimétrica, TLS, PKI y certificados.

Cuando uno se conecta a una Web mediante HTTPS se realiza una negociación de claves para establecer una conexión segura, uno de los pasos de esta negociación tiene que ver con el certificado. Éste sólo es válido si ha sido firmado por una entidad certificadora (CA), y estas entidades obviamente cobran por certificado emitido, y sí, son cantidad muchas veces desorbitadas.

Gracias a la iniciativa LetsEncrypt podemos obtener un certificado de manera gratuita. ¿Pero, el certificado ya será válido? Sí, al 100%, puesto que el mismo es firmado por una CA de confianza (IdenTrust CA). ¿Y no pierden dinero las otras CA (competencia)? Sí, pero dar este paso era fundamental para retomar el control sobre nuestra privacidad.

Resumiendo, lo que quiero que entendaís es que podeís proteger el tráfico de vuestras Webs personales de ataques Man-In-The-Middle (MITM) sin gastar vuestro dinero en certificados costosos que para colmo hay que pagar por cada renovación del mismo. Esto supone una gran patada al gran hermano amigos.

INSTALACIÓN

Primero, remarcar que la herramienta sólo es empleable por ahora en GNU/Linux, preveen portarla pronto a Windows, pero como bien dije todavía están en Beta.

Para los interesados estoy utilizando CentOs. Abrid vuestra terminal, situaros en el directorio que queraís, descargadla mediante el cliente de git de la siguiente forma y acto seguido corred el cliente letsencrypt-auto para que instale las dependencias auxiliares necesarias (OJO: necesitareís permisos de root):

$ git clone https://github.com/letsencrypt/letsencrypt
$ cd letsencrypt
$ ./letsencrypt-auto

Si no podeis correr el cliente letsencrypt-auto probad a ejecutarlo de la siguiente forma:

$ ./letsencrypt-auto --debug (esto sucede con versiones de Python obsoletas/antiguas.)

USO DE LA HERRAMIENTA

Aquí os explicare el método manual, el cual consiste en generar un par de claves pública/privada además del CSR. El CSR (Certificate Signing Request) es el archivo que contiene la información de nuestra entidad, dominios a proteger, algoritmos de firma digital y nuestra clave pública, que será enviado mediante el cliente de LetsEncrypt a su entidad certificadora (CA) para que nos lo firme y nos devuelva un certificado SSL/TLS.

Existen métodos automatizados que facilitan la obtención del certificado sin tanto rodeo, interesados -> https://letsencrypt.org/howitworks/

Os aviso de antemano que encontrareís MUY POCA info del método manual, todo lo que os voy a explicar a continuación es una recopilación de mi esfuerzo y horas invertidas en este proceso.

Primero generamos nuestro par de claves pública/privada junto al CSR, todo a la vez. En este comando incluiremos la información personal del sitio así como los dominios a proteger:

openssl req -new -newkey rsa:2048 -sha256 -nodes -keyout privkey.pem -out signreq.der -subj "/C=SP/ST=BI/O=NoLucro,S.A./CN=dominio.com" -outform der -reqexts SAN -config <(cat /etc/pki/tls/openssl.cnf <(printf "[SAN]\nsubjectAltName=DNS:dominio.com,DNS:www.dominio.com,DNS:subdominio.com,DNS:www.subdominio.com"))

Os explico los parámetros:

-newkey: Genera un par de claves, en este caso RSA 2048 bit. También soporta 4096 bit.
-sha256: Algoritmo empleado para la verificación de la firma digital del certificado. Recordad, SHA-1 se considerá inseguro.
-nodes: La clave privada no será cifrada mediante criptografía simétrica.
-keyout: Archivo donde se guardará la clave privada, su contenedor es del tipo .pem.
-out: Archivo donde se guardará el CSR, IMPORTANTÍSIMO que sea .der pues LetsEncrypt no soporta .pem para el CSR.
-subj: Información personal del dueño de nuestra Web (nosotros). "C" es Country (país, 2 letras, SP=España), ST (ciudad, ¿2 letras?, BI=Bilbao), O (organicación), CN (dominio de la web).
-outform der: Como ya he dicho, este comando es fundamental para convertir el CSR en formado .der para que sea reconocible por LetsEncrypt.
-reqexts: Nos permite espicificar más de un dominio para el certificado, así un mismo certificado sirve para varios dominios/subdominios.
SAN: Subject Alter Name, campo del CSR donde podemos especificar más de un dominio, como ya he dicho previamente. Importante incluir los dominios sin www y con www, además de incluir el dominio del campo "CN".

Si todo va bien obtendreís el siguiente output al ejecutar el comando:

Generating a 2048 bit RSA private key
.........................................................................................+++
....................................................+++
writing new private key to 'privkey.pem'
-----

Ahora que tenemos el CSR, necesitamos que la entidad certificadora (CA) de LetsEncrypt nos lo firme con su clave privada, bueno, realmente firma el SHA256 de nuestro certificado y lo incluye en un nuevo campo, y ese resultado es lo que conocemos por certificado x509v3 o certificado SSL/TLS.

Para ello ejecutamos el cliente de LetsEncrypt de la siguiente forma:

./letsencrypt-auto certonly --authenticator manual --email vuestro@email.com --csr signreq.der --text --debug

Bueno no os preocupeis de la cascada de datos que se muestra en pantalla. Llegará un punto en el que el cliente se detenga y os pregunte si le dais consentimiento para almacenar vuestra IP, por seguridad, aceptaís y estareís en la siguiente fase, donde tendremos que provar a LetsEncrypt que somos los dueños de los dominios pertenecientes al CSR. Obtendreís algo como:

Make sure your web server displays the following content at
http://www.dominio.com/.well-known/acme-challenge/XU61P5E-sEefZB5vjllHeQWRpkDs2G_AvlxitI6hOIQ before continuing:

XU61P5E-sEefZB5vjllHeQWRpkDs2G_AvlxitI6hOIQ.BON7JEeVn9miBfADQ34eQIcUTsSTVsHRQqCeXuVUGVs

Simplemente nos dicen que creemos el directorio .well-known/acme-challenge en el directorio raíz de nuestro servidor. Una vez creado, en este ejemplo, crearemos el archivo XU61P5E-sEefZB5vjllHeQWRpkDs2G_AvlxitI6hOIQ con la siguiente cadena dentro XU61P5E-sEefZB5vjllHeQWRpkDs2G_AvlxitI6hOIQ.BON7JEeVn9miBfADQ34eQIcUTsSTVsHRQqCeXuVUGVs. Cuando hayais terminado visitad la URL en vuestro navegador para cercioraros de que la cadena es visible. Una vez completado el proceso presionad ENTER en la terminal donde estaís ejecutando el cliente LetsEncrypt.

Daros cuenta que las cadenas de arriba son un ejemplo, además tendreís que repetir este proceso por cada dominio especificado en el apartado SAN del CSR, ya que por cada dominio tendreís que probar a LetsEncrypt que sois vosotros sus respectivos dueños.

Si la verificación del challenge ha sido satisfactoria obtendreís un mensaje como este:

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at
   /home/kub0x/letsencrypt/0001_chain.pem. Your cert will expire on
   2016-03-10. To obtain a new version of the certificate in the
   future, simply run Let's Encrypt again.

Felicidades, ya teneis vuestro propio certificado gratuito firmado por una entidad de confianza, por lo que vuestro certificado es válido en cualquier plataforma, navegador etc. El siguiente paso os lo dejo a vosotros. Si teneis apache simplemente modificad vuestra configuración de VirtualHosts e indicar donde está la clave privada, el certificado que habeís obtenido y la certificate chain, pues sin esta última es imposible verificar que el certificado fue emitido por LetsEncrypt.

PROS:

- Certificado válido bajo cualquier plataforma y firmado por una entidad de confianza (CA), ya que LetsEncrypt delega en IdenTrust, CA (trust-anchor) confiada por todo tipo de plataformas. + info sobre la CA en: https://letsencrypt.org/certificates/
- Renovación del certificado gratuita.
- Dentro de poco implementarán la emisión de certificados mediante la prueba de DNS, junto a la previamente expuesta basada en HTTP.

CONTRAS:

- Se encuentra en fase Beta, por lo que requiere de un conocimiento avanzado (según el modo de instalación) y no está para nada libre de bugs.
- Los certificados tienen que ser renovados cada cierto tiempo, es una política de seguridad para evitar que estén activos largos periodos de tiempo.
- En algunos hostings gratuitos o administrados es necesario deshabilitar el módulo de apache mod_security puesto que obtendremos un error "403 forbidden". En nginx ni idea.
- No se puede obtener un certificado de tipo WildCard, es decir, no emiten certificados del tipo *.dominio.com. por lo que debemos especificar en el campo SAN del CSR todos los dominios a proteger.
- Por ahora no tiene soporte en Windows.

Estaré encantado en responder cualquier cuestión relacionada con el tema. Si me animais a hacer un tutorial sobre certificados, HTTPS, SSL/TLS, RSA e incluso la matemática interna, pues obviamente, lo realizaré muy agusto, pues ahora mi entretenimiento es la criptografía al 100%.

Saludos!