File Transfer

# Upload local file to remote
scp /local/path/file.txt user@remote_host:/remote/path/

# Download file from remote
scp user@remote_host:/remote/path/file.txt /local/destination/

# Copy entire directory (recursive)
scp -r /local/dir/ user@remote_host:/remote/dir/

# Use non-default SSH port
scp -P 2222 file.txt user@remote_host:/remote/path/

# Use specific private key
scp -i ~/.ssh/id_rsa file.txt user@remote_host:/remote/path/

# Copy between two remote hosts
scp user1@host1:/path/file.txt user2@host2:/path/

# Compress during transfer
scp -C large_file.tar user@remote_host:/path/

# Limit bandwidth (KB/s)
scp -l 1024 file.txt user@remote_host:/path/

# Verbose mode
scp -v file.txt user@remote_host:/path/

# Connect to remote host
sftp user@remote_host

# Connect on non-default port
sftp -oPort=2222 user@remote_host

# Use a specific private key
sftp -o IdentityFile=~/.ssh/id_rsa user@remote_host

# ── Inside the SFTP session ──────────────────────────────
sftp> pwd                      # Print remote working directory
sftp> lpwd                     # Print local working directory
sftp> ls                       # List remote files
sftp> lls                      # List local files
sftp> cd /remote/path          # Change remote directory
sftp> lcd /local/path          # Change local directory

sftp> put file.txt             # Upload local file to remote
sftp> put -r ./local_dir       # Upload directory recursively
sftp> get remote_file.txt      # Download file from remote
sftp> get -r remote_dir/       # Download directory recursively
sftp> mput *.txt               # Upload multiple files
sftp> mget *.log               # Download multiple files

sftp> mkdir new_dir            # Create remote directory
sftp> rmdir empty_dir          # Remove empty remote directory
sftp> rm remote_file.txt       # Delete remote file
sftp> rename old.txt new.txt   # Rename remote file
sftp> chmod 755 script.sh      # Change remote file permissions

sftp> !ls                      # Run local shell command without exiting
sftp> bye                      # Exit SFTP session

# Basic sync local → remote
rsync -avz /local/dir/ user@remote_host:/remote/dir/

# Basic sync remote → local
rsync -avz user@remote_host:/remote/dir/ /local/dir/

# Key flags:
#   -a  archive mode (recursive + preserve permissions, timestamps, symlinks)
#   -v  verbose
#   -z  compress data during transfer
#   -P  show progress and allow resume (--partial --progress)
#   -n  dry run (simulate without transferring)
#   --delete  delete remote files that no longer exist locally

# Show progress
rsync -avzP /local/dir/ user@remote_host:/remote/dir/

# Dry run first (preview what will change)
rsync -avzn /local/dir/ user@remote_host:/remote/dir/

# Use non-default SSH port
rsync -avz -e "ssh -p 2222" /local/dir/ user@remote_host:/remote/dir/

# Use specific SSH key
rsync -avz -e "ssh -i ~/.ssh/id_rsa" /local/dir/ user@remote_host:/remote/dir/

# Mirror directory (delete files removed at source)
rsync -avz --delete /local/dir/ user@remote_host:/remote/dir/

# Exclude files/patterns
rsync -avz --exclude='*.log' --exclude='.git/' /local/dir/ user@remote_host:/remote/dir/

# Limit bandwidth (KB/s)
rsync --bwlimit=500 -avz /local/dir/ user@remote_host:/remote/dir/

# Backup (append timestamp suffix to changed files)
rsync -avz --backup --backup-dir=/backup/$(date +%Y%m%d) /local/dir/ /backup/current/

# Download file (save with original name)
wget http://example.com/file.zip

# Save with a different name
wget -O output.zip http://example.com/file.zip

# Download to specific directory
wget -P /tmp/ http://example.com/file.zip

# Resume interrupted download
wget -c http://example.com/large_file.iso

# Download in background
wget -b http://example.com/file.zip

# Limit download speed
wget --limit-rate=500k http://example.com/file.zip

# Download multiple files from a list
wget -i urls.txt

# Mirror a website
wget --mirror --convert-links --no-parent http://example.com/

# Skip SSL certificate check
wget --no-check-certificate https://example.com/file.zip

# Authenticate with HTTP basic auth
wget --user=username --password=secret http://example.com/private/file.zip

# Download via FTP
wget ftp://ftp.example.com/pub/file.tar.gz

# Retry on failure
wget --tries=5 http://example.com/file.zip

# Quiet mode (no output)
wget -q http://example.com/file.zip

# Download file (output to stdout — pipe or redirect)
curl http://example.com/file.txt

# Save with remote filename
curl -O http://example.com/file.zip

# Save with custom filename
curl -o myfile.zip http://example.com/file.zip

# Resume interrupted download
curl -C - -O http://example.com/large_file.iso

# Follow redirects
curl -L http://example.com/redirect

# Limit download speed
curl --limit-rate 500k -O http://example.com/file.zip

# Upload file with HTTP POST (multipart form)
curl -X POST -F "file=@/local/file.txt" http://example.com/upload

# Upload file with PUT
curl -T /local/file.txt http://example.com/upload/file.txt

# HTTP Basic authentication
curl -u username:password http://example.com/private/file.txt

