SSH kapcsolat beállítása Linuxon

Emlékszem, amikor először kellett távolról bejelentkeznem egy szerverre, és fogalmam sem volt, hogyan kezdjek hozzá. Mindenki csak annyit mondott: „Használj SSH-t”, mintha ez magától értetődő lenne. Órákig küszködtem, mire végre sikerült biztonságos kapcsolatot létesítenem. Azóta tudom, hogy ez a készség nem csak a rendszergazdák kiváltsága, hanem alapvető fontosságú bárki számára, aki Linux rendszerrel dolgozik vagy tanul.

Az SSH (Secure Shell) egy olyan protokoll, amely lehetővé teszi a biztonságos kommunikációt két számítógép között nyílt hálózaton keresztül. Titkosított csatornát biztosít, amelyen keresztül adatokat továbbíthatunk, parancsokat futtathatunk, vagy akár fájlokat másolhatunk. Az SSH beállítása sokféleképpen történhet – vannak, akik jelszavas hitelesítést részesítenek előnyben annak egyszerűsége miatt, míg mások a kulcsalapú hitelesítés megnövelt biztonságára esküsznek. Mindkét megközelítésnek megvan a maga helye a digitális világban.

Ebben a részben végigvezetlek az SSH kapcsolat beállításának teljes folyamatán, a szükséges csomagok telepítésétől kezdve a haladó biztonsági beállításokig. Megtanulod, hogyan generálj és kezelj SSH-kulcsokat, hogyan konfigurálj SSH szervert biztonságosan, és milyen trükkökkel teheted még hatékonyabbá a távoli munkavégzést. Gyakorlati példákon keresztül mutatom be a leggyakoribb problémák megoldását is, hogy magabiztosan használhasd ezt a nélkülözhetetlen eszközt.

Az SSH alapjai

A modern informatikai környezetben a távoli szerverek kezelése mindennapos feladat. Legyen szó egy weboldalról, adatbázisról vagy bármilyen hálózati szolgáltatásról, gyakran előfordul, hogy fizikailag távol vagyunk attól a géptől, amelyen a szoftver fut. Ilyenkor jön képbe az SSH, amely biztonságos csatornát biztosít a távoli rendszerek eléréséhez.

Az SSH protokollt eredetileg a telnet és az rsh (remote shell) protokollok leváltására fejlesztették ki, amelyek súlyos biztonsági hiányosságokkal rendelkeztek – például a jelszavakat és egyéb érzékeny adatokat titkosítatlanul továbbították a hálózaton. Az SSH ezzel szemben erős titkosítást használ, így a kommunikáció lehallgatása esetén sem juthat illetéktelen személy az adatokhoz.

„A biztonság nem egy termék, hanem egy folyamat. Nem elég egyszer beállítani az SSH-t, rendszeresen felül kell vizsgálni a konfigurációt a legújabb biztonsági ajánlások alapján.”

A Linux rendszereken az OpenSSH a legelterjedtebb implementáció, amely két fő komponensből áll:

Az SSH kliens (ssh), amellyel kapcsolódhatunk más gépekhez
Az SSH szerver (sshd), amely lehetővé teszi, hogy mások kapcsolódjanak a gépünkhöz

Mielőtt belevágnánk a részletekbe, fontos tisztázni néhány alapfogalmat:

🔑 Kliens: Az a számítógép, amelyről kapcsolódunk
🔒 Szerver: Az a számítógép, amelyhez kapcsolódunk
🔐 Hitelesítés: A folyamat, amely során bizonyítjuk, hogy jogosultak vagyunk a hozzáférésre
🌐 Port forwarding: Lehetővé teszi a hálózati forgalom továbbítását az SSH kapcsolaton keresztül
🛡️ Kulcspár: Egy nyilvános és egy privát kulcsból álló pár, amely a kulcsalapú hitelesítés alapja

Az SSH telepítése és alapvető beállítása

A legtöbb modern Linux disztribúció alapértelmezetten tartalmazza az SSH klienst, de a szerver komponenst általában külön kell telepíteni. Nézzük, hogyan történik ez a különböző disztribúciókon:

Telepítés Debian/Ubuntu rendszereken

A Debian alapú rendszereken (mint az Ubuntu) az alábbi paranccsal telepíthetjük az SSH szervert:

sudo apt update
sudo apt install openssh-server

A telepítés után a szolgáltatás automatikusan elindul. Ellenőrizhetjük a státuszát:

sudo systemctl status ssh

Ha minden rendben van, ehhez hasonló kimenetet kell látnunk:

● ssh.service - OpenBSD Secure Shell server
     Loaded: loaded (/lib/systemd/system/ssh.service; enabled; vendor preset: enabled)
     Active: active (running) since Mon 2023-10-23 15:30:45 CEST; 2min 15s ago

Telepítés Fedora/CentOS/RHEL rendszereken

A Red Hat alapú disztribúciókon az alábbi parancsokkal telepíthetjük:

