5 fragmentos de código de seguridad de Node.js que todo desarrollador backend debería conocer

Como desarrolladores backend, tenemos la importante responsabilidad de garantizar la seguridad de nuestras aplicaciones. Node.js no está exento de esta responsabilidad y su creciente popularidad lo convierte en un objetivo atractivo para los hackers, por lo que es fundamental seguir las mejores prácticas de seguridad al trabajar con Node.js.

En esta publicación del blog, exploraremos algunos fragmentos esenciales de código de seguridad de Node.js que todo desarrollador backend debería conocer en 2024. Las vulnerabilidades de software de Node.js pueden representar una amenaza considerable para cualquier aplicación. Pueden provocar accesos no autorizados, filtraciones de datos y, en el peor de los casos, el compromiso total del sistema. Por eso, seguir las mejores prácticas de seguridad no es solo una recomendación, sino un requisito.

En el contexto de Node.js, esto significa asegurarte de que tu código no exponga vulnerabilidades que puedan aprovecharse. Significa sanear los datos de entrada de los usuarios para prevenir ataques de inyección, tratar las contraseñas como datos confidenciales y administrar las dependencias para evitar vulnerabilidades de terceros, entre otras prácticas.

Revisaremos los siguientes conceptos de seguridad de Node.js y sus fragmentos de código correspondientes, considerando su eficacia para prevenir vulnerabilidades comunes y lo accesibles que son para los desarrolladores, sin necesidad de contar con conocimientos adicionales de seguridad:

1. Usa el modelo de permisos de Node.js para restringir el acceso a los recursos durante la ejecución

2. Implementa la validación de entradas con un esquema JSON de Fastify

3. Protege el hash de contraseñas con Bcrypt

4. Previene ataques de inyección SQL con Knex.js

5. Implementa la limitación de frecuencia con fastify-rate-limit

1. Usa el modelo de permisos de Node.js para restringir el acceso a los recursos durante la ejecución

El modelo de permisos de Node.js puede desempeñar un papel fundamental en la protección de tus aplicaciones. Es una parte clave del modelo de seguridad básico de Node.js y ayuda a garantizar que tus aplicaciones estén protegidas contra ataques y actividades maliciosas. De manera similar a la promesa de seguridad que Deno ofreció con las restricciones de recursos centradas en los procesos, Node.js ahora cuenta, hasta cierto punto, con un modelo de permisos similar.

Imagina que una aplicación de Node.js necesita convertir archivos PDF en imágenes PNG. Podríamos usar el paquete npm pdf-image para realizar esta tarea. El paquete pdf-image usa procesos secundarios para llevar a cabo la conversión. Para habilitar esta función, debemos usar la opción --allow-child-process en el entorno de ejecución de Node.js (que proporciona el modelo de permisos).

A continuación, se muestra un fragmento de código que lo demuestra:

1const { PDFImage } = require('pdf-image');
2const path = require('path');
3
4const pdfPath = path.resolve(__dirname, 'sample.pdf');
5const pdfImage = new PDFImage(pdfPath, {
6  convertOptions: {
7    '-density': '300',
8    '-quality': '80'
9  },
10  combinedImage: true
11});
12pdfImage.convertFile().then(() => {
13  console.log('PDF converted to PNG successfully');
14}).catch((err) => {
15  console.error(`Failed to convert PDF to PNG: ${err}`);
16});

En este fragmento, creamos una nueva instancia de PDFImage con la ruta a nuestro archivo PDF y algunas opciones de conversión. Luego, llamamos a convertFile() para convertir el PDF en una imagen PNG.

Si habilitas el modelo experimental de permisos en Node.js, tendrás que ejecutar explícitamente el entorno de ejecución de Node.js con la opción de línea de comandos --allow-child-process mencionada anteriormente, ya que internamente la biblioteca pdf-image inicia un proceso secundario para convertir estos archivos PDF.

Aunque el modelo de permisos de Node.js ofrece una excelente forma de restringir el acceso a los recursos del sistema, también es fundamental conocer las posibles vulnerabilidades de seguridad de los paquetes que usamos. Aquí es donde entra en juego la extensión de Snyk para Visual Studio Code. La extensión de Snyk puede detectar código inseguro y dependencias vulnerables en una aplicación de Node.js. Por ejemplo, se sabe que el paquete pdf-image mencionado anteriormente es vulnerable a la inyección de comandos debido al uso de procesos secundarios. Esta vulnerabilidad se conoce desde 2018 y, lamentablemente, todavía no hay una solución disponible.

