Cara Amankan Akses SSH Server Linux dengan Tailscale

SSH lewat port 22 yang terbuka ke internet publik selalu jadi target empuk buat attacker. Cukup jalankan nmap ke rentang IP mana pun, dan port 22 yang terbuka akan langsung ketahuan, lalu diserbu percobaan login brute-force tanpa henti. Tailscale menawarkan pendekatan berbeda: server cukup menerima koneksi SSH dari jaringan privat berbasis WireGuard, lalu port SSH di antarmuka publik ditutup rapat lewat firewall. Sysadmin dan developer tetap bisa remote kapan pun dibutuhkan, tapi lewat jalur yang jauh lebih sulit ditembus attacker dari luar.

Risiko SSH Terbuka ke Publik

Server dengan port 22 terbuka ke internet menghadapi tiga masalah klasik. Pertama, serangan brute-force yang mencoba ribuan kombinasi username dan password secara otomatis. Kedua, port scanning massal yang dilakukan bot maupun attacker untuk memetakan server mana saja yang punya SSH terbuka, lalu dijadikan target lanjutan. Ketiga, pengelolaan SSH key yang makin merepotkan begitu jumlah server dan developer yang butuh akses bertambah, karena setiap penambahan atau pencabutan akses berarti mengedit file authorized_keys di banyak mesin sekaligus.

Solusi umum seperti mengganti port SSH default atau memasang fail2ban memang membantu, tapi keduanya cuma mengurangi gejala, bukan menghilangkan akar masalah: port SSH tetap terekspos ke internet. Tailscale mengambil pendekatan lain dengan memindahkan verifikasi akses ke lapisan identitas tailnet, lalu menutup akses publik itu sepenuhnya lewat firewall.

Tailscale sebagai Mesh VPN

Tailscale adalah mesh VPN yang dibangun di atas protokol WireGuard, menghubungkan server dan perangkat klien lewat jaringan privat yang disebut tailnet. Berbeda dari VPN tradisional yang butuh satu server pusat sebagai gateway, arsitektur mesh membuat setiap perangkat dalam tailnet bisa saling terhubung langsung (peer-to-peer) tanpa melewati server perantara, selama koneksi jaringan mengizinkan. Kalau koneksi langsung terhalang NAT atau firewall yang ketat, Tailscale otomatis mengalihkan trafik lewat server relay (DERP) miliknya sendiri.

Karena berjalan di atas jaringan privat ini, server tidak perlu melakukan port forwarding apa pun di router atau firewall publik untuk bisa diakses. Sysadmin cukup memasang agen Tailscale di sisi server Linux maupun di setiap perangkat klien (laptop atau PC) yang butuh akses, lalu keduanya otomatis saling mengenali begitu berada di tailnet yang sama.

Prasyarat Instalasi

Sebelum mulai, pastikan kebutuhan berikut sudah tersedia:

Server Linux dengan akses sudo atau root.
Perangkat klien (Linux, macOS, atau Windows) yang juga punya akses admin untuk instalasi software.
Akun Tailscale aktif. Pendaftaran bisa lewat akun GitHub, Google, atau Microsoft yang sudah ada, tanpa perlu membuat password baru khusus Tailscale.

Instalasi Tailscale di Klien

Klien adalah perangkat yang dipakai sysadmin atau developer untuk mengakses server lewat SSH. Cara instalasinya beda tipis tergantung sistem operasi yang dipakai.

Kalau klien memakai Linux, jalankan script instalasi resmi lewat terminal, sama seperti di sisi server:

curl -fsSL https://tailscale.com/install.sh | sh

Lanjutkan dengan menghubungkan perangkat ke tailnet:

sudo tailscale up

Perintah ini menampilkan URL autentikasi yang perlu dibuka lewat browser untuk login memakai akun yang sudah didaftarkan sebelumnya.

Kalau klien memakai macOS, Windows, iOS, atau Android, unduh installer resmi sesuai sistem operasi dari halaman download Tailscale, lalu pasang seperti aplikasi biasa. Setelah terpasang, buka aplikasi Tailscale dan lakukan autentikasi lewat GUI memakai akun yang sama.

Setelah login berhasil di kedua metode, perangkat klien otomatis muncul di halaman Machines pada admin console Tailscale.

Instalasi Tailscale di Server

