Mengonfigurasi dan Mengamankan SSH
Tags: ramadhanbersamaredhat, naspadrasastrawberry, bagasumiabibiba, ramadhanberbagitakjil
Published: 2024-03-21 01:33:21

## Mengakses Baris Perintah Jarak Jauh dengan SSH

**Apa itu open SSH?**

OpenSSH adalah sebuah program yang digunakan dalam sistem Red Hat Enterprise Linux untuk mengimplementasikan protokol Secure Shell, atau SSH. SSH memungkinkan komunikasi aman dan terenkripsi antara sistem-sistem bahkan saat berada di jaringan yang tidak aman.

Dengan menggunakan perintah 'ssh', Anda dapat membuat koneksi yang aman ke sistem-sistem yang berada di lokasi yang jauh, mengotentikasi diri sebagai pengguna tertentu, dan memulai sesi shell interaktif pada sistem tersebut sebagai pengguna yang terotentikasi. Selain itu, Anda juga dapat menggunakan perintah 'ssh' untuk menjalankan perintah-perintah secara individual pada sistem jarak jauh tanpa perlu membuka sesi shell interaktif.

**Berikut ini adalah contoh penggunaan shell aman**:

Jika Anda ingin masuk ke server jarak jauh yang disebut 'remotehost' menggunakan nama pengguna yang sama dengan pengguna yang sedang aktif di komputer Anda saat ini. Ketika Anda menjalankan perintah 'ssh', sistem jarak jauh akan meminta Anda untuk memasukkan kata sandi pengguna tersebut sebagai bentuk autentikasi.

```
[user01@host ~]$ ssh remotehost
user01@remotehost's password: redhat
...output omitted...
[user01@remotehost ~]$ 
```
Anda dapat menggunakan perintah exit untuk keluar dari sistem jarak jauh.

```
[user01@remotehost ~]$ exit
logout
Connection to remotehost closed.
[user01@host ~]$ 
```
Perintah ssh berikutnya akan memasukkan Anda ke dalam host jarak jauh server jarak jauh menggunakan nama pengguna pengguna 02. Sekali lagi, Anda diminta oleh sistem jarak jauh untuk mengautentikasi dengan kata sandi pengguna tersebut.
```
[user01@host ~]$ ssh user02@remotehost
user02@remotehost's password: shadowman
...output omitted...
[user02@remotehost ~]$ 
```
Perintah ssh ini akan menjalankan perintah hostname pada sistem jarak jauh remotehost sebagai pengguna user02 tanpa mengakses shell interaktif jarak jauh.

```
[user01@host ~]$ ssh user02@remotehost hostname
user02@remotehost's password: shadowman
remotehost.lab.example.com
[user01@host ~]$
```
Perhatikan bahwa perintah sebelumnya menampilkan output di terminal sistem lokal.

**Mengidentifikasi Pengguna Jarak Jauh**
Perintah w menampilkan daftar pengguna yang sedang login ke komputer. Hal ini sangat berguna untuk menunjukkan pengguna mana yang login menggunakan ssh dari lokasi terpencil mana, dan apa yang mereka lakukan.

```
[user01@host ~]$ ssh user01@remotehost
user01@remotehost's password: redhat
[user01@remotehost ~]$ w
 16:13:38 up 36 min,  1 user,  load average: 0.00, 0.00, 0.00
USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
user02   pts/0    172.25.250.10    16:13    7:30   0.01s  0.01s -bash
user01   pts/1    172.25.250.10    16:24    3.00s  0.01s  0.00s w
[user02@remotehost ~]$ 
```
Output sebelumnya menunjukkan bahwa user02pengguna telah masuk ke sistem pada terminal semu hari 0ini 16:13dari host dengan 172.25.250.10alamat IP, dan telah menganggur di prompt shell selama tujuh menit tiga puluh detik. Output sebelumnya juga menunjukkan bahwa user01pengguna telah login ke sistem pada terminal semu 1dan telah menganggur sejak tiga detik terakhir setelah menjalankan perintah w.

**Kunci host SSH**
SSH menggunakan enkripsi kunci publik untuk mengamankan komunikasi antara klien dan server. Saat klien terhubung ke server SSH, server mengirimkan salinan kunci publiknya kepada klien untuk menyiapkan enkripsi komunikasi dan mengautentikasi server.