Esto resalta la importancia de usar herramientas como Snyk para mantenerte al tanto de las vulnerabilidades de seguridad en los paquetes de los que dependemos. También nos recuerda que debemos tener cuidado al usar ciertas funciones, como los procesos secundarios, que pueden representar riesgos de seguridad si no se manejan correctamente.

Como desarrolladores de Node.js, tenemos la responsabilidad de asegurarnos de que el código que escribimos no solo funcione, sino que también sea seguro. Una forma clave de mejorar la seguridad de una aplicación de Node.js es usar el modelo de permisos integrado para restringir el acceso a los recursos del sistema durante la ejecución. Si sabes que tu aplicación de Node.js no necesita capacidades de procesos secundarios, no habilites este recurso para evitar ampliar la superficie de ataque.

Preguntas frecuentes sobre el modelo de permisos de Node.js

2. Implementa la validación de entradas con un esquema JSON de Fastify

La validación de entradas es un aspecto fundamental del desarrollo backend. Si ya creaste API con Express, Fastify u otros frameworks, probablemente ya conozcas su importancia. Es una práctica de seguridad que garantiza que solo ingresen datos con el formato correcto a tu sistema y, de ese modo, previene posibles riesgos de seguridad. Una forma de implementar la validación de entradas en tus aplicaciones de Node.js es usar el esquema de Fastify en tus aplicaciones web de Fastify.

Enfoque basado en esquemas de Fastify

Fastify usa un enfoque basado en esquemas para validar las entradas. Aunque no es obligatorio, se recomienda usar el esquema JSON para validar las rutas y serializar las salidas. El esquema JSON establece un contrato para tus datos y detalla el formato esperado, los tipos de datos, los campos obligatorios y otras restricciones. Puedes pensar en el esquema JSON de una ruta de Fastify como el uso de TypeScript para garantizar un tipado estricto en tu código durante el proceso de compilación.

Imagina una aplicación sencilla de Fastify en la que creamos un nuevo usuario. Podemos usar un esquema de Fastify para validar los datos de entrada.

1const fastify = require('fastify')({ logger: true });
2
3const UserSchema = {
4  body: {
5    type: 'object',
6    properties: {
7      name: { type: 'string' },
8      email: { type: 'string', format: 'email' },
9      password: { type: 'string', minLength: 8 }
10    },
11    required: ['name', 'email', 'password']
12  }
13};
14
15// User creation route
16fastify.post('/users', { schema: UserSchema }, async (request, reply) => {
17  // Example user creation logic
18  // In a real application, you would replace this with actual database logic
19  const user = request.body;
20
21  // Simulating user creation
22  console.log("Creating user:", user);
23
24  // Responding with the created user (in real applications, never send the password back)
25  return reply
26    .code(201)
27    .send({ success: true, message: "User created", user: { name: user.name, email: user.email } });
28});
29
30// Server startup
31const start = async () => {
32  try {
33    await fastify.listen({ port: 6000, host: 'localhost' });
34    console.log(`Server running at http://localhost:3000/`);
35  } catch (err) {
36    fastify.log.error(err);
37    process.exit(1);
38  }
39};
40
41start();

En el código anterior, definimos un UserSchema que requiere un nombre, un correo electrónico y una contraseña. El correo debe tener un formato válido y la contraseña debe tener al menos 8 caracteres.

No validar las entradas puede exponer tu aplicación a varios riesgos de seguridad, como la falsificación de solicitudes del lado del servidor (SSRF) o los ataques de contaminación de parámetros HTTP. Los ataques SSRF pueden engañar al servidor para que realice solicitudes no autorizadas, lo que podría exponer datos; por su parte, la contaminación de parámetros HTTP puede manipular o corromper las solicitudes y provocar comportamientos inesperados.

Herramientas como Snyk pueden ayudar a descubrir estas vulnerabilidades al analizar tu código en busca de fallas de seguridad. También pueden ofrecer recomendaciones de corrección para ayudarte a resolverlas y mejorar la seguridad general de tu aplicación.

Preguntas frecuentes sobre la validación de entradas con Fastify

