Tag Archives: web

Weak TLS cipher suites

HTTP and HTTPS are well known Internet protocols that don’t require any introduction. The other day at work as part of a daily security scan one of our servers got tagged as using weak cipher suites during TLS negotiation. In this quick post I’ll explain what a weak cipher suite means and how to fix it.

There are many tools out there to check if you are following the security best practices when it comes to SSL/TLS server configuration (supported versions, accepted cipher suites, certificate transparency, expiration, etc.) but one of my favorites is https://www.ssllabs.com/ssltest/analyze.html and drwetter/testssl.sh.

SSLlabs.com is easy to use, you just have to enter a Hostname and the website will analyze all possible TLS configuration and calculate a score for you, this tool will also tell you what you can do to improve that score.

There are many TLS protocol versions: 1.0, 1.1, 1.2, 1.3. The first two are considered insecure and should not be used so I will focus on 1.2 and 1.3 only.
In my case SSLlabs.com was complaining about weak cipher suites were supported for TLS 1.2:

The above report is showing ECDHE-RSA-AES256-SHA384E and ECDHE-RSA-AES256-SHA as weak cipher suites.

First let’s clarify a couple of things, according to Wikipedia:

Cipher suite: A set of algorithms that help secure a network connection.

So a weak cipher suite will be algorithms with known vulnerabilities that can be used by attackers to downgrade connections or other nefarious things.

Fixing this is very easy and will require changing a line or two on the server configuration, deploying the changes and then testing again using SSLlabs.com.

Of course, the above only applies if you know exactly what you are doing, otherwise it will take you many attempts and you are going to waste precious time.

Reproduce and fix the issue locally

Suppose you have the same issue I had, because this issue was reported on an Nginx Server now the task is to reproduce the issue locally and come up with a fix. With modern technologies like docker containers it’s very easy to run a local Nginx server, the only thing you need is a copy of the nginx.conf, to run a docker container the command will be:

docker run --name mynginx -v ./public.pem:/etc/nginx/public.pem -v ./private.pem:/etc/nginx/private.pem -v ./nginx.conf:/etc/nginx/nginx.conf:ro -p 1337:443 --rm nginx

The above command is telling docker to run an Nginx container; binding the local port 1337 to the container port 443 and also mounting the public.pem (public key), private.pem (private key) and nginx.conf (the server configuration) files inside the container.

The nginx.conf looks like this:

    server {
        listen 443 ssl;
        server_name www.alevsk.com;
        ssl_certificate /etc/nginx/public.pem;
        ssl_certificate_key /etc/nginx/private.pem;
        ssl_protocols TLSv1.3 TLSv1.2;
        ssl_prefer_server_ciphers on;
        ssl_ecdh_curve secp521r1:secp384r1:prime256v1;
        ssl_ciphers EECDH+AESGCM:EECDH+AES256:EECDH+CHACHA20;
        ssl_session_cache shared:TLS:2m;
        ssl_buffer_size 4k;
        add_header Strict-Transport-Security 'max-age=31536000; includeSubDomains; preload' always;
    }

You can test the server is working fine with a simple curl command:

curl https://localhost:1337/ -v -k
*   Trying 127.0.0.1:1337...
* Connected to localhost (127.0.0.1) port 1337 (#0)
* ALPN, offering h2
* ALPN, offering http/1.1
*  CAfile: /etc/ssl/certs/ca-certificates.crt
*  CApath: /etc/ssl/certs
* TLSv1.0 (OUT), TLS header, Certificate Status (22):
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
* TLSv1.2 (IN), TLS header, Certificate Status (22):
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* TLSv1.2 (OUT), TLS header, Finished (20):
* TLSv1.3 (OUT), TLS change cipher, Change cipher spec (1):
* TLSv1.2 (OUT), TLS header, Certificate Status (22):
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
* TLSv1.2 (IN), TLS header, Finished (20):
* TLSv1.2 (IN), TLS header, Certificate Status (22):
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* TLSv1.2 (IN), TLS header, Supplemental data (23):
* TLSv1.3 (IN), TLS handshake, Encrypted Extensions (8):
* TLSv1.2 (IN), TLS header, Supplemental data (23):
* TLSv1.3 (IN), TLS handshake, Certificate (11):
* TLSv1.2 (IN), TLS header, Supplemental data (23):
* TLSv1.3 (IN), TLS handshake, CERT verify (15):
* TLSv1.2 (IN), TLS header, Supplemental data (23):
* TLSv1.3 (IN), TLS handshake, Finished (20):
* TLSv1.2 (OUT), TLS header, Supplemental data (23):
* TLSv1.3 (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384
* ALPN, server accepted to use http/1.1
* Server certificate:
....
....
....
> 
* TLSv1.2 (IN), TLS header, Supplemental data (23):
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
* TLSv1.2 (IN), TLS header, Supplemental data (23):
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
* old SSL session ID is stale, removing
* TLSv1.2 (IN), TLS header, Supplemental data (23):
* Mark bundle as not supporting multiuse
< HTTP/1.1 404 Not Found
< Server: nginx
< Date: Sun, 15 May 2022 23:14:23 GMT
< Content-Type: text/html
< Content-Length: 146
< Connection: keep-alive
< Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
< 
<html>
<head><title>404 Not Found</title></head>
<body>
<center><h1>404 Not Found</h1></center>
<hr><center>nginx</center>
</body>
</html>
* Connection #0 to host localhost left intact

The next step is to reproduce the report from https://www.ssllabs.com/ but that will involve somehow exposing our local Nginx server to the internet and that’s time consuming. Fortunately there’s an amazing open source tool that will help you to run all these TLS tests locally.

drwetter/testssl.sh is a tool for testing TLS/SSL encryption anywhere on any port and the best part is that runs on a container too, go to your terminal again and run the following command:

docker run --rm -ti --net=host drwetter/testssl.sh localhost:1337

The above command will run the drwetter/testssl.sh container, the –rm flag will automatically delete the container once it’s done running (keep your system nice and clean), -ti means interactive mode and –net=host will allow the container to use the parent host network namespace.

After a couple of seconds you will see a similar result as in the website, something like this:

Testing server’s cipher preferences.

Hexcode  Cipher Suite Name (OpenSSL)       KeyExch.   Encryption  Bits     Cipher Suite Name (IANA/RFC)                        
-----------------------------------------------------------------------------------------------------------------------------  
SSLv2                                                                                                                          
 -                                                                                                                             
SSLv3                                                                                                                          
 -                                                                                                                             
TLSv1                                                                                                                          
 -                                                                                                                             
TLSv1.1                                                                                                                        
 -                                                                                                                             
TLSv1.2 (server order)                                                                                                         
 xc030   ECDHE-RSA-AES256-GCM-SHA384       ECDH 521   AESGCM      256      TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384               
 xc02f   ECDHE-RSA-AES128-GCM-SHA256       ECDH 521   AESGCM      128      TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256               
 xc028   ECDHE-RSA-AES256-SHA384           ECDH 521   AES         256      TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384               
 xc014   ECDHE-RSA-AES256-SHA              ECDH 521   AES         256      TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA                  
 xcca8   ECDHE-RSA-CHACHA20-POLY1305       ECDH 521   ChaCha20    256      TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256         
TLSv1.3 (server order)                                        
 x1302   TLS_AES_256_GCM_SHA384            ECDH 256   AESGCM      256      TLS_AES_256_GCM_SHA384                              
 x1303   TLS_CHACHA20_POLY1305_SHA256      ECDH 256   ChaCha20    256      TLS_CHACHA20_POLY1305_SHA256                        
 x1301   TLS_AES_128_GCM_SHA256            ECDH 256   AESGCM      128      TLS_AES_128_GCM_SHA256

Even on this test we see the weak cipher suites (ECDHE-RSA-AES256-SHA384 and ECDHE-RSA-AES256-SHA).

Great, now you are able to fully reproduce the issue locally and test as many times as you want until you have the perfect configuration. It’s time to do the actual fix.

Open the nginx.conf file one more time and locate the line that starts with ssl_ciphers and just add !ECDHE-RSA-AES256-SHA384:!ECDHE-RSA-AES256-SHA at the end, ie:

 server {
        listen 443 ssl;
        server_name www.alevsk.com;
        ssl_certificate /etc/nginx/public.pem;
        ssl_certificate_key /etc/nginx/private.pem;
        ssl_protocols TLSv1.3 TLSv1.2;
        ssl_prefer_server_ciphers on;
        ssl_ecdh_curve secp521r1:secp384r1:prime256v1;
        ssl_ciphers EECDH+AESGCM:EECDH+AES256:EECDH+CHACHA20:!ECDHE-RSA-AES256-SHA384:!ECDHE-RSA-AES256-SHA;
        ssl_session_cache shared:TLS:2m;
        ssl_buffer_size 4k;
        add_header Strict-Transport-Security 'max-age=31536000; includeSubDomains; preload' always;
    }

If you run the Nginx container with the new configuration and then run the drwetter/testssl.sh test again this time you will see no weak cipher suites anymore.

TLSv1.2 (server order)                                                                                                         
 xc030   ECDHE-RSA-AES256-GCM-SHA384       ECDH 521   AESGCM      256      TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384              
 xc02f   ECDHE-RSA-AES128-GCM-SHA256       ECDH 521   AESGCM      128      TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256              
 xcca8   ECDHE-RSA-CHACHA20-POLY1305       ECDH 521   ChaCha20    256      TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256        
TLSv1.3 (server order)          
 x1302   TLS_AES_256_GCM_SHA384            ECDH 256   AESGCM      256      TLS_AES_256_GCM_SHA384                              
 x1303   TLS_CHACHA20_POLY1305_SHA256      ECDH 256   ChaCha20    256      TLS_CHACHA20_POLY1305_SHA256                        
 x1301   TLS_AES_128_GCM_SHA256            ECDH 256   AESGCM      128      TLS_AES_128_GCM_SHA256

Conclusion

Congratulations, you just fixed your first security engineer issue and now you can push the fix to production. In general when it comes to fixing any kind of problem in tech it is better to start by reproducing the issue locally and work on a fix from there (of course this is debatable if you are facing an issue that only happens in a specific environment). SSL/TLS  and cipher suites are one of those technologies that you have to learn by heart or at least have a very good understanding if you want to work in application security, but not only that, once you understand it it will completely change the way you approach problems and debug security applications .

Happy hacking.

CTF OverTheWire: Natas10

Continuing with the CTF Natas series, now is the turn for natas10

[bash]
Natas Level 9 → Level 10
Username: natas10
URL: http://natas10.natas.labs.overthewire.org
[/bash]

Using the flag obtained in the previous challenge, we go to the URL showed in the description and we will see the following screen.

It’s a simple web page with a basic input form, very similar to the previous one but they have added a character filter, we proceed to click the View sourcecode and we are redirected to index-source.html

This is supposed to be the backend code of the html form.

[php]
<?
$key = "";

if(array_key_exists("needle", $_REQUEST)) {
$key = $_REQUEST["needle"];
}

if($key != "") {
if(preg_match(‘/[;|&]/’,$key)) {
print "Input contains an illegal character!";
} else {
passthru("grep -i $key dictionary.txt");
}
}
?>
[/php]

The preg_match(‘/[;|&]/’,$key) function will make sure to drop any search request that contains the ; or & characters so we cannot execute additional commands like we did on the previous level, but instead of trying to bypass this filter there is an easier way to solve this level, the grep command supports search for a pattern in multiple files so we are going to exploit that, the goal is to execute something like this:

[bash]
grep -i ” /etc/natas_webpass/natas11 dictionary.txt
[/bash]

Since ” /etc/natas_webpass/natas11 doesn’t contains any of the filtered characters we can just send this payload through the form.

The flag for the next level, natas11, is: U82q5TCMMQ9xuFoI3dYX61s7OZD9JKoK

In this challenge we exploit a command injection vulnerability that essentially allow us to execute arbitrary commands on the server, this time there was a security mechanism in place but the fundamental problem was still there. Depending on the privileges of the user running the web server we might read, write or delete files.

Happy hacking 🙂

Commands and Code Snippets I usually forget

Some commands and code snippets I use rarely during CTFs or my daily work, but still I need them from time to time and I’m very lazy to remember them. This note may grow over time.

Javascript

Playing with dec, hexa and bin (not really) in JS

[javascript]
String.fromCharCode(0x41) // ‘A’

parseInt(‘0xf’, 16) // 15

var n = 15

n.toString(16) // ‘f’
n.toString(2) // ‘1111’
n.toString() // ’15’

var n = ‘A’
n.charCodeAt() // 65
// dec to hex
n.charCodeAt().toString(16) // ’41’
// dec to bin
n.charCodeAt().toString(2) // ‘1000001’
// dec to hex
parseInt(255).toString(16) // ‘ff’
// dec to bin
parseInt(5).toString(2) // ‘101’
[/javascript]

Simple HTTP GET request using nodejs

[javascript]
const https = require(‘https’);

https.get(‘https://www.alevsk.com’, (resp) => {
let data = ”;
resp.on(‘data’, (chunk) => {
data += chunk;
});
resp.on(‘end’, () => {
//DO something with data
});
}).on("error", (err) => {
console.log("Error: " + err.message);
});
[/javascript]

Simple HTTP POST request using nodejs

[javascript]
const https = require(‘https’)

const data = JSON.stringify({
todo: ‘Buy the milk’
})

const options = {
hostname: ‘whatever.com’,
port: 443,
path: ‘/todos’,
method: ‘POST’,
headers: {
‘Content-Type’: ‘application/json’,
‘Content-Length’: data.length
}
}

const req = https.request(options, res => {
res.on(‘data’, d => {
process.stdout.write(d)
})
})

req.on(‘error’, error => {
console.error(error)
})

req.write(data)

req.end()
[/javascript]

Extract content between regular expression patterns using JS

[javascript]
const message = data.match(/<p>([^<]+)<\/p>/)[1];
const lat = data.match(/name="lat" value="([^<]+)" min=/)[1];
const long = data.match(/name="lon" value="([^<]+)" min=/)[1];
const token = data.match(/name="token" value="([^<]+)"/)[1];
[/javascript]

Linux

Mount NTFS on Linux

[bash]
mount -t ntfs [FILE] [PATH]
mount -t type device directory
[/bash]

Extract extended attributes from NTFS disk

[bash]
getfattr –only-values [FILE] -n [ATTR-NAME] > file
[/bash]

Parsing file with awk and run xargs

[bash]
cat [FILE] | awk ‘{print $1 .. $n}’ | xargs
[/bash]

Python

Start Simple HTTP server with Python

[bash]
python -m SimpleHTTPServer
[/bash]

Inline Python commands

[bash]
python -c ‘print "\x41" * 20’
[/bash]

PHP

Run PHP interactive mode

[bash]
php -a
[/bash]

CTF OverTheWire: Natas6

Continuamos con la serie de tutoriales del CTF Natas, ahora toca el turno de natas6.

[bash]
Natas Level 5 → Level 6
Username: natas6
URL: http://natas6.natas.labs.overthewire.org
[/bash]

Utilizamos la bandera obtenida en el reto anterior y accedemos a la URL indicada en las instrucciones del reto, veremos una pantalla como la siguiente.

Es solo un formulario donde nos piden ingresar una contraseña o secreto, al introducir cualquier cosa obtenemos un mensaje de error.

En la misma pagina hay un enlace que dice view sourcecode (ver código fuente), damos clic y veremos lo siguiente.

La parte importa es:

[php]
<?

include "includes/secret.inc";

if(array_key_exists("submit", $_POST)) {
if($secret == $_POST[‘secret’]) {
print "Access granted. The password for natas7 is <censored>";
} else {
print "Wrong secret";
}
}
?>
[/php]

Es un código php muy sencillo, podemos ver que obtiene un parámetro via POST (el que enviamos mediante el formulario) y lo compara con la variable $secret, ademas hace include de un archivo interesante includes/secret.inc

Accedemos a ese archivo usando el navegador.

Y utilizamos el secret que acabamos de descubrir en el formulario inicial.

La bandera para acceder a natas7 es 7z3hEENjQtflzgnT29q7wAvMNfZdh0i9

En este reto aprovechamos un fallo de seguridad llamado Source code disclosure, en donde tenemos acceso a código que solo debería ser consumido del lado del servidor.

Happy hacking 🙂

25 mujeres tecnólogas / hackers / programadoras que sigo en twitter – Parte 2

Continuo con la segunda parte de mi listas, mujeres en la tecnología que no puedes dejar de seguir en Twitter 🙂

#11 – Jessy Irwin

Tecnologa y entusiasta de la ciberseguridad, Jessy es un miembro muy activo en la comunidad, parte de su tiempo lo dedica a impartir platicas sobre privacidad de datos, consejos básicos sobre seguridad y en general concientizar a la población acerca del buen uso de Internet, en su blog personal tiene bastantes referencias sobre platicas y eventos a las que ha sido invitada

#12 – Julia Evans

Julia es una hacker muy peculiar 🙂 no solo por la manera en la que transmite sus ideas (les recomiendo ver los videos de sus presentaciones en YouTube) si no también por el gran numero de áreas que domina en la informática, parece que no hay algo que esta mujer no sepa y lo mejor de todo es que puede explicar temas muy complejos de una forma simple y fácil de entender para el común de los programadores. Algunas de sus publicaciones mas populares incluyen System design, TCP stack, Kernel hacking, dynamic memory, etc.

Aunque ella se considera a si misma una simple administradora de sistemas, en sus publicaciones Julia demuestra un gran expertis en el área de redes y sistemas operativos en general.

#13 – Katie Moussouris

Fundadora y CEO de LutaSecurity, empresa dedicada en proveer soluciones para el responsable disclosure de vulnerabilidades en las organizaciones, los tweets de Katie incluyen las ultimas noticias sobre el malware que afecta a las organizaciones y APTs (advanced persistent threat) en general.

#14 – Katie Neuman

Katie Neuman es una autoridad en la comunidad de seguridad, junto con un grupo de expertos se encargan de crear las pautas para que los procesos de seguridad a nivel corporativo sigan un mismo estándar, en su cuenta de Twitter publica acerca de las ultimas amenazas en el mundo de la ciberseguridad.

#15 – Lesley Carhart

Lesley Carhart es una veterana de la seguridad, con mas de 15 años de experiencia en la industria, incluyendo 8 como DFIR (Digital Forensics and Incident Response) es una gran inspiración para todas los entusiastas de la informática forense, mediante su blog personal colabora con la comunidad publicando artículos de seguridad dirigidos tanto a audiencia técnica como no técnica, puedes encontrar varios videos de sus charlas en Youtube

#16 – Amanda Rousseau

Amanda Rousseau, mejor conocida como Malware Unicorn, es una analista de Malware e investigadora de seguridad, su experiencia incluye haber trabajado como Malware reverse Engineer en el centro de delitos cibernéticos del Departamento de Defensa de los Estados Unidos, Amanda es especialmente popular en eventos de ciberseguridad como Defcon y Black Hat por sus platicas y talleres sobre ingeniería inversa.

Si estas interesado en el análisis de Malware, en su blog encontraras dos cursos completamente gratuitos que te ayudaran a empezar, Reverse Engineering Malware 101 y Reverse Engineering Malware 102.

#17 – Melissa Archer

Melissa Archer es una entusiasta de la tecnología, actriz y empresaria, mejor conocida por ser cofundadora de Hacker’s brew, Jailbreak developer y Tweak developer.

#18 – Ophelia Pastrana

Ophelia Pastrana es una mujer transgénero, física, economista, emprendedora y agnóstica de la tecnología, es muy activa en redes sociales, especialmente en la comunidad tecnológica y LGBT de Latinoamérica, es creadora de varios podcast/vlogs como nerdcore y canvas y le gusta asistir a multitud de eventos tecnológicos entre ellos Campus Party MX, en el cual he tenido la oportunidad de conocerla y hablar con ella personalmente.

#19 – Parisa Tabriz

Parisa Tabriz aka Security Princess, trabaja en Google liderando uno de los equipo de ciberseguridad encargado de mejorar la seguridad de varios productos, entre ellos como Google Chrome, Parisa es una investigadora de la que todo entusiasta de la seguridad ha oído hablar al menos una vez, una de sus aportaciones mas significativas ha sido su articulo So, you want to work in security? en donde comparte consejos a las personas que se quieren iniciar en seguridad.

#20 – Rosa Guillén

Rosa Guillén, también conocida como Novatillasku es una entusiasta de Linux a la que tengo ya varios años de seguir en Internet, es autodidacta y tiene un blog donde publica noticias y artículos de tecnología, comencé a leer sus tutoriales sobre Ubuntu y Linux en general cuando empezaba la preparatoria, si quieres estar enterado de las ultimas noticias sobre este sistema operativo definitivamente es una excelente fuente de noticias.

#21 – Sailor Mercury (Amy)

Sailor Mercury tiene una historia muy interesante, ella solía ser una desarrolladora web en Airbnb y tenia un pasa tiempo que consistía en crear historietas sobre tecnología y diversos temas de ciencias computacionales como algoritmos, memoria, TCP, protocolos, etc. con la ayuda de Kickstarter consiguio fondos para crear una tienda en linea llamada bubblesort.io, dejo su trabajo en Airbnb y ahora se dedica de tiempo completo a seguir transformando conceptos complejos en pequeñas historietas para que mas gente tenga acceso al conocimiento.

#22 – Samantha Davison

Samantha Davidson es una hacker que ha trabajado en equipos de seguridad de compañías como Uber y actualmente Snapchat, su trabajo consiste en concientizar a las personas acerca de la privacidad de sus datos, sobre todo en ambientes corporativos.

#23 – Sheila A. Berta

Tuve la oportunidad de conocer a Sheila en una de sus platicas durante el DragonJar Security Conference en 2015 en Manizales, Colombia. Ella se dedica a la seguridad informática pero desde un punto de vista mas ofensivo, es una reverse engineer y analista de malware muy hábil, ha contribuido a la comunidad de seguridad creando herramientas como CBM – The Bicho y el framework Crozono

#24 – Yan Zhu

Yan Zhu es otra de las hackers mas populares y respetadas en la comunidad de seguridad, siempre esta presente en eventos como Defcon y Black Hat, entre sus aportaciones a la comunidad se encuentran haber contribuido a proyectos como HTTPS everywhere, Let’s Encrypt, SecureDrop, Privacy Badger y Brave

Puedes encontrar varias de sus charlas en Youtube, la gran mayoría de ellas son acerca de protocolos de seguridad para comunicaciones como TLS.

#25 – Keren Elazari

Investigadora y oradora en temas de ciberseguridad reconocida mundialmente, trabaja directamente con compañías Big 4 y Fortune 500 ayudandolos a crear estrategias para mejorar su seguridad y la de sus productos. Esta mujer ha aportado bastante a la comunidad y ha sido fuente de inspiración de muchísimos entusiastas alrededor del mundo, ha sido mencionada en medios de gran reputación como Forbes, Scientific American, WIRED y TED.

Tienen alguna otra recomendación para seguir en Twitter? de ser así se los agradecería.

Saludos.