Ketika pengguna menggunakan perintah 'ssh' untuk terhubung ke server SSH, perintah tersebut memeriksa apakah pengguna memiliki salinan kunci publik server di file host yang diketahui. Jika ada, 'ssh' akan membandingkan kunci yang diterima dengan kunci yang disimpan. Jika kunci tidak cocok, pengguna diminta untuk mengonfirmasi apakah ingin melanjutkan koneksi.

Jika pengguna tidak memiliki salinan kunci publik, 'ssh' akan menanyakan apakah ingin tetap masuk. Jika disetujui, salinan kunci publik server akan disimpan untuk konfirmasi otomatis di masa mendatang.

> Catatan
: Anda dapat mengatur 'StrictHostKeyChecking' ke 'yes' untuk membatalkan koneksi jika kunci publik tidak cocok.

```
[user01@host ~]$ ssh newhost
The authenticity of host 'remotehost (172.25.250.12)' can't be established.
ECDSA key fingerprint is SHA256:qaS0PToLrqlCO2XGklA0iY7CaP7aPKimerDoaUkv720.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'newhost,172.25.250.12' (ECDSA) to the list of known hosts.
user01@newhost's password: redhat
...output omitted...
[user01@newhost ~]$ 
```

**Manajemen Kunci Host Dikenal SSH**
Ketika kunci publik server berubah karena kegagalan hard drive atau diganti secara resmi, Anda harus mengedit file host yang dikenal untuk memperbarui entri dengan kunci publik baru. Ini memastikan koneksi tanpa kesalahan ke server yang diubah.

Kunci publik server disimpan di '/etc/ssh/ssh_known_hosts' untuk sistem secara global, dan di setiap file '~/.ssh/known_hosts' untuk setiap klien SSH. Setiap kunci disimpan dalam satu baris, dengan bidang pertama berisi daftar nama host dan alamat IP yang berbagi kunci tersebut. Bidang kedua mencantumkan algoritma enkripsi, sedangkan bidang terakhir berisi kunci publik itu sendiri. Dengan mengedit file-file ini, Anda dapat memperbarui kunci publik yang telah berubah untuk memastikan koneksi yang sukses.

```
[user01@host ~]$ cat ~/.ssh/known_hosts
remotehost, 172.25.250.11 ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBOsEi0e+FlaNT6jul8Ag5Nj+RViZl0yE2w6iYUr+1fPtOIF0EaOgFZ1LXM37VFTxdgFxHS 3D5WhnJikab+68zf8+w=
```
Setiap server SSH jarak jauh yang Anda sambungkan menyimpan kunci publiknya di /etc/sshdirektori dalam file dengan ekstensi .pub

```
[user01@remotehost ~]$ ls /etc/ssh/*key.pub
/etc/ssh/ssh_host_ecdsa_key.pub /etc/ssh/ssh_host_ed25519_key.pub /etc/ssh/ssh_host_rsa_key.pub
```

## Mengonfigurasi Otentikasi Berbasis Kunci SSH
## Tujuan
**Otentikasi Berbasis Kunci SSH**
Anda dapat mengonfigurasi server SSH untuk mengizinkan autentikasi tanpa kata sandi menggunakan autentikasi berbasis kunci. Ini melibatkan pembuatan sepasang file kunci kriptografi yang sesuai: kunci pribadi dan kunci publik. Kunci pribadi berfungsi sebagai kredensial autentikasi yang rahasia dan aman, sementara kunci publik disalin ke sistem yang ingin diakses oleh pengguna.

Salinan kunci publik ditempatkan di akun pengguna di server. Saat mencoba login, server SSH menggunakan kunci publik untuk mengeluarkan tantangan yang hanya dapat dijawab dengan benar menggunakan kunci pribadi. Sebagai hasilnya, klien SSH dapat mengautentikasi login secara otomatis ke server menggunakan kunci pribadi yang unik. Ini memungkinkan akses yang aman tanpa memerlukan pengguna memasukkan kata sandi secara interaktif setiap saat.

**Menghasilkan Kunci SSH**

Untuk membuat kunci privat dan mencocokkan kunci publik untuk autentikasi, gunakan perintah ssh-keygen . Secara default, kunci pribadi dan publik Anda masing-masing disimpan di file ~/.ssh/id_rsadan ~/.ssh/id_rsa.pubfile Anda.