3. Protege el hash de contraseñas con Bcrypt

Almacenar de forma segura las contraseñas de los usuarios es fundamental en el desarrollo de software. En caso de una filtración de datos, debes asegurarte de que la información de las contraseñas de los usuarios no se pueda descifrar fácilmente. Aquí es donde entra en juego el hashing de contraseñas. El hashing es el proceso de convertir una clave determinada en otro valor. Se usa una función hash para generar el nuevo valor, que idealmente debería producir una salida única (o código hash) para cada valor de entrada único.

Si decides implementar la autenticación por tu cuenta en lugar de recurrir a un servicio o a otra biblioteca, es fundamental que entiendas que la forma en que proteges las contraseñas puede afectar directamente la seguridad general de tu aplicación.

Introducción a Bcrypt para el hashing de contraseñas en Node.js

Bcrypt es un algoritmo y un paquete npm que ofrece una función de hashing de contraseñas considerada muy segura. Incorpora una sal (datos aleatorios) para proteger contra los ataques de tablas arcoíris y permite configurar un factor de trabajo, que determina cuánto procesamiento de CPU requiere el hashing. Esta característica resulta útil para prevenir ataques de fuerza bruta.

Veamos un caso de uso sencillo:

1const bcrypt = require('bcrypt');
2const saltRounds = 10;
3const myPlaintextPassword = 'my_password';
4
5// Define an async function
6async function hashPassword(plaintextPassword) {
7  try {
8    const hash = await bcrypt.hash(plaintextPassword, saltRounds);
9    // Store hash in your password DB.
10    console.log(hash); // Example of how to use the hash
11  } catch (err) {
12    // Handle error
13    console.error(err);
14  }
15}
16
17// Call the async function
18hashPassword(myPlaintextPassword);

El parámetro saltRounds determina la complejidad del proceso de hashing. Cuanto mayor sea el valor, más tiempo tardará el proceso, lo que puede ayudar a proteger contra los ataques de fuerza bruta. La función hash agrega una sal y aplica automáticamente el hashing a la contraseña en texto plano. Luego, puedes almacenar el hash resultante en tu base de datos.

Preguntas frecuentes sobre el hashing de contraseñas y la administración de la autenticación en Node.js

4. Previene ataques de inyección SQL con Knex.js

La inyección SQL es una vulnerabilidad de seguridad común que representa un riesgo importante para los datos de las aplicaciones. Los desarrolladores de Node.js pueden reducir este riesgo usando Knex.js, un prometedor generador de consultas SQL que permite crear consultas más seguras. Sin embargo, ten en cuenta que Knex.js también permite crear y ejecutar consultas SQL sin procesar. En ese caso, la inyección SQL sigue siendo un riesgo de seguridad, ya que puede introducirse en la consulta al concatenar entradas de usuarios.

Knex.js es un potente generador de consultas SQL para Node.js. Es compatible con transacciones, agrupación de conexiones, migraciones y datos iniciales, por lo que es una opción preferida por los desarrolladores que buscan escribir consultas SQL seguras, sólidas y escalables. Knex.js protege contra los ataques de inyección SQL mediante consultas parametrizadas y el escape de los valores que se ingresan en las instrucciones SQL.

Considera el siguiente fragmento de código, que muestra cómo Knex.js protege contra los ataques de inyección SQL:

1const knex = require('knex')({
2  client: 'pg',
3  connection: {
4    host : '127.0.0.1',
5    user : 'your_database_user',
6    password : 'your_database_password',
7    database : 'myapp_test'
8  }
9});
10
11// This value is provided by the user and could be malicious
12// such as applying an OR 1=1 SQL injection or other
13// techniques that escape the original context of the query
14// and create a new one
15let userProvidedValue = 'maliciousValue';
16
17knex('users')
18  .where('id', '=', userProvidedValue)
19  .select()
20  .then(rows => {
21    // process result
22  })
23  .catch(err => {
24    // handle error
25  });

En este ejemplo, Knex.js aplica automáticamente el escape a userProvidedValue para prevenir posibles ataques de inyección SQL.

Como mencionamos antes, usar Knex.js por sí solo no ofrece un aislamiento completo ni una mitigación total contra la inyección SQL. Este es un ejemplo de un uso potencialmente inseguro de Knex.js que podría provocar un ataque de inyección SQL:

1knex.raw(`SELECT * FROM users WHERE id = ${userProvidedValue}`)

En este caso, no se aplica escape ni parametrización a userProvidedValue, por lo que la consulta es vulnerable a la inyección SQL si userProvidedValue contiene código SQL malicioso. Snyk puede ayudar a los desarrolladores a detectar este tipo de vulnerabilidades en su base de código. Snyk analiza tu código y ofrece recomendaciones prácticas para corregir las vulnerabilidades de seguridad, incluidos los posibles ataques de inyección SQL.

Preguntas frecuentes sobre la prevención de la inyección SQL con Knex.js

5. Implementa la limitación de frecuencia con fastify-rate-limit

La limitación de frecuencia es un mecanismo de seguridad fundamental que protege tus aplicaciones web contra los ataques de denegación de servicio (DoS). Al controlar la cantidad de solicitudes que un cliente puede hacer a tu aplicación en un periodo determinado, evitas que clientes maliciosos saturen tu servidor con una gran cantidad de solicitudes y garantizas que tu aplicación siga disponible para otros usuarios legítimos.

fastify-rate-limit es un complemento para el framework web Fastify que ofrece una interfaz fácil de usar para implementar la limitación de frecuencia en tus aplicaciones de Node.js. El complemento te permite especificar la cantidad máxima de solicitudes que un cliente puede hacer en un periodo determinado y la respuesta que se debe enviar cuando se supera ese límite.

Este es un ejemplo básico de cómo implementar la limitación de frecuencia en tu aplicación de Node.js con fastify-rate-limit:

1const fastify = require('fastify')()
2
3fastify.register(require('@fastify/rate-limit'), {
4  // max number of connections during windowMs milliseconds before sending a 429 response
5  max: 100,
6  timeWindow: '1 minute'
7})
8
9fastify.get('/', (req, reply) => {
10  reply.send({ hello: 'world' })
11})
12
13fastify.listen(3000, err => {
14  if (err) throw err
15  console.log('Server listening at http://localhost:3000')
16})

En este fragmento de código, el paquete de limitación de frecuencia de Fastify está configurado para limitar a cada cliente a 100 solicitudes por minuto. Si un cliente supera este límite, el servidor responde con el código de estado 429 ("Too Many Requests").

Preguntas frecuentes sobre la limitación de frecuencia

Por qué los desarrolladores deberían usar Snyk para la seguridad de JavaScript

En esta publicación del blog, repasamos cinco fragmentos esenciales de código de seguridad de Node.js que todo desarrollador backend debería conocer. Hablamos de la importancia de las prácticas de programación segura, como evitar la inyección SQL, y de su importante contribución a la seguridad de las aplicaciones. Con la evolución de la tecnología y la creciente complejidad de las amenazas cibernéticas, no se puede exagerar la importancia de programar de forma segura.

Como desarrollador, es fundamental aprovechar herramientas de seguridad sólidas que te ayuden a identificar y mitigar posibles vulnerabilidades en tu código. Una de ellas es Snyk, una potente plataforma de seguridad para desarrolladores que permite detectar y corregir vulnerabilidades en el código, las dependencias, los contenedores y mucho más. Con Snyk, puedes monitorear continuamente tu aplicación para detectar vulnerabilidades de seguridad y recibir solicitudes de cambios de corrección automáticas cuando se descubre una nueva vulnerabilidad.

1// Install Snyk CLI
2npm install -g snyk
3
4// Then run Snyk to find vulnerabilities
5snyk test

Snyk se integra sin problemas en tus IDE y tu canalización de CI/CD, lo que te permite mantener la seguridad de forma continua durante todo el ciclo de vida del desarrollo de tus aplicaciones. Es compatible con una amplia variedad de lenguajes de programación, incluido Node.js, por lo que es una herramienta versátil para desarrolladores que trabajan en distintas plataformas.

La programación segura es una práctica fundamental en el desarrollo de software que todos los desarrolladores de backend deberían priorizar. El uso de herramientas de seguridad como Snyk refuerza esta práctica al ofrecer capacidades automatizadas para detectar vulnerabilidades y corregirlas. A medida que seguimos enfrentando un panorama de ciberamenazas en constante evolución, estas prácticas y herramientas serán esenciales para mantener la seguridad y la integridad de nuestras aplicaciones.