sudo dnf update
sudo dnf install openssh-server

A szolgáltatás elindítása és engedélyezése a rendszerindításkor:

sudo systemctl start sshd
sudo systemctl enable sshd

Telepítés Arch Linux rendszeren

Az Arch Linux és származékai esetén:

sudo pacman -Syu
sudo pacman -S openssh

A szolgáltatás elindítása és engedélyezése:

sudo systemctl start sshd
sudo systemctl enable sshd

Alapvető konfiguráció

Az SSH szerver konfigurációs fájlja a /etc/ssh/sshd_config. Mielőtt módosítanánk, készítsünk róla biztonsági másolatot:

sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak

Most már biztonságosan szerkeszthetjük a fájlt:

sudo nano /etc/ssh/sshd_config

Íme néhány alapvető biztonsági beállítás, amelyet érdemes megfontolni:

A port megváltoztatása (opcionális, de megnehezíti az automatizált támadásokat):

   Port 2222

Root bejelentkezés letiltása:

   PermitRootLogin no

Jelszavas bejelentkezés kikapcsolása (csak kulcsalapú hitelesítés engedélyezése):

   PasswordAuthentication no

Inaktív kapcsolatok időkorlátjának beállítása:

   ClientAliveInterval 300
   ClientAliveCountMax 2

A változtatások után újra kell indítani az SSH szolgáltatást:

sudo systemctl restart sshd

„A legbiztonságosabb rendszer az, amelyik ki van kapcsolva. Mivel ez ritkán kivitelezhető, a következő legjobb megoldás az, ha csak a szükséges szolgáltatásokat futtatjuk, és azokat is a lehető legbiztonságosabb konfigurációval.”

SSH kulcspárok létrehozása és kezelése

Az SSH kulcspárok használata jelentősen növeli a biztonságot a jelszavas hitelesítéshez képest. A kulcspár két részből áll: egy privát kulcsból, amelyet biztonságban kell tartanunk a saját gépünkön, és egy nyilvános kulcsból, amelyet megoszthatunk azokkal a szerverekkel, amelyekhez kapcsolódni szeretnénk.

Kulcspár generálása

Az SSH kulcspár létrehozásához használjuk az ssh-keygen parancsot:

ssh-keygen -t ed25519 -C "komment a kulcs azonosításához"

Az Ed25519 algoritmus modern és biztonságos, de ha régebbi rendszerekkel is kompatibilisnek kell lennünk, használhatjuk az RSA algoritmust is:

ssh-keygen -t rsa -b 4096 -C "komment a kulcs azonosításához"

A parancs futtatása után meg kell adnunk, hova mentse a kulcsokat (alapértelmezetten a ~/.ssh/ könyvtárba), és opcionálisan beállíthatunk egy jelszót a privát kulcs védelmére.

Fontos: A privát kulcsot soha ne osszuk meg másokkal! Ez olyan, mintha a lakáskulcsunkat adnánk oda idegeneknek.

A nyilvános kulcs megosztása a szerverrel

Miután létrehoztuk a kulcspárt, a nyilvános kulcsot fel kell tölteni a távoli szerverre. Erre több módszer is létezik:

1. Az ssh-copy-id használata

Ez a legegyszerűbb módszer:

ssh-copy-id felhasznalo@szerver.cim

A parancs bekéri a távoli felhasználó jelszavát, majd feltölti a nyilvános kulcsot a megfelelő helyre.

2. Manuális másolás

Ha az ssh-copy-id nem érhető el, manuálisan is másolhatjuk a kulcsot:

cat ~/.ssh/id_ed25519.pub | ssh felhasznalo@szerver.cim "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

3. Fájlátvitel és beállítás

Alternatív megoldásként átvihetjük a nyilvános kulcsot a szerverre SCP vagy SFTP segítségével, majd beállíthatjuk a megfelelő jogosultságokat:

scp ~/.ssh/id_ed25519.pub felhasznalo@szerver.cim:~/kulcs.pub
ssh felhasznalo@szerver.cim
mkdir -p ~/.ssh
cat ~/kulcs.pub >> ~/.ssh/authorized_keys
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
rm ~/kulcs.pub

Kulcsok kezelése SSH-agent segítségével

Ha jelszóval védtük a privát kulcsunkat (ami erősen ajánlott), minden kapcsolódásnál meg kell adnunk ezt a jelszót. Az SSH-agent segítségével elkerülhetjük ezt a kellemetlenséget:

eval $(ssh-agent)
ssh-add ~/.ssh/id_ed25519

Most már jelszó megadása nélkül kapcsolódhatunk a szerverekhez, amíg az SSH-agent fut.

A modern rendszereken az SSH-agent általában automatikusan elindul a bejelentkezéskor, így csak az ssh-add parancsot kell futtatnunk.

Különböző kulcsok különböző szerverekhez

Ha több szerverhez kapcsolódunk, érdemes lehet különböző kulcsokat használni. Ehhez az SSH konfigurációs fájlját használhatjuk:

nano ~/.ssh/config

Példa konfiguráció:

Host szerver1
    HostName szerver1.pelda.com
    User felhasznalo1
    Port 22
    IdentityFile ~/.ssh/id_ed25519_szerver1

Host szerver2
    HostName 192.168.1.100
    User felhasznalo2
    Port 2222
    IdentityFile ~/.ssh/id_ed25519_szerver2

Ezután egyszerűen kapcsolódhatunk a szerverekhez:

ssh szerver1
ssh szerver2

SSH szerver biztonságos konfigurálása

Az SSH szerver megfelelő konfigurálása kritikus fontosságú a biztonság szempontjából. Az alábbiakban részletesen áttekintjük a legfontosabb biztonsági beállításokat.

Alapvető biztonsági beállítások

Nyissuk meg a konfigurációs fájlt:

sudo nano /etc/ssh/sshd_config

Ajánlott biztonsági beállítások:

# Protokoll verzió (csak SSH2)
Protocol 2

# Hitelesítési beállítások
PermitRootLogin no
PasswordAuthentication no
PermitEmptyPasswords no
ChallengeResponseAuthentication no
UsePAM yes

# Időkorlátok
LoginGraceTime 30s
MaxAuthTries 3
MaxSessions 5
ClientAliveInterval 300
ClientAliveCountMax 2

# Egyéb biztonsági beállítások
X11Forwarding no
AllowAgentForwarding no
AllowTcpForwarding no
PrintMotd no
PrintLastLog yes
TCPKeepAlive yes

A változtatások után újra kell indítani az SSH szolgáltatást:

sudo systemctl restart sshd

„A biztonság és a kényelem fordítottan arányos egymással. Minden biztonsági intézkedés valamilyen kényelmetlenséget okoz, de a megfelelő egyensúly megtalálása kritikus fontosságú.”

Felhasználók korlátozása

Korlátozhatjuk, hogy mely felhasználók jelentkezhetnek be SSH-n keresztül:

# Csak bizonyos felhasználók engedélyezése
AllowUsers felhasznalo1 felhasznalo2

# VAGY csak bizonyos csoportok engedélyezése
AllowGroups ssh-users admins

Alternatív megoldásként tilthatunk is felhasználókat:

# Bizonyos felhasználók tiltása
DenyUsers vendeg teszt

# Bizonyos csoportok tiltása
DenyGroups guests

Hálózati korlátozások

Korlátozhatjuk, hogy mely IP-címekről lehet kapcsolódni:

# Csak bizonyos IP-címekről engedélyezzük a kapcsolódást
ListenAddress 192.168.1.100

Vagy használhatjuk a TCP Wrappers funkciót is (ha a rendszer támogatja):

sudo nano /etc/hosts.allow

Adjuk hozzá:

sshd: 192.168.1.0/24 10.0.0.5

Majd:

sudo nano /etc/hosts.deny

Adjuk hozzá:

sshd: ALL

Fail2Ban használata

A Fail2Ban egy hasznos eszköz, amely figyeli a sikertelen bejelentkezési kísérleteket, és ideiglenesen blokkolja azokat az IP-címeket, amelyekről túl sok sikertelen próbálkozás érkezik.

Telepítés:

sudo apt install fail2ban   # Debian/Ubuntu
sudo dnf install fail2ban   # Fedora/CentOS/RHEL
sudo pacman -S fail2ban     # Arch Linux

Konfiguráció:

sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
sudo nano /etc/fail2ban/jail.local

Keressük meg az SSH szekciót, és módosítsuk igény szerint:

[sshd]
enabled = true
port = ssh
filter = sshd
logpath = /var/log/auth.log
maxretry = 3
bantime = 3600
findtime = 600

Indítsuk el és engedélyezzük a szolgáltatást:

sudo systemctl start fail2ban
sudo systemctl enable fail2ban

Port Forwarding és Tunneling

Az SSH nem csak távoli bejelentkezésre használható, hanem hálózati forgalom továbbítására is. Ez hasznos lehet például, ha egy távoli szerveren futó webszervert szeretnénk elérni a helyi böngészőnkből.

Lokális port forwarding

ssh -L 8080:localhost:80 felhasznalo@szerver.cim

Ez a parancs a helyi 8080-as portot a távoli szerver 80-as portjára irányítja. Most már elérhetjük a távoli webszervert a http://localhost:8080 címen.

Távoli port forwarding

ssh -R 8080:localhost:80 felhasznalo@szerver.cim

Ez fordítva működik: a távoli szerver 8080-as portját irányítja a helyi gép 80-as portjára.

Dinamikus port forwarding (SOCKS proxy)

ssh -D 1080 felhasznalo@szerver.cim

Ez létrehoz egy SOCKS proxyt a helyi 1080-as porton, amelyen keresztül bármilyen forgalmat továbbíthatunk.