```
[user@host ~]$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/user/.ssh/id_rsa): Enter
Created directory '/home/user/.ssh'.
Enter passphrase (empty for no passphrase): Enter
Enter same passphrase again: Enter
Your identification has been saved in /home/user/.ssh/id_rsa.
Your public key has been saved in /home/user/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:vxutUNPio3QDCyvkYm1oIx35hmMrHpPKWFdIYu3HV+w user@host.lab.example.com
The key's randomart image is:
+---[RSA 2048]----+
|                 |
|   .     .       |
|  o o     o      |
| . = o   o .     |
|  o + = S E .    |
| ..O o + * +     |
|.+% O . + B .    |
|=*oO . . + *     |
|++.     . +.     |
+----[SHA256]-----+
```
Jika Anda tidak menentukan frasa sandi saat menggunakan perintah ssh-keygen untuk membuat kunci pribadi, kunci yang dihasilkan tidak akan dilindungi. Artinya, siapa pun yang memiliki file kunci pribadi Anda dapat menggunakannya untuk otentikasi.

Namun, jika Anda menyetel frasa sandi saat membuat kunci pribadi, Anda harus memasukkan frasa sandi tersebut setiap kali menggunakan kunci pribadi untuk otentikasi. Dengan demikian, Anda akan menggunakan frasa sandi kunci pribadi, bukan kata sandi pada host jarak jauh, untuk mengautentikasi.

Untuk mengatasi pengulangan memasukkan frasa sandi, Anda dapat menggunakan program bantu bernama ssh-agent. ssh-agent dapat menyimpan frasa sandi kunci pribadi Anda sementara di memori pada awal sesi, memungkinkan otentikasi tanpa memasukkan frasa sandi secara berkali-kali.

Contoh perintah ssh-keygen menunjukkan pembuatan kunci pribadi yang dilindungi dengan frasa sandi bersama dengan kunci publik.

```
[user@host ~]$ ssh-keygen -f .ssh/key-with-pass
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in .ssh/key-with-pass.
Your public key has been saved in .ssh/key-with-pass.pub.
The key fingerprint is:
SHA256:w3GGB7EyHUry4aOcNPKmhNKS7dl1YsMVLvFZJ77VxAo user@host.lab.example.com
The key's randomart image is:
+---[RSA 2048]----+
|    . + =.o ...  |
|     = B XEo o.  |
|  . o O X =....  |
| = = = B = o.    |
|= + * * S .      |
|.+ = o + .       |
|  + .            |
|                 |
|                 |
+----[SHA256]-----+
```

Opsi -f dalam perintah ssh-keygen digunakan untuk menentukan lokasi file di mana kunci disimpan. Dalam contoh sebelumnya, kunci privat dan kunci publik masing-masing disimpan dalam file /home/user/.ssh/key-with-pass dan /home/user/.ssh/key-with-pass.pub.

Perlu diingat bahwa selama pembuatan pasangan kunci SSH berikutnya, kecuali jika nama file unik telah ditentukan, Anda akan diminta izin untuk menimpa file id_rsa dan id_rsa.pub yang sudah ada. Jika Anda menimpa file id_rsa dan id_rsa.pub, Anda harus memperbarui kunci publik lama dengan yang baru di semua server SSH yang telah menggunakan kunci publik lama Anda.

Setelah kunci SSH dibuat, secara default kunci-kunci tersebut disimpan di direktori .ssh dalam direktori home pengguna. Mode izin yang disarankan adalah 600 untuk kunci privat dan 644 untuk kunci publik.


**Berbagi Kunci Publik**

Sebelum Anda dapat menggunakan otentikasi berbasis kunci, kunci publik perlu disalin ke sistem tujuan. Perintah ssh-copy-id digunakan untuk melakukan ini dengan menyalin kunci publik dari pasangan kunci SSH ke sistem tujuan.

Jika Anda menjalankan ssh-copy-id tanpa menentukan jalur ke file kunci publik, maka file default yang akan digunakan adalah /home/user/.ssh/id_rsa.pub.

```
[user@host ~]$ ssh-copy-id -i .ssh/key-with-pass.pub user@remotehost
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/user/.ssh/id_rsa.pub"
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
user@remotehost's password: redhat
Number of key(s) added: 1

Now try logging into the machine, with:   "ssh 'user@remotehost'"
and check to make sure that only the key(s) you wanted were added.
```

Setelah kunci publik berhasil ditransfer ke sistem jarak jauh, Anda dapat mengautentikasi ke sistem tersebut menggunakan kunci pribadi yang sesuai saat melakukan masuk melalui SSH. Jika Anda tidak menentukan jalur ke file kunci pribadi saat menjalankan perintah ssh, maka secara default akan digunakan file /home/user/.ssh/id_rsa.