Setelah klien siap, langkah berikutnya memasang agen Tailscale di server Linux yang akan diamankan. Tailscale menyediakan satu script instalasi resmi yang otomatis mendeteksi distribusi dan versi sistem operasi, lalu menambahkan repository paket yang sesuai. Script ini bekerja di hampir semua distribusi Linux populer, jadi tidak perlu langkah manual berbeda-beda per distro.

Jalankan script instalasi resmi Tailscale:
```
curl -fsSL https://tailscale.com/install.sh | sh
```
Script ini menambahkan repository paket Tailscale, menginstal binary tailscale, lalu mengaktifkan service tailscaled agar berjalan otomatis saat boot.
Hubungkan server ke tailnet:
```
sudo tailscale up
```
Buka URL autentikasi yang muncul di terminal, lalu login dengan akun Tailscale yang sama dengan yang dipakai di klien.

Kalau distro server tidak masuk daftar yang didukung script ini, atau sysadmin memang lebih suka instalasi manual lewat repository resmi per distro, langkah lengkapnya tersedia di halaman download Linux Tailscale.

Konfigurasi Akses SSH

Server dan klien yang sudah terhubung ke tailnet yang sama otomatis bisa saling menjangkau lewat IP privat Tailscale, tanpa perlu konfigurasi jaringan tambahan.

Cek IP Tailscale Server

Setiap perangkat di tailnet mendapat alamat IP privat unik dalam rentang 100.x.y.z (CGNAT range). Cek alamat ini di server dengan perintah:

tailscale ip -4

Perintah ini mengembalikan IP Tailscale server, misalnya 100.101.102.103. IP ini tidak berubah selama perangkat tidak dihapus dari tailnet, jadi aman dipakai sebagai alamat tetap untuk koneksi SSH berikutnya.

Uji Koneksi SSH lewat Tailscale

Dari perangkat klien, coba hubungkan ke server memakai IP Tailscale yang didapat sebelumnya, bukan IP publik server:

ssh [email protected]

Kalau koneksi berhasil, jalur SSH lewat tailnet sudah berfungsi dan siap dipakai sebagai jalur akses utama ke server.

Tailscale SSH tanpa Key Manual

Selain SSH konvensional lewat IP Tailscale, Tailscale menyediakan fitur Tailscale SSH yang mengambil alih otentikasi dan otorisasi koneksi port 22 dari sesama anggota tailnet, tanpa mengubah konfigurasi /etc/ssh/sshd_config di server.

Cara kerjanya berbeda dari SSH biasa. Begitu koneksi masuk lewat antarmuka tailscale0, tailscaled di server langsung mencegat trafik ke port 22 sebelum sampai ke sshd. Karena identitas pemanggil sudah diketahui lewat kunci WireGuard yang dipakai saat handshake tailnet, server tidak perlu lagi meminta bukti tambahan seperti password atau public key SSH, sesi cukup diotorisasi lewat kebijakan ACL yang berlaku. Kunci host SSH-nya sendiri dibuat otomatis oleh Tailscale saat fitur ini pertama kali diaktifkan, dan tidak perlu dikelola manual.

Aktifkan fitur ini di server dengan:

sudo tailscale set --ssh

Di sisi klien, tidak ada perintah khusus yang perlu dijalankan. Cukup pakai perintah ssh biasa seperti sebelumnya, memakai IP Tailscale atau nama perangkat (hostname) di tailnet:

ssh [email protected]

Tailscale otomatis mengenali bahwa koneksi ini datang dari sesama anggota tailnet, lalu memverifikasi apakah user tersebut diizinkan login lewat kebijakan ACL, sebelum meneruskan sesi ke sshd.

Setelah diaktifkan, siapa saja yang boleh login dan sebagai user apa diatur lewat Access Controls (ACL) di admin console Tailscale, bukan lewat authorized_keys. Contoh aturan ACL yang mengizinkan user tertentu login sebagai root atau user non-root di perangkat bertanda tag:prod:

"ssh": [
  {
    "action": "accept",
    "src":    ["autogroup:member"],
    "dst":    ["tag:prod"],
    "users":  ["autogroup:nonroot", "root"]
  }
]

Keuntungan utama pendekatan ini: mencabut akses seorang developer cukup dengan mengubah kebijakan ACL, dan perubahan itu langsung berlaku ke semua sesi SSH yang sedang aktif dalam hitungan detik, tanpa perlu masuk satu per satu ke tiap server untuk menghapus key.