Ha rendszeresen használjuk ezeket a funkciókat, beállíthatjuk őket az SSH konfigurációs fájlban is:

Host tunnel
    HostName szerver.cim
    User felhasznalo
    LocalForward 8080 localhost:80
    DynamicForward 1080

Haladó SSH technikák és tippek

Az SSH számos haladó funkciót kínál, amelyek megkönnyíthetik a mindennapi munkát. Nézzünk meg néhányat ezek közül.

SSH konfigurációs fájl testreszabása

A ~/.ssh/config fájl rendkívül hasznos lehet a gyakran használt kapcsolatok egyszerűsítésére:

# Alapértelmezett beállítások minden hoszthoz
Host *
    ServerAliveInterval 60
    ServerAliveCountMax 3
    Compression yes
    ControlMaster auto
    ControlPath ~/.ssh/control/%r@%h:%p
    ControlPersist 10m

# Specifikus hoszt beállítások
Host dev
    HostName dev-server.example.com
    User developer
    Port 2222
    IdentityFile ~/.ssh/id_ed25519_dev
    ForwardAgent yes

Host jumphost
    HostName jump.example.com
    User admin
    Port 22

# Ugróállomás használata
Host internal
    HostName internal-server.local
    User admin
    ProxyJump jumphost

Ezekkel a beállításokkal egyszerűen kapcsolódhatunk a szerverekhez:

ssh dev
ssh internal

SSH Multiplexing

Az SSH multiplexing lehetővé teszi, hogy több SSH kapcsolatot használjunk egyetlen TCP kapcsolaton keresztül. Ez jelentősen felgyorsíthatja az újabb kapcsolatok létrehozását:

Host *
    ControlMaster auto
    ControlPath ~/.ssh/control/%r@%h:%p
    ControlPersist 10m

Ezzel a beállítással az első kapcsolat létrehozása után a további kapcsolatok szinte azonnal létrejönnek, mivel újrahasználják az eredeti kapcsolatot.

Fájlátvitel SSH-n keresztül

Az SSH protokoll nem csak bejelentkezésre használható, hanem fájlátvitelre is. Az SCP (Secure Copy) és az SFTP (SSH File Transfer Protocol) mindkettő az SSH protokollt használja a biztonságos fájlátvitelhez.

SCP használata

Fájl másolása a helyi gépről a távoli szerverre:

scp helyi_fajl.txt felhasznalo@szerver.cim:~/cél_könyvtár/

Fájl másolása a távoli szerverről a helyi gépre:

scp felhasznalo@szerver.cim:~/távoli_fajl.txt ./helyi_könyvtár/

Teljes könyvtár másolása rekurzívan:

scp -r helyi_könyvtár/ felhasznalo@szerver.cim:~/cél_könyvtár/

SFTP használata

Az SFTP interaktívabb felületet biztosít a fájlátvitelhez:

sftp felhasznalo@szerver.cim

Ez megnyit egy interaktív shell-t, ahol különböző parancsokat adhatunk ki:

sftp> ls          # Távoli könyvtár listázása
sftp> lls         # Helyi könyvtár listázása
sftp> cd távoli_könyvtár    # Váltás távoli könyvtárba
sftp> lcd helyi_könyvtár    # Váltás helyi könyvtárba
sftp> get távoli_fajl       # Fájl letöltése
sftp> put helyi_fajl        # Fájl feltöltése
sftp> mget *.txt            # Több fájl letöltése
sftp> mput *.jpg            # Több fájl feltöltése
sftp> exit                  # Kilépés

X11 Forwarding

Az X11 Forwarding lehetővé teszi, hogy távoli grafikus alkalmazásokat futtassunk, amelyek a helyi képernyőnkön jelennek meg:

ssh -X felhasznalo@szerver.cim

A kapcsolódás után indíthatunk grafikus alkalmazásokat:

firefox &

Ez a Firefox böngészőt indítja el a távoli szerveren, de a felület a helyi gépünkön jelenik meg.

„Az SSH nem csak egy eszköz a távoli bejelentkezéshez, hanem egy svájci bicska, amely számtalan problémára kínál megoldást a hálózati adminisztráció területén.”

SSH Escape Sequences

Az SSH kliens támogat különböző escape szekvenciákat, amelyeket az aktív kapcsolaton belül használhatunk. Ezeket a ~ karakter bevitelével kezdeményezhetjük (új sorban, közvetlenül a sor elején):

~. – Kapcsolat azonnali bontása
~^Z – SSH kapcsolat háttérbe helyezése
~# – Aktív kapcsolatok listázása (ha több kapcsolat van nyitva)
~? – Súgó megjelenítése
~C – Parancs mód megnyitása (pl. port forwarding hozzáadásához)

SSH és rsync kombinálása

Az rsync és az SSH kombinálása rendkívül hatékony módja a fájlok szinkronizálásának:

rsync -avz -e ssh helyi_könyvtár/ felhasznalo@szerver.cim:~/cél_könyvtár/