```
[user@host ~]$ ssh -i .ssh/key-with-pass user@remotehost
Enter passphrase for key '.ssh/key-with-pass': redhatpass
...output omitted...
[user@remotehost ~]$ exit
logout
Connection to remotehost closed.
[user@host ~]$ 
```

## Menyesuaikan Konfigurasi Layanan OpenSSH
## Tujuan
**Mengonfigurasi Server OpenSSH**

Konfigurasi default server OpenSSH umumnya berfungsi dengan baik, namun, untuk memperkuat keamanan sistem, Anda mungkin ingin melakukan dua perubahan umum. Pertama, Anda mungkin ingin melarang login langsung ke akun root secara remote. Kedua, Anda mungkin ingin melarang autentikasi berbasis kata sandi dan beralih ke autentikasi berbasis kunci pribadi SSH.

**Melarang Superuser Untuk Masuk Menggunakan SSH**

- Nama pengguna root secara default hadir di setiap sistem Linux, yang berpotensi memudahkan penyerang karena mereka hanya perlu menebak kata sandi, bukan mencoba kombinasi nama pengguna dan kata sandi yang valid. Hal ini mengurangi kompleksitas bagi penyerang.

- Pengguna rootmemiliki hak istimewa yang tidak dibatasi, sehingga komprominya dapat menyebabkan kerusakan maksimum pada sistem.

- Dari perspektif audit, mungkin sulit untuk melacak pengguna yang berwenang yang masuk sebagai root dan membuat perubahan. Jika pengguna harus masuk sebagai pengguna biasa dan beralih ke akun root, hal ini akan menghasilkan peristiwa log yang dapat digunakan untuk membantu memberikan pertanggungjawaban.

Server OpenSSH menggunakan pengaturan konfigurasi PermitRootLogin pada berkas konfigurasi /etc/ssh/sshd_config untuk mengizinkan atau melarang pengguna masuk ke sistem sebagai root.


```
PermitRootLogin yes

```
Dengan parameter PermitRootLogin ke ya, seperti yang ditetapkan secara default, orang diizinkan masuk sebagai root. Untuk mencegah hal ini, setel nilainya ke no. Atau, untuk mencegah autentikasi berbasis kata sandi tetapi mengizinkan autentikasi berbasis kunci privat untuk root, setel parameter PermitRootLogin ke tanpa kata sandi.

Server SSH (sshd) harus dimuat ulang agar perubahan dapat diterapkan.

```
[root@host ~]# systemctl reload sshd
```
**Melarang Otentikasi Berbasis Kata Sandi untuk SSH**

Mengizinkan hanya login berbasis kunci privat ke baris perintah jarak jauh memiliki berbagai keuntungan:

- Penyerang tidak dapat menggunakan serangan menebak kata sandi untuk membobol akun yang dikenal pada sistem dari jarak jauh.
- Dengan kunci privat yang dilindungi frasa sandi, penyerang membutuhkan frasa sandi dan salinan kunci privat. Dengan kata sandi, penyerang hanya membutuhkan kata sandi.
- Dengan menggunakan kunci privat yang dilindungi kata sandi bersama dengan ssh-agent, kata sandi akan lebih jarang terekspos karena kata sandi tersebut lebih jarang dimasukkan, dan proses masuk menjadi lebih nyaman bagi pengguna.

Server OpenSSH menggunakan parameter PasswordAuthentication pada berkas konfigurasi /etc/ssh/sshd_config untuk mengontrol apakah pengguna dapat menggunakan autentikasi berbasis kata sandi untuk masuk ke sistem.

```
PasswordAuthentication yes
```
Nilai default ya untuk parameter PasswordAuthentication pada berkas konfigurasi /etc/ssh/sshd_config menyebabkan server SSH mengizinkan pengguna menggunakan autentikasi berbasis kata sandi saat masuk. Nilai no untuk PasswordAuthentication mencegah pengguna menggunakan autentikasi berbasis kata sandi.

Ingatlah bahwa setiap kali Anda mengubah berkas /etc/ssh/sshd_config, Anda harus memuat ulang layanan sshd agar perubahan diterapkan.

> Penting
Ingat, jika Anda mematikan autentikasi berbasis kata sandi untuk ssh, Anda harus memiliki cara untuk memastikan bahwa berkas ~/.ssh/authorized_keys milik pengguna di server jauh diisi dengan kunci publik mereka, sehingga mereka dapat masuk.