Skip to main content

Use of an insecure channel - FTP

Need​

Secure transmission of customer information

Context​

  • Usage of C# for building robust and scalable applications
  • Usage of System for accessing and manipulating system-level resources and functionality
  • Usage of System.Net for network communication in .NET development

Description​

Non compliant code​

using System;
using System.Net;

public class FtpUploader
{
    public void UploadFile(string ftpUrl, string userName, string password, string localFilePath)
    {
        using (WebClient client = new WebClient())
        {
            client.Credentials = new NetworkCredential(userName, password);
            client.UploadFile(ftpUrl, WebRequestMethods.Ftp.UploadFile, localFilePath);
        }
    }
}

In the above code snippet, the FtpUploader class is used to upload files to a FTP server. The UploadFile method accepts a FTP URL, a username, a password, and a local file path as parameters.

The WebClient class is used to send data to and receive data from a FTP server. The Credentials property of the WebClient object is set to a new instance of NetworkCredential that takes the username and password as parameters. This is how the user is authenticated.

The UploadFile method of the WebClient object is used to upload the file to the FTP server. It takes the FTP URL, the method that the request uses (WebRequestMethods.Ftp.UploadFile), and the local file path as parameters.

The vulnerability in this code is that the data transmitted over the FTP server is not encrypted. This means that if an attacker is able to intercept the data being transmitted, they can read the username, password, and file data in plain text. This can lead to unauthorized access to the FTP server and the data being transmitted.

Steps​

  • Replace FTP protocol with a secure protocol such as SFTP or HTTPS.
  • Ensure that the server supports the chosen secure protocol.
  • Implement encryption for data transmission using SSL/TLS.
  • Use secure authentication mechanisms such as OAuth or token-based authentication.
  • Implement strong password policies and enforce password complexity.
  • Regularly update and patch the server and client software to address any security vulnerabilities.
  • Implement secure coding practices to prevent other vulnerabilities.

Compliant code​

using System;
using Renci.SshNet; // You need to install the SSH.NET NuGet package

public class SftpUploader
{
    public void UploadFile(string sftpUrl, string userName, string password, string localFilePath)
    {
        using (var sftp = new SftpClient(sftpUrl, userName, password))
        {
            sftp.Connect();
            using (var fileStream = new FileStream(localFilePath, FileMode.Open))
            {
                sftp.UploadFile(fileStream, Path.GetFileName(localFilePath));
            }
            sftp.Disconnect();
        }
    }
}

The previous code was vulnerable because it was using the FTP protocol to upload files, which is insecure because it does not encrypt the data being transmitted. This means that sensitive information such as usernames, passwords, and any data in the file being uploaded could be intercepted and read in plain text.

The new code fixes this vulnerability by using the SFTP protocol instead of FTP. SFTP, or SSH File Transfer Protocol, is a network protocol that provides file access, file transfer, and file management functionalities over any reliable data stream. It is typically used with the SSH-2 protocol to provide secure file transfer.

The SftpClient class from the SSH.NET library is used to establish an SFTP connection. The Connect method is used to open the connection, and the UploadFile method is used to upload the file. The Disconnect method is then used to close the connection.

This code assumes that the server supports the SFTP protocol. If it does not, you will need to configure the server to support SFTP or use another secure protocol that the server supports.

In addition to using a secure protocol, you should also implement other security measures such as secure authentication mechanisms, strong password policies, regular updates and patches, and secure coding practices.

References​

Last updated on