Untuk mengecek server mana saja yang sudah mengaktifkan fitur ini, buka halaman Machines di admin console, lalu gunakan filter Property dan pilih opsi Tailscale SSH, atau ketik langsung property:tailscale-ssh di kolom pencarian. Daftar yang muncul menampilkan semua perangkat di tailnet yang sedang menerima koneksi lewat Tailscale SSH.

Kalau suatu saat perlu menonaktifkan fitur ini di satu server, misalnya karena ingin kembali ke otentikasi SSH key manual, jalankan:

sudo tailscale set --ssh=false

Pastikan dulu ada jalur SSH lain yang masih berfungsi di server tersebut sebelum menonaktifkan Tailscale SSH, misalnya key manual yang sudah terpasang di authorized_keys atau akses lewat console provider cloud. Kalau tidak, sysadmin bisa langsung terkunci dari server begitu perintah ini dijalankan.

Membatasi Akses SSH Lewat Firewall

Begitu terpasang, Tailscale otomatis menambahkan beberapa rule ke iptables Linux lewat chain khusus bernama ts-input dan ts-forward. Kalau dicek dengan sudo iptables -L, isinya kurang lebih begini:

Chain INPUT (policy ACCEPT)
target     prot opt source               destination
ts-input   all  --  anywhere             anywhere

Chain ts-input (1 references)
target     prot opt source               destination
ACCEPT     all  --  anywhere             anywhere
DROP       all  --  100.64.0.0/10        anywhere

Rule bawaan ini cuma untuk dua hal: menerima trafik yang masuk lewat antarmuka tailscale0, dan menolak paket yang mengaku datang dari rentang IP tailnet (100.64.0.0/10) padahal lewat antarmuka lain, semacam proteksi anti-spoofing. Rule ini tidak membatasi service apa pun, termasuk SSH. Karena policy default INPUT di atas tetap ACCEPT, port SSH publik tetap bisa diakses siapa saja dari internet selama sysadmin belum menambahkan aturan sendiri.

Supaya cuma trafik dari tailnet yang bisa connect ke SSH, kita perlu menambahkan rule eksplisit di firewall. Contoh berikut memakai port SSH default 22; ganti angka ini dengan port kustom kalau server sudah diatur memakai port SSH lain lewat Port di /etc/ssh/sshd_config. Pilih salah satu metode sesuai firewall yang aktif di server: iptables, UFW, atau firewalld.

Iptables

Tambahkan rule berikut di INPUT, setelah rule bawaan Tailscale. Urutannya penting: izinkan dulu trafik dari tailscale0, baru blokir port SSH dari antarmuka lain, supaya kita tidak terkunci dari server sendiri saat rule diterapkan.

Izinkan semua trafik masuk lewat antarmuka Tailscale:
```
sudo iptables -A INPUT -i tailscale0 -j ACCEPT
```
Blokir koneksi baru ke port SSH dari antarmuka mana pun selain tailscale0:
```
sudo iptables -A INPUT -p tcp --dport 22 ! -i tailscale0 -j DROP
```
Simpan rule supaya tidak hilang setelah reboot. Caranya berbeda tergantung distro, misalnya lewat package iptables-persistent di Debian/Ubuntu, atau iptables-services di keluarga RHEL yang belum memakai firewalld:
```
sudo iptables-save > /etc/iptables/rules.v4
```

Cek rule yang aktif dengan sudo iptables -L INPUT -v -n. Rule tambahan ini aman berdampingan dengan ts-input dan ts-forward bawaan Tailscale, karena keduanya adalah chain terpisah yang tidak saling tumpang tindih.

UFW

Pastikan UFW aktif dan aturan default menolak semua trafik masuk:

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw enable

Izinkan semua trafik masuk lewat antarmuka Tailscale:
```
sudo ufw allow in on tailscale0
```
Hapus aturan yang mengizinkan SSH publik di port tersebut (kalau sebelumnya ada):
```
sudo ufw delete allow 22/tcp
```
Muat ulang UFW:
```
sudo ufw reload
```

Setelah langkah ini, sudo ufw status seharusnya tidak lagi menampilkan aturan 22/tcp ALLOW Anywhere, tapi tetap menampilkan izin untuk antarmuka tailscale0.