Ez a parancs csak a változott fájlokat másolja át, ami jelentősen gyorsabb lehet nagy könyvtárak esetén.

SSH hibaelhárítás és diagnosztika

Az SSH kapcsolatok létrehozásakor vagy használatakor különféle problémákba ütközhetünk. Ebben a részben a leggyakoribb problémákat és azok megoldásait tekintjük át.

Verbózis növelése a hibakereséshez

Ha problémánk van az SSH kapcsolattal, az első lépés a verbózis szintjének növelése:

ssh -v felhasznalo@szerver.cim     # Alapszintű verbózis
ssh -vv felhasznalo@szerver.cim    # Részletesebb információk
ssh -vvv felhasznalo@szerver.cim   # Maximális részletesség

Ez segít azonosítani, hogy pontosan hol akad el a kapcsolódási folyamat.

Gyakori hibaüzenetek és megoldásaik

„Connection refused”

Ez általában azt jelenti, hogy:

Az SSH szerver nem fut a célgépen
Tűzfal blokkolja a kapcsolatot
Rossz porton próbálunk kapcsolódni

Megoldások:

Ellenőrizzük, hogy fut-e az SSH szerver: sudo systemctl status sshd
Ellenőrizzük a tűzfal beállításait: sudo ufw status vagy sudo firewall-cmd --list-all
Ellenőrizzük, hogy a megfelelő portra kapcsolódunk-e

„Permission denied (publickey,password)”

Ez azt jelenti, hogy sem a kulcsalapú, sem a jelszavas hitelesítés nem sikerült.

Megoldások:

Ellenőrizzük, hogy a megfelelő felhasználónevet használjuk-e
Ellenőrizzük, hogy a nyilvános kulcs megfelelően fel van-e töltve a szerverre
Ellenőrizzük a szerver konfigurációját: sudo cat /etc/ssh/sshd_config | grep Password
Ellenőrizzük a jogosultságokat: ls -la ~/.ssh/

A ~/.ssh/ könyvtár és fájlok jogosultságai kritikusak:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub
chmod 600 ~/.ssh/authorized_keys

„Host key verification failed”

Ez akkor fordul elő, ha a szerver SSH hosztkulcsa megváltozott (pl. újratelepítés után).

Megoldás:

ssh-keygen -R szerver.cim

Ez törli a régi hosztkulcsot a ~/.ssh/known_hosts fájlból.

SSH szerver naplófájlok elemzése

Ha szerveroldali problémáink vannak, érdemes megnézni a naplófájlokat:

sudo tail -f /var/log/auth.log    # Debian/Ubuntu
sudo tail -f /var/log/secure      # Fedora/CentOS/RHEL
sudo journalctl -u sshd -f        # Systemd alapú rendszerek

Kapcsolódási problémák tűzfalak esetén

Ha tűzfal blokkolja a kapcsolatot, engedélyeznünk kell az SSH portot:

UFW (Ubuntu/Debian)

sudo ufw allow ssh          # Alapértelmezett port (22)
sudo ufw allow 2222/tcp     # Egyedi port

FirewallD (Fedora/CentOS/RHEL)

sudo firewall-cmd --permanent --add-service=ssh
sudo firewall-cmd --permanent --add-port=2222/tcp
sudo firewall-cmd --reload

Iptables

sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 2222 -j ACCEPT
sudo iptables-save > /etc/iptables/rules.v4

Teljesítmény optimalizálás

Ha lassú az SSH kapcsolat, próbáljuk meg az alábbi optimalizálásokat:

Host *
    Compression yes
    TCPKeepAlive yes
    ServerAliveInterval 60
    ServerAliveCountMax 3
    ControlMaster auto
    ControlPath ~/.ssh/control/%r@%h:%p
    ControlPersist 10m

Ezek a beállítások a ~/.ssh/config fájlba kerüljenek.

SSH biztonsági legjobb gyakorlatok

Az SSH biztonságos protokoll, de csak akkor, ha megfelelően konfigurálják. Az alábbiakban összefoglaljuk a legfontosabb biztonsági gyakorlatokat.

Kulcsalapú hitelesítés használata

A jelszavas hitelesítés helyett mindig kulcsalapú hitelesítést használjunk:

Generáljunk erős kulcspárt: ssh-keygen -t ed25519
Töltsük fel a nyilvános kulcsot: ssh-copy-id felhasznalo@szerver.cim
Tiltsuk le a jelszavas hitelesítést: PasswordAuthentication no

Erős kriptográfiai algoritmusok használata

Az SSH konfigurációs fájlban korlátozzuk az engedélyezett algoritmusokat:

# /etc/ssh/sshd_config
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes128-gcm@openssh.com
MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com
HostKeyAlgorithms ssh-ed25519,ssh-rsa,rsa-sha2-512,rsa-sha2-256

Rendszeres frissítések

Az OpenSSH rendszeres frissítése kritikus fontosságú:

sudo apt update && sudo apt upgrade     # Debian/Ubuntu
sudo dnf update                         # Fedora/CentOS/RHEL
sudo pacman -Syu                        # Arch Linux

Két faktoros hitelesítés (2FA)

Az SSH-hoz is beállíthatunk két faktoros hitelesítést, például a Google Authenticator segítségével:

sudo apt install libpam-google-authenticator    # Debian/Ubuntu
sudo dnf install google-authenticator           # Fedora/CentOS/RHEL
sudo pacman -S libpam-google-authenticator      # Arch Linux

Konfiguráció:

google-authenticator

Majd módosítsuk a PAM konfigurációt:

sudo nano /etc/pam.d/sshd

Adjuk hozzá:

auth required pam_google_authenticator.so

És az SSH konfigurációt:

sudo nano /etc/ssh/sshd_config

Módosítsuk:

ChallengeResponseAuthentication yes
AuthenticationMethods publickey,keyboard-interactive

„A biztonság nem egy célállapot, hanem egy folyamatos utazás. Az SSH beállítások rendszeres felülvizsgálata és frissítése elengedhetetlen a magas szintű biztonság fenntartásához.”

Jogosultságok korlátozása

Az SSH hozzáférést korlátozzuk csak azokra a felhasználókra, akiknek valóban szükségük van rá:

AllowUsers felhasznalo1 felhasznalo2
AllowGroups ssh-users admins

Hálózati szintű védelem

Az SSH szervert védjük hálózati szinten is:

Tűzfal használata
Fail2Ban beállítása
VPN mögé helyezés kritikus rendszerek esetén

Rendszeres auditálás

Rendszeresen ellenőrizzük a bejelentkezési kísérleteket:

sudo lastb               # Sikertelen bejelentkezési kísérletek
sudo last | head -20     # Sikeres bejelentkezések

SSH és a modern DevOps gyakorlatok

Az SSH kulcsszerepet játszik a modern DevOps gyakorlatokban, különösen a CI/CD (Continuous Integration/Continuous Deployment) folyamatokban és az infrastruktúra automatizálásban.

SSH kulcsok használata CI/CD rendszerekben

A CI/CD rendszerek (pl. Jenkins, GitLab CI, GitHub Actions) gyakran SSH-t használnak a távoli szerverekhez való kapcsolódáshoz. Néhány legjobb gyakorlat:

Dedikált SSH kulcsok használata az automatizáláshoz
A kulcsok jogosultságainak korlátozása (csak a szükséges műveletekre)
A privát kulcsok biztonságos tárolása (pl. Jenkins Credentials, GitLab/GitHub titkosított változók)

Példa GitLab CI konfigurációra:

deploy:
  stage: deploy
  script:
    - eval $(ssh-agent -s)
    - echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add -
    - mkdir -p ~/.ssh
    - chmod 700 ~/.ssh
    - ssh-keyscan szerver.cim >> ~/.ssh/known_hosts
    - chmod 644 ~/.ssh/known_hosts
    - ssh felhasznalo@szerver.cim "cd /var/www/app && git pull && npm install && pm2 restart app"
  only:
    - master

SSH és konfigurációkezelés

Az olyan konfigurációkezelő eszközök, mint az Ansible, Chef vagy Puppet, gyakran SSH-t használnak a távoli szerverek konfigurálásához.

Példa Ansible inventory fájlra:

[webszerverek]
web1 ansible_host=web1.pelda.com ansible_user=deploy
web2 ansible_host=web2.pelda.com ansible_user=deploy

[dbszerverek]

db1 ansible_host=db1.pelda.com ansible_user=dbadmin db2 ansible_host=db2.pelda.com ansible_user=dbadmin

[all:vars]

ansible_ssh_private_key_file=~/.ssh/ansible_id_ed25519 ansible_ssh_common_args=’-o StrictHostKeyChecking=no’

SSH Jump Hosts és Bastion Hosts

A modern infrastruktúrákban gyakran használnak „ugróállomásokat” (jump hosts) vagy „bástyagépeket” (bastion hosts) a belső hálózat védelme érdekében:

# ~/.ssh/config
Host bastion
    HostName bastion.pelda.com
    User admin
    IdentityFile ~/.ssh/id_ed25519_bastion

Host internal-*
    ProxyJump bastion
    User deploy
    IdentityFile ~/.ssh/id_ed25519_internal

Most már közvetlenül kapcsolódhatunk a belső szerverekhez:

ssh internal-web1

Ez automatikusan a bastion hoston keresztül kapcsolódik.

SSH és konténerizáció

A konténerizált környezetekben (pl. Docker, Kubernetes) az SSH használata kevésbé gyakori, de még mindig hasznos lehet a hibaelhárításhoz:

# Kapcsolódás egy Docker konténerhez
docker exec -it konténer_név /bin/bash

# Kapcsolódás egy Kubernetes podhoz
kubectl exec -it pod_név -- /bin/bash

