Skip to main content

Insecure encryption algorithm - Perfect Forward Secrecy

Need​

Implementation of secure encryption algorithms with Perfect Forward Secrecy

Context​

  • Usage of TypeScript for statically typed JavaScript development
  • Usage of Express for building web applications and APIs
  • Usage of HTTPS for secure communication over the internet
  • Usage of fs for file system operations

Description​

Non compliant code​

import express from 'express';
import https from 'https';
import fs from 'fs';

const app = express();

const options = {
  key: fs.readFileSync('private-key.pem'),
  cert: fs.readFileSync('public-cert.pem')
};

app.get('/', (req, res) => {
  const sensitiveData = 'This is sensitive information';
  res.send(sensitiveData);
});

https.createServer(options, app).listen(3000, () => {
  console.log('Server running on port 3000');
});

The vulnerability in this code is the use of an insecure encryption algorithm, specifically the lack of Perfect Forward Secrecy (PFS). PFS ensures that even if the private key used for encryption is compromised, past communications cannot be decrypted.

In this code, an HTTPS server is created using the https module from Node.js. The server is configured with a private key and a public certificate, which are read from files using the fs module. However, the code does not specify any specific cipher suites or enable Perfect Forward Secrecy.

Without enabling PFS, if the private key used for encryption is compromised, an attacker could potentially decrypt all past communications made with the server. This means that any sensitive information transmitted or stored by the application could be obtained by an attacker.

To fix this vulnerability, the code should be updated to enable Perfect Forward Secrecy by allowing cipher suites that contain Diffie-Hellman Ephemeral (DHE) or Elliptic Curve Diffie-Hellman Ephemeral (ECDHE) algorithms. This ensures that a new session key is generated for each session, providing forward secrecy even if the private key is compromised.

Steps​

  • Generate a new private key and certificate using a secure encryption algorithm
  • Enable Perfect Forward Secrecy by configuring the server to use Ciphersuites that contain DHE and ECDHE
  • Update the code to use the new private key and certificate in the options object
  • Restart the server to apply the changes

Compliant code​

import express from 'express';
import https from 'https';
import fs from 'fs';

const app = express();

const options = {
  key: fs.readFileSync('new-private-key.pem'),
  cert: fs.readFileSync('new-public-cert.pem'),
  ciphers: [
    'ECDHE-RSA-AES128-GCM-SHA256',
    'ECDHE-ECDSA-AES128-GCM-SHA256',
    'DHE-RSA-AES128-GCM-SHA256',
    'DHE-DSS-AES128-GCM-SHA256',
    'ECDHE-RSA-AES256-GCM-SHA384',
    'ECDHE-ECDSA-AES256-GCM-SHA384',
    'DHE-RSA-AES256-GCM-SHA384',
    'DHE-DSS-AES256-GCM-SHA384',
    'ECDHE-RSA-AES128-SHA256',
    'ECDHE-ECDSA-AES128-SHA256',
    'ECDHE-RSA-AES128-SHA',
    'ECDHE-ECDSA-AES128-SHA',
    'ECDHE-RSA-AES256-SHA384',
    'ECDHE-ECDSA-AES256-SHA384',
    'ECDHE-RSA-AES256-SHA',
    'ECDHE-ECDSA-AES256-SHA',
    'DHE-RSA-AES128-SHA256',
    'DHE-RSA-AES128-SHA',
    'DHE-DSS-AES128-SHA256',
    'DHE-RSA-AES256-SHA256',
    'DHE-DSS-AES256-SHA',
    'DHE-RSA-AES256-SHA'
  ].join(':')
};

app.get('/', (req, res) => {
  const sensitiveData = 'This is sensitive information';
  res.send(sensitiveData);
});

https.createServer(options, app).listen(3000, () => {
  console.log('Server running on port 3000');
});

The fixed code addresses the vulnerability by enabling Perfect Forward Secrecy (PFS) in the server-side configuration. PFS ensures that even if the private key is compromised, past communications cannot be decrypted.

Here's an explanation of the fixed code:

  1. The code imports the necessary modules: express, https, and fs.

  2. The app variable is initialized as an instance of the Express application.

  3. The options object is created to configure the HTTPS server. It includes the following properties:

    • key: The private key file used for encryption. It is read from the 'new-private-key.pem' file.
    • cert: The public certificate file used for encryption. It is read from the 'new-public-cert.pem' file.
    • ciphers: A list of supported cipher suites that enable PFS. The list includes various combinations of ECDHE (Elliptic Curve Diffie-Hellman Ephemeral) and DHE (Diffie-Hellman Ephemeral) algorithms with different AES encryption strengths.

  4. The Express app defines a single route for the root URL ('/'). When this route is accessed, it sends a response containing the sensitive data.

  5. The https.createServer function is used to create an HTTPS server. It takes the options object and the app as arguments. The server listens on port 3000.

  6. Finally, a log message is printed to indicate that the server is running on port 3000.

By configuring the server with the appropriate cipher suites that support PFS, the fixed code ensures that sensitive information transmitted or stored by the application is protected even if the private key is compromised.

References​

Last updated on