# Send custom headers
curl -H "Authorization: Bearer TOKEN" http://example.com/api/file

# Skip SSL certificate verification
curl -k https://example.com/file.zip

# Download via FTP
curl -u user:pass ftp://ftp.example.com/file.tar.gz

# Upload to FTP
curl -T file.txt ftp://ftp.example.com/ -u user:pass

# Download via SCP
curl -u user: --key ~/.ssh/id_rsa --pubkey ~/.ssh/id_rsa.pub \
  scp://remote_host/path/to/file.txt -o file.txt

# Show download progress
curl --progress-bar -O http://example.com/file.zip

# Verbose output
curl -v http://example.com/file.txt

# ── Receiving end (listener) — run this FIRST ───────────
nc -lvp 4444 > received_file.txt

# ── Sending end ─────────────────────────────────────────
nc <receiver_ip> 4444 < file_to_send.txt

# ── Transfer a directory (tar on-the-fly) ───────────────
# Receiver:
nc -lvp 4444 | tar xzf -

# Sender:
tar czf - /path/to/dir | nc <receiver_ip> 4444

# ── Using /dev/tcp (no nc required on sender) ───────────
# Receiver:
nc -lvp 4444 > file.txt

# Sender (Bash built-in):
cat file.txt > /dev/tcp/<receiver_ip>/4444

# ── Using ncat (with SSL encryption) ────────────────────
# Receiver:
ncat -lvp 4444 --ssl > file.txt

# Sender:
ncat <receiver_ip> 4444 --ssl < file.txt

# Python 3 — serve current directory on port 8080
python3 -m http.server 8080

# Python 3 — serve a specific directory
python3 -m http.server 8080 --directory /path/to/files

# Python 2 (legacy)
python2 -m SimpleHTTPServer 8080

# Python 3 with upload support (requires pip install uploadserver)
pip install uploadserver
python3 -m uploadserver 8080

# Download from the server on any machine:
wget http://<server_ip>:8080/file.txt
curl -O http://<server_ip>:8080/file.txt

# Connect to FTP server
ftp ftp.example.com

# Connect with specific port
ftp -p ftp.example.com 2121

# ── Inside FTP session ───────────────────────────────────
ftp> ls                        # List remote files
ftp> cd /remote/path           # Change remote directory
ftp> lcd /local/path           # Change local directory
ftp> get file.txt              # Download file
ftp> mget *.txt                # Download multiple files
ftp> put file.txt              # Upload file
ftp> mput *.txt                # Upload multiple files
ftp> binary                    # Switch to binary transfer mode
ftp> ascii                     # Switch to ASCII mode
ftp> passive                   # Toggle passive mode
ftp> bye                       # Disconnect

# Non-interactive download (one-liner)
ftp -n -v ftp.example.com << EOF
user username password
binary
get file.txt
bye
EOF

# Encode file to base64
base64 -w 0 file.bin > file.b64

# Decode on receiving end
base64 -d file.b64 > file.bin

# One-liner: encode, copy to clipboard (Linux)
base64 -w 0 file.bin | xclip -selection clipboard

# Verify integrity with md5sum
md5sum file.bin             # Before encoding
base64 -d file.b64 | md5sum # After decoding — should match

# Start SMB server (unauthenticated, current directory)
sudo impacket-smbserver ShareName $(pwd) -smb2support

# Start with authentication (required in newer Windows versions)
sudo impacket-smbserver ShareName $(pwd) -smb2support -user myuser -password mypass

# Download with Python 3
python3 -c 'import urllib.request; urllib.request.urlretrieve("http://example.com/file.txt", "file.txt")'

# Download with requests library
python3 -c 'import requests; open("file.txt","wb").write(requests.get("http://example.com/file.txt").content)'

# Upload via POST
python3 -c 'import requests; requests.post("http://server/upload", files={"file": open("file.txt","rb")})'

# Download a file
php -r '$file = file_get_contents("http://example.com/file.txt"); file_put_contents("file.txt", $file);'

# Stream large file
php -r 'const BUF=4096; $r=fopen("http://example.com/big.bin","rb"); $w=fopen("big.bin","wb"); while($b=fread($r,BUF)){fwrite($w,$b);} fclose($r); fclose($w);'

# Download a file
ruby -e 'require "net/http"; File.write("file.txt", Net::HTTP.get(URI("http://example.com/file.txt")))'

# Download a file
perl -e 'use LWP::Simple; getstore("http://example.com/file.txt", "file.txt");'

# Download a file (Node.js)
node -e "const fs=require('fs'),https=require('https'); https.get('https://example.com/file.txt', r=>r.pipe(fs.createWriteStream('file.txt')))"

# Linux — tar + gzip before large transfers
tar czf archive.tar.gz /path/to/dir
scp archive.tar.gz user@remote:/path/
# On remote:
tar xzf archive.tar.gz

# Now you can use:
scp file.txt myserver:/remote/path/
rsync -avz ./dir/ myserver:/remote/dir/
sftp myserver

# Linux
md5sum file.zip
sha256sum file.zip

# PowerShell
Get-FileHash C:\Temp\file.zip -Algorithm MD5
Get-FileHash C:\Temp\file.zip -Algorithm SHA256