Firewalld

Cara paling sederhana di firewalld adalah memindahkan antarmuka tailscale0 ke zone trusted (semua trafik masuk-keluar diizinkan), lalu mencabut izin SSH dari zone publik yang dipakai antarmuka jaringan publik:

Pindahkan tailscale0 ke zone trusted secara permanen:

sudo firewall-cmd --zone=trusted --change-interface=tailscale0 --permanent

Hapus izin SSH dari zone publik. Kalau server memakai port default, hapus lewat nama service:
```
sudo firewall-cmd --zone=public --remove-service=ssh --permanent
```
Kalau server memakai port kustom yang sebelumnya dibuka manual, hapus lewat nomor port, misalnya untuk port 2222:
```
sudo firewall-cmd --zone=public --remove-port=2222/tcp --permanent
```
Muat ulang firewalld agar perubahan diterapkan:
```
sudo firewall-cmd --reload
```

Beberapa laporan pengguna menyebutkan perpindahan zone pada antarmuka tailscale0 pernah membuat interface sempat down di kombinasi versi firewalld dan Tailscale tertentu. Sysadmin sebaiknya menguji perubahan ini di luar jam sibuk dan menyiapkan akses console alternatif (misalnya lewat provider cloud) sebagai jalur darurat kalau firewall salah konfigurasi.

Pengujian dan Validasi Akses

Setelah instalasi, konfigurasi Tailscale SSH, dan pengetatan firewall selesai, validasi ulang dari dua sisi untuk memastikan semuanya bekerja seperti yang diharapkan.

Pastikan status Tailscale di klien maupun server dalam kondisi terhubung:
```
tailscale status
```
Perangkat yang aktif akan tampil dengan status online, lengkap dengan IP Tailscale masing-masing.
Coba SSH ke server lewat IP Tailscale dari klien yang terdaftar di tailnet yang sama. Koneksi harus berhasil tanpa perlu memasukkan password atau SSH key manual kalau Tailscale SSH sudah aktif.
Coba login dengan user yang tidak diizinkan lewat kebijakan ACL, misalnya root di server yang aturannya cuma mengizinkan autogroup:nonroot. Koneksi ini seharusnya ditolak, tanda kebijakan akses benar-benar diterapkan, bukan cuma identitas WireGuard yang divalidasi.
Coba SSH ke server lewat IP publiknya (kalau server punya IP publik), bukan IP Tailscale. Koneksi ini seharusnya gagal dengan connection timed out, tanda firewall sudah menolak trafik SSH dari luar antarmuka tailscale0.

Kalau langkah keempat masih berhasil terhubung, berarti aturan firewall belum diterapkan dengan benar. Cek ulang urutan perintah iptables, UFW, atau firewalld di langkah sebelumnya, terutama pastikan tidak ada aturan lama yang masih mengizinkan port SSH dari semua alamat IP. Kalau langkah kedua atau ketiga tidak sesuai ekspektasi, cek ulang status Tailscale SSH dengan tailscale status --peers=false, atau tinjau ulang kebijakan ACL di Access Controls pada admin console.

Kesimpulan

Tailscale memindahkan titik kepercayaan akses SSH dari kombinasi IP publik dan SSH key statis, menjadi identitas WireGuard yang diverifikasi lewat tailnet dan diotorisasi lewat kebijakan ACL terpusat. Langkah ini baru benar-benar rapat kalau dibarengi aturan firewall eksplisit di server, karena rule bawaan Tailscale sendiri tidak otomatis menutup port SSH dari akses publik. Begitu kedua lapisan ini aktif, sysadmin, developer, dan siapa pun yang berhak tetap bisa masuk kapan saja lewat jaringan privat terenkripsi, sementara attacker yang tidak tergabung dalam tailnet tidak punya jalan masuk sama sekali. Fitur Tailscale SSH menambah lapisan kenyamanan lain karena pengelolaan akses cukup lewat kebijakan ACL, tanpa repot mendistribusikan SSH key manual ke banyak server. Setelah setup ini berjalan, jangan lupa memantau daftar perangkat yang terhubung lewat admin console secara rutin, mencabut perangkat yang sudah tidak dipakai, dan mengikuti pembaruan Tailscale maupun sistem operasi server supaya lapisan keamanan ini tetap terjaga.