Ha mégis SSH-t szeretnénk használni a konténerekben, gondoskodnunk kell az SSH szerver megfelelő konfigurálásáról és a kulcsok biztonságos kezeléséről.

Összehasonlító táblázatok

SSH hitelesítési módszerek összehasonlítása

Hitelesítési módszer	Előnyök	Hátrányok	Ajánlott használat
Jelszavas hitelesítés	Egyszerű beállítás Nem igényel előzetes kulcscserét	Kitett brute force támadásoknak A jelszavak ellophatók Nem automatizálható könnyen	Csak ideiglenes vagy nem kritikus rendszerekhez
Kulcsalapú hitelesítés	Nagyon biztonságos Automatizálható Nem igényel jelszó megjegyzést	Kulcsok elvesztése esetén elvész a hozzáférés Kulcsok megfelelő kezelése szükséges	Általános használatra és automatizáláshoz
Két faktoros hitelesítés	Rendkívül biztonságos Még ellopott kulcs esetén is véd	Komplexebb beállítás Több lépés a bejelentkezéshez	Magas biztonsági igényű rendszerekhez
Kerberos hitelesítés	Egyszeri bejelentkezés (SSO) Központosított felhasználókezelés	Komplex infrastruktúrát igényel Nehezebb beállítani	Nagyvállalati környezetben

SSH szerveroldali konfigurációs beállítások

Beállítás	Ajánlott érték	Hatás	Biztonsági szint
Protocol	2	Csak SSH2 protokoll használata (biztonságosabb)	Magas
PermitRootLogin	no	Root felhasználó közvetlen bejelentkezésének tiltása	Magas
PasswordAuthentication	no	Jelszavas hitelesítés tiltása	Magas
PubkeyAuthentication	yes	Kulcsalapú hitelesítés engedélyezése	Magas
MaxAuthTries	3	Maximális hitelesítési próbálkozások száma	Közepes
LoginGraceTime	30s	Bejelentkezési időkorlát	Közepes
PermitEmptyPasswords	no	Üres jelszavak tiltása	Magas
X11Forwarding	no	X11 forwarding tiltása (ha nem szükséges)	Közepes
AllowTcpForwarding	no	TCP forwarding tiltása (ha nem szükséges)	Közepes
ClientAliveInterval	300	Inaktív kapcsolatok ellenőrzése 5 percenként	Alacsony
ClientAliveCountMax	2	Kapcsolat bontása 2 sikertelen ellenőrzés után	Alacsony

Valós példák és esettanulmányok

Az elméleti ismeretek után nézzünk néhány valós példát, amelyek bemutatják az SSH használatát különböző helyzetekben.

Példa 1: Webszerver automatizált telepítése

Tegyük fel, hogy egy új webszervert szeretnénk telepíteni és konfigurálni automatizáltan. Ehhez használhatjuk az SSH-t és egy egyszerű shell szkriptet:

#!/bin/bash
# webserver_setup.sh

# Kapcsolódás a szerverhez
ssh -i ~/.ssh/id_ed25519 admin@uj-szerver.pelda.com << 'EOF'

# Frissítések telepítése
sudo apt update
sudo apt upgrade -y

# Webszerver telepítése
sudo apt install -y nginx

# Tűzfal konfigurálása
sudo ufw allow 'Nginx Full'
sudo ufw allow ssh

# Nginx konfigurálása
sudo tee /etc/nginx/sites-available/default > /dev/null << 'CONF'
server {
    listen 80 default_server;
    listen [::]:80 default_server;

    root /var/www/html;
    index index.html index.htm;

    server_name _;

    location / {
        try_files $uri $uri/ =404;
    }
}
CONF

# Weboldal létrehozása
sudo tee /var/www/html/index.html > /dev/null << 'HTML'
<!DOCTYPE html>
<html>
<head>
    <title>Üdvözöljük!</title>
</head>
<body>
    <h1>Az új webszerver sikeresen telepítve!</h1>
    <p>Ez egy automatizált telepítés eredménye.</p>
</body>
</html>
HTML

# Nginx újraindítása
sudo systemctl restart nginx

echo "A webszerver telepítése sikeres!"
EOF

Ezt a szkriptet a helyi gépünkről futtathatjuk, és automatikusan elvégzi a szerver konfigurálását.

Példa 2: Adatbázis biztonsági mentése SSH tunnel segítségével

Tegyük fel, hogy egy távoli MySQL adatbázisról szeretnénk biztonsági mentést készíteni, de a MySQL port nem érhető el közvetlenül az internetről (ami jó biztonsági gyakorlat). SSH tunnel segítségével megoldhatjuk ezt:

#!/bin/bash
# db_backup.sh

# SSH tunnel létrehozása
ssh -f -N -L 3307:localhost:3306 felhasznalo@db-szerver.pelda.com

# Várakozás a tunnel létrejöttére
sleep 2

