SFTP and SCP: Secure File Transfer Protocols

Every day, organizations transfer millions of files across networks—financial reports, source code, customer databases, medical records, and classified documents. For decades, the File Transfer Protocol (FTP) was the workhorse enabling this data movement. Yet beneath FTP's familiar interface lurked a catastrophic security flaw: every byte traveled in plain text.

Imagine sending your bank account credentials printed on a postcard through the postal system. Anyone handling that postcard—postal workers, neighbors, curious strangers—could read your sensitive information. Traditional FTP operates identically: credentials, commands, and file contents traverse networks as readable text, visible to any observer positioned along the data path.

This page explores why secure file transfer isn't optional in modern networks, the fundamental vulnerabilities we must address, and how cryptographic protocols transform dangerous data exposure into protected communication.

The File Transfer Protocol, standardized in RFC 959 (1985), was designed in an era of trusted networks and collaborative research communities. Security was an afterthought—or more accurately, not a thought at all. Understanding FTP's vulnerabilities illuminates why we need SFTP and SCP.

The Architecture of Exposure:

FTP operates on a model where security was never integrated into the protocol design. When you connect to an FTP server, the following occurs in completely unencrypted form:

The Dual-Connection Vulnerability:

FTP's architecture compounds security problems. The protocol uses separate connections for control (commands) and data (file contents):

1. Control Connection: Client initiates TCP connection to server port 21
2. Data Connection: Established separately for actual file transfer

In Active Mode, the server initiates the data connection back to the client—a design that conflicts with firewalls and NAT, forcing many organizations to use Passive Mode. But both modes share the same fundamental flaw: no encryption on either connection.

Firewalls attempting to protect FTP must perform deep packet inspection to track the PORT or PASV commands and dynamically open ports—a complex, error-prone process that creates additional attack surfaces.

Understanding secure file transfer requires appreciating the sophisticated threats organizations face today. The threat actors targeting file transfers range from opportunistic script kiddies to nation-state adversaries, each with distinct capabilities and motivations.

Categories of Attackers:

Attack Vectors Exploiting Insecure File Transfer:

The vulnerabilities of traditional FTP enable multiple attack methodologies:

Secure file transfer protocols address FTP's vulnerabilities through cryptography. Before examining SFTP and SCP specifically, we must understand the cryptographic primitives they employ.

The Security Services Required:

Secure file transfer must provide four fundamental security services, often called the security tetrad:

Symmetric vs. Asymmetric Encryption:

Secure protocols use both encryption paradigms, leveraging their respective strengths:

Symmetric Encryption uses a single shared key for both encryption and decryption. Algorithms like AES-256-GCM provide high throughput—critical for transferring large files. However, symmetric encryption has a key distribution problem: how do you securely share the key initially?

Asymmetric Encryption solves key distribution through mathematically related key pairs. The public key encrypts; only the corresponding private key decrypts. RSA, ECDSA, and Ed25519 enable key exchange and digital signatures. However, asymmetric operations are computationally expensive—roughly 1000x slower than symmetric encryption.

The Hybrid Solution:

Modern secure protocols combine both approaches:

1. Use asymmetric cryptography to authenticate parties and establish a shared session key
2. Use symmetric cryptography with that session key for efficient bulk data encryption
3. Generate new session keys for each connection (perfect forward secrecy)

Both SFTP and SCP build upon the Secure Shell (SSH) protocol. Understanding SSH is essential for mastering secure file transfer, as SSH provides the cryptographic tunnel through which these protocols operate.

SSH Origins and Evolution:

SSH emerged in 1995, created by Tatu Ylönen at Helsinki University of Technology after a password-sniffing attack on his university network. The protocol was designed to replace insecure remote access tools: Telnet (unencrypted remote shell), rlogin (trusted host authentication), and rsh (remote shell with .rhosts trust).

SSH-1 (1995) introduced encrypted remote access but had cryptographic weaknesses. SSH-2 (2006, RFC 4251-4256) completely redesigned the protocol with modern cryptographic architecture and remains the current standard.

SSH Protocol Architecture:

SSH operates as a layered protocol stack, with each layer providing specific functionality:

SSH Transport Layer Deep Dive:

The transport layer establishes the encrypted tunnel. Upon connection:

1. Version Exchange: Client and server exchange SSH version strings
2. Algorithm Negotiation: Both sides propose supported key exchange, encryption, MAC, and compression algorithms; first mutually supported option is selected
3. Key Exchange: Typically Diffie-Hellman or Elliptic Curve DH produces shared secrets
4. Server Authentication: Server proves identity via its host key; client verifies against known_hosts
5. Encryption Activated: All subsequent packets encrypted with negotiated algorithms

