CWE-322: Key Exchange without Entity Authentication

What is Key Exchange without Entity Authentication?

• Overview: Key Exchange without Entity Authentication (CWE-322) occurs when a system performs a key exchange without verifying the identity of the other party involved, potentially allowing an attacker to impersonate a trusted entity.

• Exploitation Methods:

• Attackers can intercept or modify traffic between two entities during the key exchange.
• Common attack patterns include man-in-the-middle attacks where a malicious server impersonates a trusted server to a client.

• Security Impact:

• Direct consequences include unauthorized access to sensitive information and potential data breaches.
• Potential cascading effects involve the attacker gaining further access to secure systems using stolen credentials.
• Business impact can include loss of customer trust, legal liabilities, and financial losses due to data breaches.

• Prevention Guidelines:

• Implement mutual authentication to ensure both parties in a key exchange verify each other's identities.
• Use cryptographic protocols that support entity authentication, such as TLS with client and server certificates.
• Recommended tools include libraries that facilitate secure key exchanges, such as OpenSSL for SSL/TLS communication.
• Follow security best practices by regularly updating cryptographic libraries and protocols to protect against known vulnerabilities.

Corgea can automatically detect and fix Key Exchange without Entity Authentication in your codebase. Try Corgea free today.

Technical Details

Likelihood of Exploit: High

Affected Languages: Not Language-Specific

Affected Technologies: Not specified

Vulnerable Code Example

const net = require('net');

const client = new net.Socket();
client.connect(8080, 'example.com', function() {
    console.log('Connected to server');

    // Vulnerable: No verification of the server's identity
    // This is susceptible to Man-in-the-Middle (MitM) attacks, as the client 
    // blindly trusts the server without any authentication.
    client.write('Client public key');
});

client.on('data', function(data) {
    console.log('Received: ' + data);
    client.destroy(); // Close the client connection after receiving data
});

How to fix Key Exchange without Entity Authentication?

In JavaScript, particularly with Node.js, the tls module should be used to create a secure connection that verifies the server's identity. This ensures that the server's certificate is validated against a trusted Certificate Authority (CA), thereby safeguarding against MitM attacks. Using tls.connect(), you can establish a TLS connection that handles both authentication and encryption.

Fixed Code Example

const tls = require('tls');
const fs = require('fs');

// Securely connect to the server using TLS
const options = {
    // Ensure the server's identity is verified against a trusted CA
    ca: [fs.readFileSync('trusted-cert.pem')],
    host: 'example.com',
    port: 8080,
    // Optionally, you can specify the server name for SNI (Server Name Indication)
    servername: 'example.com'
};

const client = tls.connect(options, () => {
    console.log('Connected to server securely');
    console.log('Cipher: ', client.getCipher());

    // Securely perform the key exchange
    client.write('Client public key');
});

client.on('data', (data) => {
    console.log('Received: ' + data);
    client.end(); // Properly close the client connection
});

In the fixed example, the critical change is wrapping the communication in a secure layer (SSL/TLS) to authenticate the server's identity, preventing unauthorized interception or MitM attacks during the key exchange process. The use of a trusted CA certificate ensures that the server is indeed who it claims to be, protecting the integrity of the key exchange.