# Biztonsági mentés készítése a helyi gépen
mysqldump -h 127.0.0.1 -P 3307 -u remote_user -p'remote_password' adatbazis_nev > backup_$(date +%Y%m%d).sql

# SSH tunnel leállítása
tunnel_pid=$(pgrep -f "ssh -f -N -L 3307:localhost:3306")
kill $tunnel_pid

echo "Az adatbázis biztonsági mentése elkészült: backup_$(date +%Y%m%d).sql"

Ez a szkript létrehoz egy SSH tunnelt, amely a helyi 3307-es portot a távoli szerver 3306-os portjára irányítja, majd elvégzi a biztonsági mentést a helyi gépen.

„Az SSH tunnel olyan, mint egy titkos alagút az internet dzsungelében. Lehetővé teszi, hogy biztonságosan elérjünk olyan szolgáltatásokat, amelyek egyébként nem lennének hozzáférhetőek vagy biztonságosak a nyílt interneten.”

Példa 3: Többszerveres monitoring SSH segítségével

Ha több szervert kell monitoroznunk, az SSH segítségével egyszerűen összegyűjthetjük az információkat:

#!/bin/bash
# monitor_servers.sh

# Szerverek listája
servers=(
    "web1.pelda.com"
    "web2.pelda.com"
    "db1.pelda.com"
    "db2.pelda.com"
)

# Eredmények fájlja
output_file="szerver_status_$(date +%Y%m%d).txt"
echo "Szerver monitoring - $(date)" > $output_file
echo "===============================" >> $output_file

# Minden szerveren lefuttatjuk a monitoring parancsokat
for server in "${servers[@]}"; do
    echo -e "\n$server:" >> $output_file
    echo "---------------------------------------" >> $output_file

    ssh -i ~/.ssh/monitoring_key monitoring@$server << 'EOF' >> $output_file
    echo "Uptime:"
    uptime
    echo -e "\nDisk usage:"
    df -h | grep -v tmpfs
    echo -e "\nMemory usage:"
    free -h
    echo -e "\nCPU load:"
    top -bn1 | head -n 5
    echo -e "\nActive connections:"
    netstat -tuan | grep ESTABLISHED | wc -l
EOF

    echo "---------------------------------------" >> $output_file
done

echo "A monitoring eredményei mentve: $output_file"

Ez a szkript minden szerverről összegyűjti a legfontosabb információkat, és egy fájlba menti őket.

Az SSH alapjai

Az SSH telepítése és alapvető beállítása

Telepítés Debian/Ubuntu rendszereken

Telepítés Fedora/CentOS/RHEL rendszereken

Telepítés Arch Linux rendszeren

Alapvető konfiguráció

SSH kulcspárok létrehozása és kezelése

Kulcspár generálása

A nyilvános kulcs megosztása a szerverrel

1. Az ssh-copy-id használata

2. Manuális másolás

3. Fájlátvitel és beállítás

Kulcsok kezelése SSH-agent segítségével

Különböző kulcsok különböző szerverekhez

SSH szerver biztonságos konfigurálása

Alapvető biztonsági beállítások

Felhasználók korlátozása

Hálózati korlátozások

Fail2Ban használata

Port Forwarding és Tunneling

Lokális port forwarding

Távoli port forwarding

Dinamikus port forwarding (SOCKS proxy)

Haladó SSH technikák és tippek

SSH konfigurációs fájl testreszabása

SSH Multiplexing

Fájlátvitel SSH-n keresztül

SCP használata

SFTP használata

X11 Forwarding

SSH Escape Sequences

SSH és rsync kombinálása

SSH hibaelhárítás és diagnosztika

Verbózis növelése a hibakereséshez

Gyakori hibaüzenetek és megoldásaik

„Connection refused”

„Permission denied (publickey,password)”

„Host key verification failed”

SSH szerver naplófájlok elemzése

Kapcsolódási problémák tűzfalak esetén

UFW (Ubuntu/Debian)

FirewallD (Fedora/CentOS/RHEL)

Iptables

Teljesítmény optimalizálás

SSH biztonsági legjobb gyakorlatok

Kulcsalapú hitelesítés használata

Erős kriptográfiai algoritmusok használata

Rendszeres frissítések

Két faktoros hitelesítés (2FA)

Jogosultságok korlátozása

Hálózati szintű védelem

Rendszeres auditálás

SSH és a modern DevOps gyakorlatok

SSH kulcsok használata CI/CD rendszerekben

SSH és konfigurációkezelés

SSH Jump Hosts és Bastion Hosts

SSH és konténerizáció

Összehasonlító táblázatok

SSH hitelesítési módszerek összehasonlítása

SSH szerveroldali konfigurációs beállítások

Valós példák és esettanulmányok

Példa 1: Webszerver automatizált telepítése

Példa 2: Adatbázis biztonsági mentése SSH tunnel segítségével

Példa 3: Többszerveres monitoring SSH segítségével

BeOS

Kapcsolódó tartalom