This layered separation enables SSH to tunnel arbitrary protocols—including SFTP and SCP—through the secure channel.

With SSH providing secure channels, two distinct file transfer approaches emerged: SCP and SFTP. Understanding their historical development clarifies their design philosophies and appropriate use cases.

The SCP Origin Story:

Secure Copy (SCP) appeared alongside SSH in 1995 as a direct replacement for rcp (remote copy). The design philosophy was simplicity: take the familiar cp (copy) command semantics and tunnel them through SSH. SCP inherited rcp's protocol—essentially sending shell commands and piping file data—but wrapped everything in encryption.

This simplicity had advantages: SCP was immediately usable by anyone familiar with cp, worked through any SSH connection, and required no additional server software. However, SCP's design limitations became apparent as needs evolved:

• No directory listing capability (must use separate ssh commands)
• Limited file metadata handling
• No resume capability for interrupted transfers
• Vulnerable to protocol-level attacks in certain implementations

The SFTP Revolution:

SSH File Transfer Protocol (SFTP, not to be confused with FTPS) was designed from scratch as a proper file transfer protocol, not a command wrapper. First appearing as an Internet Draft in 1997 and formalized in RFC 4253, SFTP provides:

• Full filesystem operations (list, create, delete, rename, permissions)
• Platform-independent file handling
• Resume capability for interrupted transfers
• Extensibility for future functionality
• Consistent behavior across implementations

SFTP operates as an SSH subsystem—a specialized service multiplexed over an SSH connection. This design leverages SSH's security completely while providing rich file transfer functionality.

Before proceeding deeper into SFTP and SCP, we should acknowledge FTPS—FTP Secure—which represents a different approach to securing file transfers. Understanding FTPS clarifies why SSH-based solutions often prove superior.

What is FTPS?

FTPS wraps traditional FTP with TLS (Transport Layer Security) encryption. Two variants exist:

• Explicit FTPS (FTPES): Client connects to standard FTP port (21), then explicitly requests encryption via AUTH TLS command. Allows optional encryption.
• Implicit FTPS: Client connects to dedicated port (990), TLS negotiation begins immediately. All communication encrypted.

FTPS leverages the existing FTP protocol entirely, adding encryption as a wrapper rather than redesigning the protocol.

Why SFTP Often Wins:

While FTPS provides encryption, it inherits FTP's architectural problems:

1. Port Complexity: FTPS still uses separate control and data connections. Firewalls must track TLS-encrypted PORT/PASV negotiations—often requiring deep packet inspection or blind port ranges.

2. NAT Traversal: The data connection negotiation embedded in encrypted control traffic breaks NAT traversal. Many FTPS deployments struggle with NAT firewalls.

3. Certificate Overhead: FTPS requires X.509 certificates from a trusted CA or self-signed certificates with distribution challenges. SSH's TOFU model is often simpler for server-to-server transfers.

4. No Native Filesystem Operations: FTPS is still FTP—limited commands, platform-specific path handling, and ASCII vs. binary mode concerns.

SFTP's single-port, SSH-based design avoids these complications while providing richer functionality.

Let's examine how SFTP and SCP concretely provide the security services we identified earlier. Understanding these mechanisms helps you evaluate security posture and troubleshoot issues.

Confidentiality Through Encryption:

Both SFTP and SCP encrypt all data through SSH's symmetric encryption. Modern SSH supports multiple cipher options:

Integrity Through MACs:

Every SSH packet includes a Message Authentication Code computed over the packet contents and a sequence number (preventing replay attacks). AEAD ciphers (GCM, Poly1305) provide integrated authentication. Non-AEAD ciphers use separate MAC algorithms:

• hmac-sha2-256: 256-bit HMAC using SHA-256
• hmac-sha2-512: 512-bit HMAC using SHA-512
• umac-128@openssh.com: Fast universal MAC

Any modification to packet contents—even a single bit flip—causes MAC verification to fail, and the connection terminates.

Authentication Mechanisms:

SSH supports multiple client authentication methods, each with distinct security properties:

We've established the comprehensive foundation for understanding secure file transfer. Let's consolidate the essential concepts before diving into SFTP and SCP protocol specifics.

What's Next:

With this security foundation established, the next page explores the SFTP protocol in depth. We'll examine the protocol architecture, command structure, session lifecycle, and the rich filesystem operations that make SFTP the standard for secure file transfer in modern enterprise environments.