Introduction
File transfer is a common task for Linux users, developers, system administrators, and DevOps professionals. When files need to be moved between computers or servers, security is an important consideration.
Linux provides several tools for securely transferring files. One of the most commonly known approaches is secure copy, generally associated with the scp command. It allows users to copy files between local and remote systems through an SSH-secured connection.
Secure copying is useful for application deployment, server administration, backups, configuration transfers, and moving files between development and production environments.
What Is Secure Copy in Linux?
Secure Copy, commonly abbreviated as SCP, is a method of copying files between systems using SSH.
Unlike traditional file-transfer methods that may transmit information without encryption, SCP uses the SSH protocol to provide encrypted communication.
A basic example is:
scp file.txt user@example.com:/home/user/
This copies file.txt from the local system to the remote server.
The remote server must have SSH access configured, and the user must have permission to write to the destination directory.
Why Use Secure Copy?
Secure file copying is useful when transferring information that should not be exposed during transmission.
Common use cases include:
Uploading application files to a server
Downloading server logs
Moving configuration files
Transferring backups
Copying deployment packages
Moving files between development and production systems
Transferring files between Linux servers
Because the connection is protected through SSH, the data is transferred through an encrypted communication channel.
Basic Secure Copy Syntax
The general syntax is:
scp [options] source destination
To copy a local file to a remote system:
scp file.txt username@remote-host:/path/
To copy a remote file to the local system:
scp username@remote-host:/path/file.txt .
The direction of the transfer is determined by which side contains the remote host.
Copy a File to a Remote Server
Suppose you have:
website.zip
on your local computer and want to upload it to a remote server.
Use:
scp website.zip user@example.com:/home/user/
After authentication, the file is transferred to /home/user/.
You can also specify a particular destination filename:
scp website.zip user@example.com:/home/user/new-website.zip
Copy a File From a Remote Server
To download a file:
scp user@example.com:/home/user/website.zip .
The . represents the current directory.
You can specify another destination:
scp user@example.com:/home/user/website.zip /home/user/downloads/
Copy an Entire Directory
To securely copy a directory and its contents, use the recursive option:
scp -r project user@example.com:/home/user/
The -r option allows SCP to recursively copy directories.
For example:
project/
├── index.html
├── css/
├── js/
└── images/
Running:
scp -r project user@example.com:/home/user/
copies the entire project directory and its contents.
Copy Multiple Files
You can transfer multiple files in a single command:
scp file1.txt file2.txt file3.txt user@example.com:/home/user/
You can also use shell patterns:
scp *.log user@example.com:/home/user/logs/
This can be useful when transferring several files that share a common extension.
Specify an SSH Port
SSH commonly uses port 22, but servers can be configured to listen on another port.
Use the uppercase -P option:
scp -P 2222 backup.zip user@example.com:/home/user/
Here, SCP connects to SSH port 2222.
Remember that -P is uppercase. Linux commands and their options are case-sensitive.
Use an SSH Private Key
When the remote server requires SSH key authentication, specify the private key with -i:
scp -i ~/.ssh/server-key.pem backup.zip user@example.com:/home/user/
This is commonly used when connecting to cloud-based Linux servers.
Private keys should be protected carefully and should never be shared publicly.
Use a Specific Remote Username
You can specify the remote username before the hostname:
scp application.zip deploy@example.com:/var/www/
Here, deploy is the account used on the remote server.
Using a dedicated deployment account can be preferable to using a highly privileged account.
Enable Verbose Output
If you experience problems with an SCP transfer, use:
scp -v file.txt user@example.com:/home/user/
The -v option provides additional SSH connection information.
This can help identify problems involving:
Authentication
SSH configuration
Host verification
Connection establishment
Permissions
Preserve File Attributes
The -p option attempts to preserve file modification times, access times, and modes:
scp -p file.txt user@example.com:/home/user/
This can be helpful when file metadata is important during a transfer.
Enable Compression
You can enable SSH compression with:
scp -C large-file.txt user@example.com:/home/user/
Compression can be useful when transferring data over slower connections.
However, files that are already compressed, such as ZIP archives and many image or video formats, may receive little benefit from additional compression.
Copy Files Between Remote Systems
SCP can also be used to copy files between remote systems:
scp user1@server1:/home/user/file.txt user2@server2:/home/user/
The exact behavior of remote-to-remote copying can depend on the SCP implementation and SSH configuration.
For complex server synchronization requirements, tools such as rsync may be more appropriate.
Secure Copy and SSH
SCP relies on SSH for secure communication.
SSH provides mechanisms for:
Authentication
Encryption
Host verification
Secure remote communication
This means that SCP inherits much of the security model of SSH.
For example, before transferring a file, the client establishes an SSH connection to the remote server and authenticates the remote user.
Password Authentication
A server may allow password-based SSH authentication.
For example:
scp file.txt user@example.com:/home/user/
The system may prompt you for the remote user's password.
For automated environments, password authentication is generally less convenient because scripts should not contain plaintext passwords.
SSH Key Authentication
SSH keys are commonly used for automated secure file transfers.
You can create an SSH key pair using:
ssh-keygen
After configuring the public key on the remote server, SCP can authenticate using the corresponding private key.
For example:
scp -i ~/.ssh/deployment_key application.zip deploy@example.com:/var/www/
This is particularly useful for deployment automation.
Secure Copy for Application Deployment
SCP can be used as part of a basic application deployment process.
For example:
scp application.tar.gz deploy@example.com:/tmp/
Then connect to the server:
ssh deploy@example.com
After connecting, you can extract and deploy the application.
For larger production environments, a CI/CD system is generally preferable because it can provide automated testing, deployment workflows, audit trails, and rollback mechanisms.
Secure Copy for Backups
SCP can be used to transfer backup files to another server.
For example:
scp database-backup.sql backup@example.com:/backups/
A more complete backup workflow might include:
Create the backup.
Verify that the backup completed successfully.
Transfer it securely.
Confirm that the transferred file exists.
Apply appropriate permissions.
Retain backups according to the organization's retention policy.
Secure transfer is only one part of a reliable backup strategy.
Secure Copy for Server Logs
Administrators may need to download logs from remote servers for troubleshooting.
For example:
scp user@example.com:/var/log/application.log .
This downloads the application log to the current directory.
For very large or frequently changing logs, other methods such as centralized logging systems may be more appropriate.
Secure Copy in Cloud Computing
SCP is commonly used when managing Linux instances in cloud environments.
For example:
scp -i cloud-key.pem application.zip ubuntu@203.0.113.10:/home/ubuntu/
This transfers an application package to the remote machine.
Cloud environments may also have firewall rules, security groups, and network access policies that determine whether SSH connections are permitted.
File Permissions After Secure Copy
After copying a file, check its permissions:
ls -l file.txt
For a remote file:
ssh user@example.com
ls -l /home/user/file.txt
The copied file may need appropriate ownership or permissions before an application can use it.
Avoid unnecessarily broad permissions such as:
chmod 777 file.txt
Instead, use the minimum permissions required by the application or user.
Common Secure Copy Errors
Permission Denied
You may receive:
Permission denied
Possible causes include:
Incorrect credentials
Invalid SSH key
Incorrect private-key permissions
Insufficient permissions on the destination
SSH access restrictions
First test the SSH connection:
ssh user@example.com
If SSH authentication fails, resolve that issue before troubleshooting SCP.
No Such File or Directory
An incorrect source or destination path can produce:
No such file or directory
Check the local file:
ls -l file.txt
For a remote path, connect through SSH and verify:
ssh user@example.com
ls -la /path/to/directory/
Connection Refused
A connection refusal may indicate:
SSH is not running
The wrong port was specified
A firewall is blocking access
The server is not reachable
If SSH uses port 2222:
ssh -p 2222 user@example.com
and:
scp -P 2222 file.txt user@example.com:/home/user/
SCP vs FTP
Traditional FTP does not provide the same security characteristics as SSH-based file transfer.
FTP can transmit credentials and data without encryption unless additional security mechanisms are configured.
SCP uses SSH encryption, making it a common choice when secure server-to-server file transfer is required.
For modern systems, SFTP is another SSH-based option that provides broader remote file-management capabilities.
SCP vs SFTP
SCP is primarily focused on copying files.
SFTP provides an interactive file-transfer environment and supports operations such as:
Listing remote directories
Uploading files
Downloading files
Renaming files
Creating directories
Removing files
For a simple one-time transfer, SCP can be convenient. For ongoing remote file management, SFTP may be a better choice.
SCP vs Rsync
Rsync is particularly useful for synchronizing directories.
For example:
rsync -avz project/ user@example.com:/home/user/project/
Unlike a simple full copy, rsync can identify changes and avoid retransferring unchanged data.
Use SCP when you need straightforward copying and consider rsync when you need repeated synchronization or efficient incremental transfers.
Secure Copy Best Practices
Follow these practices when using secure file copy:
Use SSH keys for automated transfers.
Protect private SSH keys carefully.
Use dedicated low-privilege accounts where possible.
Verify the remote server's host identity.
Check source and destination paths before transferring files.
Review permissions after copying sensitive files.
Avoid storing passwords directly in scripts.
Use appropriate SSH ports and firewall rules.
Avoid transferring sensitive data unnecessarily.
Consider SFTP or rsync when they better fit the workflow.
Frequently Asked Questions
What is secure copy in Linux?
Secure copy is a method of transferring files between systems through an SSH-secured connection. It is commonly implemented using the scp command.
How do I securely copy a file to a server?
Use:
scp file.txt user@example.com:/home/user/
How do I copy a directory securely?
Use the recursive option:
scp -r directory user@example.com:/home/user/
How do I use an SSH key with SCP?
Use the -i option:
scp -i ~/.ssh/my-key file.txt user@example.com:/home/user/
Is SCP encrypted?
SCP traditionally operates through SSH, which provides encrypted communication between the systems.
Should I use SCP or SFTP?
SCP is convenient for straightforward copying, while SFTP is better suited to interactive remote file management. The right choice depends on the specific requirement.
Conclusion
Secure copy in Linux provides a straightforward way to transfer files between local and remote systems through SSH. It is useful for server administration, application deployment, backup transfers, cloud infrastructure, and day-to-day Linux file management.
Understanding options such as -r, -P, -i, -p, and -v allows you to handle a wide range of secure file-transfer requirements.
For more advanced synchronization and remote file-management workflows, tools such as rsync and SFTP may provide additional capabilities. Choosing the right tool helps make file transfers more secure, reliable, and efficient.
Solace Infotech's sitemap lists secure cp (copy) as a dedicated Linux resource alongside SCP and other Linux command topics.
