LSS - Lecture II - shells.pdf

# Terminal en shell Dit onderwerp legt het onderscheid uit tussen een terminalemulator en een shell, beschrijft verschillende typen terminals zoals virtuele en pseudo-terminals, en introduceert tools voor multiplexing zoals tmux en zellij. ### 1.1 Het onderscheid tussen terminal en shell De terminal (emulator) dient als de grafische interface of het venster waarmee een gebruiker communiceert met de computer door middel van tekstinvoer en -uitvoer. Het emuleert de functionaliteit van fysieke terminals uit het verleden die direct waren aangesloten op mainframe computers. De shell daarentegen is een programma dat fungeert als tussenpersoon tussen de gebruiker en de kernel van het besturingssysteem, waarbij commando's worden vertaald naar acties die het systeem kan uitvoeren. Kortom, de terminal is het venster waarin commando's worden getypt en resultaten worden gelezen, terwijl de shell het programma is dat deze commando's daadwerkelijk uitvoert. Dit interactieve programma wordt ook wel de command-line interface (CLI) genoemd [3](#page=3). > **Tip:** De illustraties op pagina's 4, 5 en 6 tonen hoe dezelfde shell (bash in Ubuntu via WSL2) kan worden gebruikt binnen verschillende terminalemulatoren, zoals de Windows Terminal, xterm, en cool-retro-term. Dit benadrukt het concept dat de shell onafhankelijk is van de terminalemulator die ervoor wordt gebruikt. ### 1.2 Soorten terminals Er worden twee hoofdcategorieën van terminals onderscheiden: virtuele terminals en pseudo-terminals [7](#page=7). #### 1.2.1 Virtuele terminals Virtuele terminals worden gebruikt om meerdere tekstgebaseerde sessies te beheren zonder dat er een grafische interface (GUI) nodig is. Deze zijn altijd beschikbaar op het systeem. Ze worden doorgaans aangeduid als `tty1`, `tty2`, enzovoort, en kunnen worden benaderd via toetscombinaties zoals `ALT+F1`, `ALT+F2`, enzovoort [7](#page=7). #### 1.2.2 Pseudo-terminals Pseudo-terminals (ook wel PTY's genoemd) worden dynamisch gecreëerd wanneer een nieuwe terminalemulator wordt geopend binnen een GUI of wanneer er via een netwerkverbinding wordt ingelogd, bijvoorbeeld met SSH [7](#page=7). ### 1.3 Tools voor multiplexing Tools voor multiplexing stellen gebruikers in staat om meerdere vensters en/of gesplitste weergaven binnen één enkele terminalvenster te beheren. Enkele prominente voorbeelden van dergelijke tools zijn `screen`, `tmux`, `zellij`, `tmate`, `terminator` en `tilix` [8](#page=8). #### 1.3.1 Tmux `tmux` (terminal multiplexer) is een populaire tool waarmee gebruikers meerdere vensters en gesplitste weergaven ("panes") kunnen openen binnen één terminalvenster. Een belangrijk kenmerk van `tmux` is dat het deze vensters en panes in een sessie houdt. Dit betekent dat gebruikers een sessie kunnen afsluiten (detachen) en op een later moment weer kunnen hervatten (re-attachen) [9](#page=9). > **Voorbeeld:** De tabel op pagina 11 geeft een overzicht van veelgebruikte `tmux` commando's: > * `tmux new -s myname` : Creëert een nieuwe `tmux` sessie genaamd `myname`. > * `ctrl-b d` : Ontkoppelt (detach) de huidige sessie. > * `tmux ls` : Toont een lijst van beschikbare sessies. > * `tmux attach -t myname` : Herstart/koppelt aan een specifieke sessie. > * `ctrl-b %` : Splitst het huidige venster verticaal. > * `ctrl-b "` : Splitst het huidige venster horizontaal. > * `ctrl-b c` : Creëert een nieuw venster. > * `ctrl-b p` : Gaat naar het vorige venster. > * `ctrl-b n` : Gaat naar het volgende venster. #### 1.3.2 Zellij `zellij` wordt beschreven als vergelijkbaar met `nano` (een eenvoudige teksteditor), in tegenstelling tot `tmux` of `screen` die meer vergelijkbaar zijn met `vim` (een krachtigere teksteditor). `zellij` biedt ook de functionaliteit van een terminal multiplexer. Het is mogelijk om `zellij` direct uit te proberen zonder installatie door de instructies op de officiële website te volgen [12](#page=12). --- # Begrip van de shell en commando-uitvoering Deze sectie legt uit hoe de shell commando's verwerkt, inclusief verschillende expansiemechanismen, en hoe input, output en fouten worden beheerd [15](#page=15). ### 2.1 Hoe de shell commando's verwerkt De shell is de interface waarmee gebruikers met het besturingssysteem communiceren. Voordat een commando daadwerkelijk wordt uitgevoerd, ondergaat het een reeks verwerkingsstappen door de shell. Dit proces begint met het opsplitsen van de invoerregel in afzonderlijke "tokens" of woorden, gebaseerd op speciale tekens zoals spatie, tab, newline, puntkomma en verschillende haakjes. Vervolgens vindt "word splitting" plaats, waarbij deze tokens verder worden onderverdeeld op basis van de `USDIFS` (Internal Field Separator) variabele. Daarna worden parameters uitgebreid, wat verwijst naar het vervangen van variabelen door hun waarden. Tot slot worden er diverse expansiemechanismen toegepast voordat het uiteindelijke commando wordt uitgevoerd [15](#page=15) [16](#page=16) [17](#page=17) [18](#page=18) [19](#page=19) [20](#page=20) [21](#page=21). ### 2.2 Expansiemechanismen De shell biedt krachtige mechanismen om de commando's die u invoert dynamisch uit te breiden. #### 2.2.1 Filename expansion Filename expansion, ook wel globbing genoemd, breidt patronen uit naar bestaande bestanden en mappen die aan het patroon voldoen. Als er geen overeenkomst wordt gevonden, wordt het patroon behandeld als een gewone string [16](#page=16). De volgende symbolen worden gebruikt: * `*`: Komt overeen met nul of meer tekens [16](#page=16). * `?`: Komt overeen met exact één teken [16](#page=16). * `[abcd]`: Komt overeen met exact één teken dat één van de opgegeven karakters is (bijvoorbeeld `a`, `b`, `c` of `d`) [16](#page=16). * `[a-d]`: Komt overeen met exact één teken dat binnen het opgegeven bereik valt (bijvoorbeeld `a` tot `d`) [16](#page=16). * `[^ab]` of `[!ab]`: Komt overeen met exact één teken dat *niet* één van de opgegeven karakters is (bijvoorbeeld niet `a` en niet `b`) [16](#page=16). > **Tip:** Dit mechanisme is erg nuttig om snel te verwijzen naar groepen bestanden zonder ze allemaal handmatig te hoeven typen. Onthoud dat het patroon alleen wordt uitgebreid als er daadwerkelijk bestanden zijn die ermee overeenkomen [16](#page=16). #### 2.2.2 Brace expansion Brace expansion genereert reeksen van tekens of getallen, onafhankelijk van het bestaan van bestanden [17](#page=17). De volgende constructies worden ondersteund: * `{a,b,c}`: Genereert de opgegeven items gescheiden door komma's (bijvoorbeeld `a`, `b`, `c`) [17](#page=17). * `{0..6}`: Genereert een reeks getallen binnen het opgegeven bereik (bijvoorbeeld `0`, `1`, `2`, `3`, `4`, `5`, `6`) [17](#page=17). * `{0..6..2}`: Genereert een reeks getallen binnen het bereik met een opgegeven stapgrootte (bijvoorbeeld `0`, `2`, `4`, `6`) [17](#page=17). > **Voorbeeld:** Het commando `echo {a,b}{1..2}` zou `a1 a2 b1 b2` produceren [17](#page=17). #### 2.2.3 Command substitution Command substitution laat u het resultaat van een commando gebruiken als onderdeel van een ander commando. De shell voert eerst het commando tussen de haakjes uit en vervangt vervolgens de hele constructie door de standaard output van dat commando. De moderne en aanbevolen manier om dit te doen is met `USD(...)`. Het gebruik van backticks `` `...` `` is verouderd [19](#page=19). > **Voorbeeld:** `du /usr/bin > USD(date +%Y-%m-%d)-bin-usage.log` zou de uitvoer van `date` gebruiken om een logbestand te creëren met de huidige datum in de naam [19](#page=19). #### 2.2.4 Arithmetic expansion Arithmetic expansion maakt het mogelijk om rekenkundige bewerkingen direct in de shell uit te voeren. Dit wordt gedaan met de constructie `USD((...))`. Variabelen binnen de dubbele haakjes worden automatisch als getallen behandeld [20](#page=20). > **Voorbeeld:** Als `$a=5` en `$b=4`, dan zal `echo USD((a+b))` het getal `9` afdrukken [20](#page=20). ### 2.3 Input, output en fouten Shells beheren de input, output en foutenstromen van commando's op gestandaardiseerde wijze. #### 2.3.1 Standaard streams Elk commando heeft drie standaard streams: * **Standaard input (stdin)**: De invoer die aan een commando wordt gegeven. Wordt typisch verwacht vanuit de toetsenbordinvoer [22](#page=22). * **Standaard output (stdout)**: De normale uitvoer van een commando. Wordt typisch getoond op de terminal [22](#page=22). * **Standaard error (stderr)**: De foutmeldingen van een commando. Wordt typisch ook getoond op de terminal [22](#page=22). #### 2.3.2 Piping Piping, aangegeven met het symbool `|`, stuurt de standaard output van het ene commando als standaard input naar het volgende commando. Het is belangrijk te weten dat *alleen* de standaard output wordt doorgegeven, niet de standaard error [23](#page=23) [24](#page=24). > **Voorbeeld:** `ls /usr/bin/a* | wc -l` toont hoeveel bestanden in `/usr/bin` beginnen met `a`. De uitvoer van `ls` wordt de invoer van `wc -l` [23](#page=23). #### 2.3.3 Redirection Redirection maakt het mogelijk om de standaard streams (input, output, errors) om te leiden naar bestanden of andere streams [25](#page=25). | Symbool | Betekenis | | :------- | :------------------------------------------------------- | | `>` | Schrijft output naar een bestand (overschrijft bestaand). | [25](#page=25). | `>>` | Voegt output toe aan een bestand. | [25](#page=25). | `<` | Gebruikt een bestand als input voor een commando. | [25](#page=25). | `2>` | Stuurt fouten (stderr) naar een bestand. | [25](#page=25). | `2>&1` | Stuurt standaard error ook naar standaard output. | [25](#page=25). | `2>&1 >/dev/null` | Stuurt output naar de prullenmand en errors naar standaard output. Hiermee worden enkel de errors behouden voor verdere verwerking. | [25](#page=25). > **Tip:** Als u zowel de standaard output als de standaard error van een commando naar hetzelfde bestand wilt schrijven, kunt u eerst de standaard error naar de standaard output leiden met `2>&1`, en vervolgens de standaard output (die nu ook de errors bevat) naar het gewenste bestand sturen [25](#page=25). ### 2.4 Hulpmiddelen voor begrip Er zijn externe hulpmiddelen beschikbaar om de werking van shellcommando's te begrijpen. De website [explainshell.com](https://explainshell.com/) is een waardevolle bron om de verschillende onderdelen van een shellcommando te ontleden. Daarnaast kan de `info` pagina van `bash` diepgaande documentatie bieden na installatie via `apt install info bash-doc` [18](#page=18) [26](#page=26). --- # Verschillende shells en hun gebruik Dit onderwerp biedt een overzicht van diverse command-line shells, hun functies, en hoe ze worden geconfigureerd en gebruikt in een besturingssysteemomgeving. ### 3.1 Overzicht van populaire shells Verschillende shells zijn beschikbaar met elk hun eigen kenmerken en ontwikkelingsgeschiedenis [28](#page=28). * **sh (Bourne Shell)**: Ontwikkeld door Stephen Bourne in de jaren '70 bij AT&T Bell Labs [28](#page=28). * **bash (Bourne-Again Shell)**: Uitgebracht in 1989, breidt de functionaliteit van `sh` uit met features zoals command completion en geschiedenisbeheer [28](#page=28). * **tcsh**: Een variant van de C shell (`csh`) van Berkeley Unix, met een syntax die meer lijkt op de C-programmeertaal [28](#page=28). * **dash (Debian Almquist Shell)**: Ontworpen om zo klein en snel mogelijk te zijn. Het is de standaard non-interactieve shell in Ubuntu/Debian [28](#page=28). * **zsh (Z Shell)**: Een uitgebreide Bourne shell, en de standaard shell in macOS Catalina en Kali 2020.4 [28](#page=28). Andere vermeldde shells zijn onder andere `ksh` (Korn Shell) en `fish` (Friendly Interactive Shell) [28](#page=28). ### 3.2 Interactieve en non-interactieve shells #### 3.2.1 Non-interactieve shells Wanneer shells non-interactief worden uitgevoerd, verwerken ze commando's die uit een bestand worden gelezen. De zogenaamde "shebang" (`#!`) aan het begin van scripts verwijst vaak naar `'/bin/sh'` of `'/usr/bin/sh'` als de non-interactieve shell. In veel huidige Debian-releases is `'/bin/sh'` een symbolische link naar `dash'` [29](#page=29) [30](#page=30). > **Voorbeeld:** > ```bash > ~USD cat helloworld.sh > #!/bin/sh > echo "hello world" > ``` > Wanneer dit script wordt uitgevoerd, wordt `echo "hello world"` verwerkt door de shell die wordt gespecificeerd door de shebang [29](#page=29). #### 3.2.2 Interactieve login shells Een interactieve login shell is de shell waarmee een gebruiker zich aanmeldt bij het systeem. De lijst met beschikbare geïnstalleerde shells kan worden gevonden in het bestand `'/etc/shells'` [31](#page=31). > **Voorbeeld van `'/etc/shells'`:** > ``` > # /etc/shells: valid login shells > /bin/sh > /bin/bash > /usr/bin/bash > /bin/rbash > /usr/bin/rbash > /bin/dash > /usr/bin/dash > ``` > [31](#page=31). De standaard login shell voor nieuwe gebruikers wordt geconfigureerd via het `adduser` commando in `'/etc/adduser.conf'` (Debian) of `useradd` in `'/etc/default/useradd'` (Debian/RHEL). De login shell voor elke gebruiker is vastgelegd in `'/etc/passwd'`. De login shell van een gebruiker kan worden gewijzigd met het commando `chsh` of `usermod --shell ` [32](#page=32). #### 3.2.3 Bepalen van de huidige shell Om te achterhalen welke shell momenteel actief is, kan men gebruik maken van de PID van het draaiende proces. De variabele `$$` bevat de PID van de huidige shell. Met `ps -p $$` kan de commando-naam van dit proces worden getoond. Alternatief ondersteunen de meeste shells de variabele `$0`. Merk op dat `$SHELL` verwijst naar de *standaard* shell, niet noodzakelijkerwijs de shell die momenteel draait [33](#page=33). > **Tip:** De variabele `USDSHELL` is een omgevingsvariabele die de padnaam van de standaardlogin shell van de gebruiker bevat [33](#page=33). > **Voorbeeld:** > ```bash > ~USD ps -p USDUSD > PID TTY TIME CMD > 1262 pts/0 00:00:00 bash > > ~$ echo $0 > -bash > > ~$ echo $SHELL > /bin/bash > ``` > [33](#page=33). ### 3.3 Restricted shells Restricted shells zijn ontworpen om de mogelijkheden van een gebruiker te beperken [35](#page=35). #### 3.3.1 rbash (Restricted Bash) `rbash` is in feite `bash` met de `-r` optie geactiveerd, wat resulteert in beperkte functionaliteit. Informatie hierover is te vinden via `man rbash` of door de `-r` optie in `man bash` te bekijken. `rbash` is ook terug te vinden in `'/etc/shells'`, wat aangeeft dat het een geldige login shell kan zijn [35](#page=35). > **Let op:** `rbash` kan relatief eenvoudig worden omzeild. Er bestaan diverse technieken en gidsen voor het omzeilen van restricted shells [37](#page=37). #### 3.3.2 /usr/sbin/nologin De `nologin` shell, vaak te vinden in `'/usr/sbin/nologin'`, wordt gebruikt om gebruikers te verhinderen zich interactief aan te melden op het systeem. Als `nologin` wordt toegewezen als standaard login shell, kan de gebruiker geen interactieve sessie starten. Dit is nuttig voor gebruikers die alleen diensten zoals FTP of SFTP moeten kunnen gebruiken, maar geen toegang tot de shell nodig hebben. Het bestand `nologin` wordt niet vermeld in `'/etc/shells'` [38](#page=38). > **Belangrijk onderscheid:** `/usr/sbin/nologin` is een programma dat wordt uitgevoerd wanneer een gebruiker probeert in te loggen met `nologin` als shell. Dit verschilt van het bestand `'/etc/nologin'`. Als het bestand `'/etc/nologin'` (of `'/var/run/nologin'`) bestaat en leesbaar is, wordt alleen root toegelaten tot het systeem. Andere gebruikers zien de inhoud van dit bestand en hun loginpogingen worden geweigerd. Dit biedt een manier om tijdelijk alle onbevoegde logins te blokkeren [39](#page=39). ### 3.4 Shell geschiedenis en timestamping De omgevingsvariabele `USDHISTTIMEFORMAT` kan worden ingesteld om timestamps toe te voegen aan de shell geschiedenis. Dit maakt het gemakkelijker om de tijdstippen van commando-uitvoering te traceren [40](#page=40). --- # Superuser-toegang en handige tools Dit onderdeel behandelt methoden om root-rechten te verkrijgen via `su` en `sudo`, en introduceert diverse nuttige shell-commando's, sneltoetsen en documentatie-tools zoals `man` en `info`. ### 4.1 Superuser-toegang verkrijgen Het verkrijgen van superuser-rechten is essentieel voor het uitvoeren van beheer taken op een Linux-systeem. Er zijn verschillende commando's om dit te bewerkstelligen, elk met subtiele verschillen in hoe ze de omgeving en de gebruiker die het commando uitvoert beheren [42](#page=42). #### 4.1.1 `su` commando Het `su` (substitute user) commando stelt een gebruiker in staat om een andere gebruiker te worden. Standaard wordt de gebruiker root [42](#page=42). * **`su`**: Hiermee wordt de gebruiker root, maar de omgeving blijft deels behouden van de oorspronkelijke gebruiker. Er is een wachtwoord van de root-gebruiker voor nodig [42](#page=42). * **`su -`** of **`su --login`**: Hiermee wordt de gebruiker root en wordt de shell gestart met de omgevingsvariabelen van de root-gebruiker alsof er direct als root is ingelogd. Ook hiervoor is het root-wachtwoord vereist [42](#page=42). #### 4.1.2 `sudo` commando Het `sudo` (superuser do) commando is een alternatieve en vaak veiligere manier om commando's uit te voeren met verhoogde privileges. `sudo` werkt op basis van configuratiebestanden (`/etc/sudoers`) die bepalen wie welke commando's mag uitvoeren. Het vereist niet het root-wachtwoord, maar het wachtwoord van de gebruiker die het commando uitvoert [42](#page=42). * **`sudo -s`** of **`sudo --shell`**: Start een shell als de huidige gebruiker, maar met de mogelijkheid om commando's als root uit te voeren. De omgeving van de gebruiker wordt behouden [42](#page=42). * **`sudo su -`** of **`sudo su --login`**: Start een shell als root met de omgevingsvariabelen van root [42](#page=42). * **`sudo -i`** of **`sudo --login`**: Dit commando is gelijk aan `sudo su -` en start een interactieve shell als root met de volledige root-omgeving [42](#page=42). > **Tip:** `sudo!!` is een handige sneltoets die het laatst uitgevoerde commando opnieuw uitvoert, maar dan met `sudo` ervoor. Dit is handig als je bijvoorbeeld `apt update` uitvoert en een "permission denied" foutmelding krijgt [46](#page=46). ### 4.2 Nuttige shell commando's en sneltoetsen De command-line interface (shell) biedt een breed scala aan commando's en sneltoetsen die de productiviteit aanzienlijk kunnen verhogen [43](#page=43) [44](#page=44). #### 4.2.1 Sneltoetsen Er zijn diverse sneltoetsen die standaard werken in de meeste shells en terminal-emulators [44](#page=44): * `CTRL + A`: Ga naar het begin van de regel [44](#page=44). * `CTRL + E`: Ga naar het einde van de regel [44](#page=44). * `CTRL + L`: Maakt het scherm leeg, vergelijkbaar met het `clear` commando maar zonder de huidige regel te verwijderen [44](#page=44). * `CTRL + W`: Verwijdert het woord direct voor de cursor [44](#page=44). * `CTRL + left/right`: Springt een woord per keer vooruit of achteruit [44](#page=44). * `CTRL + R`: Start een omgekeerde zoekactie in de commando-geschiedenis (in sommige terminals, zoals cmd, is dit F7) [44](#page=44). #### 4.2.2 Belangrijke commando's Een selectie van veelgebruikte en krachtige commando's omvat [45](#page=45): * **Bestandsbeheer en navigatie**: * `pwd`: Toont de huidige werkdirectory [45](#page=45). * `cd`: Wijzigt de huidige directory [45](#page=45). * `ls`: Geeft een lijst van bestanden en mappen in de huidige of een gespecificeerde directory [45](#page=45). * `rm`: Verwijdert bestanden of mappen [45](#page=45). * `cp`: Kopieert bestanden of mappen [45](#page=45). * `mv`: Verplaatst of hernoemt bestanden of mappen [45](#page=45). * **Bestandsinhoud en manipulatie**: * `cat`: Toont de inhoud van een of meerdere bestanden [45](#page=45). * `less`, `more`: Pagineren door lange bestanden, waarbij `less` meer functionaliteit biedt [45](#page=45). * `head`: Toont de eerste regels van een bestand [45](#page=45). * `tail`: Toont de laatste regels van een bestand [45](#page=45). * `wc`: Telt het aantal regels, woorden en karakters in een bestand [45](#page=45). * `cut`: Verwijdert secties uit elke regel van bestanden [45](#page=45). * `sort`: Sorteert regels in tekstbestanden [45](#page=45). * **Zoeken en filteren**: * `grep`: Zoekt naar patronen in bestanden [45](#page=45). * `find`: Zoekt naar bestanden en mappen in een directoryhiërarchie, met krachtige filteropties zoals op naam, tijdstempel, permissies en grootte [45](#page=45) [49](#page=49). * `locate`: Een snellere zoekopdracht die een geïndexeerde database gebruikt; vereist `updatedb` om de index bij te werken [45](#page=45) [49](#page=49). * **Procesbeheer**: * `ps`: Geeft informatie over actieve processen [45](#page=45). * `kill`: Verstuurt signalen naar processen, vaak om ze te beëindigen [45](#page=45). * `bg`: Zet een gestopt proces voort op de achtergrond [45](#page=45). * `fg`: Brengt een achtergrondproces naar de voorgrond [45](#page=45). * `jobs`: Toont de actieve jobs in de huidige shell [45](#page=45). * **Netwerk en schijfgebruik**: * `wget`: Downloadt bestanden van het web [45](#page=45). * `netstat` / `ss`: Toont netwerkverbindingen en statistieken [45](#page=45). * `df`: Rapporteert schijfgebruik van bestandssystemen [45](#page=45). * `du`: Schat schijfgebruik van bestanden [45](#page=45). * **Bestandspermissies**: * `chmod`: Wijzigt toegangsrechten van bestanden [45](#page=45). * `chown`: Wijzigt de eigenaar en groep van bestanden [45](#page=45). #### 4.2.3 Documentatie tools Wanneer je een commando niet kent of de opties ervan wilt opzoeken, zijn `man` en `info` de standaard documentatie-hulpmiddelen [45](#page=45) [48](#page=48). * **`man` pages**: Het `man` (manual) commando toont de handleidingpagina's voor commando's, systeemoproepen, configuratiebestanden, etc. [46](#page=46). * `man `: Toont de handleiding van een commando. * `man -k ` of `apropos `: Zoekt naar commando's op basis van trefwoorden in hun beschrijving [46](#page=46). * `man -f ` of `whatis `: Geeft een korte beschrijving van een commando [46](#page=46). * `man `: Soms zijn er meerdere handleidingen voor hetzelfde commando in verschillende secties (bijvoorbeeld `man 1 passwd` voor het commando en `man 5 passwd` voor het configuratiebestand) [47](#page=47). * **`info` pages**: Het `info` commando is een ander documentatiesysteem, vaak met meer uitgebreide en gestructureerde informatie dan de `man` pages [45](#page=45). > **Tip:** Maak er een gewoonte van om bij twijfel de `man` of `info` pagina's te raadplegen. Dit is een cruciale vaardigheid voor effectief command-line gebruik [46](#page=46). ### 4.3 Shell fun Naast de serieuze tools zijn er ook commando's die voor amusement zorgen [50](#page=50). * `sl`: Een animatie van een stoomtrein die door de terminal rijdt [50](#page=50). * `lolcat`: Kleurt de output van commando's in regenboogkleuren [50](#page=50). * `cowsay`: Laat een koe (of andere figuren) een tekstballon uitspreken [50](#page=50). * `hollywood`: Start een "hackermodus" met vallende karakters [50](#page=50). * `curl wttr.in/Bruges`: Toont het weerbericht voor een specifieke locatie [50](#page=50). * `telnet mapscii.me`: Toont een ASCII-kaart [50](#page=50). --- # Secure Shell (SSH) en tunneling Dit hoofdstuk behandelt het Secure Shell (SSH) protocol, de implementatie ervan, het gebruik van SSH-sleutels voor authenticatie en serveridentificatie, en introduceert SSH-tunnelingtechnieken zoals lokale en reverse port forwarding. ### 5.1 Het SSH-protocol SSH is primair een applicatie- en transportprotocol dat is gedefinieerd in RFC 4251. Het hoofddoel van SSH is het beveiligen van netwerkservices over een onbeveiligd netwerk, wat essentiële functionaliteiten biedt zoals veilige remote logins, veilige bestandsoverdrachten met protocollen zoals Secure Copy Protocol (SCP) en SSH File Transfer Protocol (SFTP) [53](#page=53). Er zijn twee belangrijke versies van het protocol: * **SSH-1**: Dit is de oudere versie die sinds 1995 bestaat, maar wordt niet meer ondersteund door veel moderne implementaties [53](#page=53). * **SSH-2**: Deze versie is sinds 2006 de huidige standaard en wordt in de meeste gevallen gebruikt. Het is belangrijk te weten dat SSH-1 en SSH-2 niet compatibel zijn met elkaar [53](#page=53). ### 5.2 OpenSSH implementatie OpenSSH is een veelgebruikte implementatie van het SSH-protocol. Hoewel SSH de naam van het protocol is, verwijst `ssh` ook naar het clientprogramma van OpenSSH [54](#page=54). Op Linux-systemen worden de benodigde pakketten voor OpenSSH doorgaans geleverd als `openssh-client` en `openssh-server`. De configuratiebestanden bevinden zich op de volgende locaties [54](#page=54): * Voor de SSH-client: `/etc/ssh/ssh_config` [54](#page=54). * Voor de SSH-server (daemon): `/etc/ssh/sshd_config` [54](#page=54). Op Windows-systemen zijn de uitvoerbare bestanden van OpenSSH (inclusief `sshd` indien geïnstalleerd) te vinden in `C:\Windows\System32\OpenSSH`. Hier bevindt zich ook het `sshd_config` bestand als de OpenSSH server is geïnstalleerd [55](#page=55). ### 5.3 SSH-sleutels voor authenticatie en serveridentificatie SSH maakt gebruik van cryptografische sleutelparen voor zowel authenticatie als het verifiëren van de identiteit van servers en clients [56](#page=56). #### 5.3.1 Serveridentificatie Om de identiteit van een server te verifiëren, gebruikt de client de **server host key**. Deze sleutels zijn te vinden op de server in het bestand `/etc/ssh/ssh_host_*_key` en komen in verschillende formaten voor (RSA, ECDSA, ED25519) [56](#page=56). De client bewaart informatie over servers die het vertrouwt in een bestand genaamd `known_hosts`. Op Linux-systemen bevindt dit bestand zich in de `.ssh` directory van de gebruiker. Op Windows-systemen is dit `%UserProfile%\.ssh\known_hosts` [56](#page=56) [57](#page=57). Wanneer een client voor het eerst verbinding maakt met een server, stuurt de server zijn publieke host key naar de client. De client controleert of deze sleutel overeenkomt met een reeds bekende sleutel in het `known_hosts` bestand. Deze controle gebeurt op basis van de **fingerprint** van de publieke sleutel van de server, wat een unieke checksum is [57](#page=57). Als de fingerprint van de server die de client probeert te bereiken niet overeenkomt met de opgeslagen fingerprint, wordt de verbinding geweigerd omdat er een risico is dat het niet de bedoelde host betreft [58](#page=58). #### 5.3.2 Clientauthenticatie Voor het verifiëren van de identiteit van clients worden ook SSH-sleutels gebruikt. De publieke sleutels van clients die geautoriseerd zijn om in te loggen, worden op de server opgeslagen in het bestand `.ssh/authorized_keys` [56](#page=56). Er zijn twee hoofdmethoden voor clientlogin: * **Password login**: Hierbij worden wachtwoorden gebruikt. Deze methode is automatisch, maar kan gevoeliger zijn voor Man-in-the-Middle (MITM) aanvallen als de server fingerprint waarschuwingen worden genegeerd [59](#page=59). * **SSH key login**: Hierbij worden SSH-sleutelparen gebruikt. Deze sleutels worden handmatig gegenereerd en maken automatische login mogelijk, wat als veiliger wordt beschouwd dan wachtwoordauthenticatie [59](#page=59). ### 5.4 SSH-tunneling SSH-tunneling, ook wel bekend als port forwarding, stelt gebruikers in staat om netwerkverkeer van de ene poort naar de andere te leiden, veilig versleuteld door de SSH-verbinding. Er zijn twee primaire vormen van SSH-tunneling: lokaal en reverse port forwarding [60](#page=60). #### 5.4.1 Lokaal port forwarding (`-L`) Lokaal port forwarding wordt gebruikt om een lokale poort op uw machine te koppelen aan een poort op een externe host, via de SSH-server. Dit is nuttig om toegang te krijgen tot services die normaal gesproken niet extern bereikbaar zijn [61](#page=61). De syntax is: `ssh -L :: @` [61](#page=61). **Voorbeeld**: `ssh -L 8080:reddit.com:80 sshuser@172.21.18.53` [61](#page=61). In dit voorbeeld wordt verkeer dat binnenkomt op poort `8080` van de lokale machine, via de SSH-verbinding gestuurd naar `reddit.com` op poort `80`. `remote_host` en `IP` kunnen extern zijn en zelfs dezelfde host zijn [61](#page=61). #### 5.4.2 Reverse port forwarding (`-R`) Reverse port forwarding wordt gebruikt om een poort op de SSH-server te koppelen aan een poort op uw lokale machine of een machine in uw lokale netwerk. Dit is nuttig wanneer u een service op uw lokale machine beschikbaar wilt maken voor een externe partij, zelfs als u zich achter een NAT bevindt [62](#page=62). Om reverse port forwarding te gebruiken, moet de SSH-serverconfiguratie mogelijk worden aangepast [62](#page=62): 1. Bewerk het bestand `/etc/ssh/sshd_config`. 2. Stel de optie `GatewayPorts yes` in [62](#page=62). 3. Herstart de SSH-daemon: `systemctl restart sshd` [62](#page=62). De syntax is: `ssh -R :: @` [62](#page=62). **Voorbeeld**: `ssh -R 8888:localhost:8000 sshuser@172.21.18.53` [62](#page=62). Dit betekent dat verkeer dat binnenkomt op poort `8888` van de SSH-server (die zich op `172.21.18.53` bevindt), via de SSH-verbinding wordt doorgestuurd naar poort `8000` van de lokale machine (`localhost` relatief aan de SSH-client) [62](#page=62). #### 5.4.3 Onthouden van tunnelopties Een handige manier om de opties voor lokaal en reverse port forwarding te onthouden is door te denken aan de richting van de dataflow [63](#page=63): * `ssh -L`: Staat voor "local to remote" [63](#page=63). * `ssh -R`: Staat voor "remote to local" [63](#page=63). Meer details kunnen gevonden worden in de man-pagina van `ssh` door te zoeken naar "-L" en "-R" [63](#page=63). #### 5.4.4 Use cases voor tunneling * **Database server toegankelijk maken**: Stel dat een database server PostgreSQL draait op poort 5432, maar alleen lokale verbindingen toestaat. Als u toegang wilt vanaf een externe machine en u heeft een externe IP met een SSH-server, kunt u een lokale tunnel opzetten [64](#page=64): `ssh -L 9000:localhost:5432 user@IP` Vervolgens verbindt u met `localhost:9000` om de database te bereiken [64](#page=64). * **Lokale applicatie extern beschikbaar maken**: Als u een applicatie op poort 8000 lokaal draait achter NAT, en collega's deze willen testen, kunt u een reverse tunnel gebruiken via een externe SSH-server [65](#page=65): `ssh -R 8888:localhost:8000 user@IP` Uw collega's kunnen dan verbinden met `IP:8888` om uw lokale applicatie te benaderen [65](#page=65). #### 5.5 Andere SSH features Naast de kernfunctionaliteiten en tunneling biedt SSH nog diverse andere nuttige functies [67](#page=67) [68](#page=68): * **Commando's uitvoeren zonder in te loggen**: U kunt direct commando's uitvoeren op een remote machine [67](#page=67): `ssh student@172.21.19.1 cat /home/student/file.txt` `ssh root@192.168.32.136 tcpdump -i ens33` (vereist `PermitRootLogin yes` op de server) * **GUI programma's remote uitvoeren**: Met de optie `X11Forwarding` kunt u grafische applicaties remote draaien [67](#page=67): `ssh -fX @ ` * **Remote directory's mounten**: Met `sshfs` kunt u remote bestandssystemen lokaal mounten [67](#page=67): `sshfs user@IP:/media/data ~/server/` (op Linux) * **Springen via jump hosts**: U kunt meerdere SSH-servers doorlopen om een eindbestemming te bereiken, waarbij de verbinding van begin tot eind versleuteld blijft [68](#page=68): `ssh -J host1,host2,host3 user@host4` * **Port forwarding aanpassen binnen een sessie**: Door binnen een SSH-sessie de controle-escape sequentie `~C` te gebruiken (druk op Enter en type dan `~C`), kunt u de huidige verbinding bewerken en bijvoorbeeld een nieuwe port forwarding toevoegen [68](#page=68). > **Tip:** Een lab-oefening kan onder andere het opzetten van een SSH-tunnel naar een VM op een Howest server omvatten [69](#page=69). --- ## Veelgemaakte fouten om te vermijden - Bestudeer alle onderwerpen grondig voor examens - Let op formules en belangrijke definities - Oefen met de voorbeelden in elke sectie - Memoriseer niet zonder de onderliggende concepten te begrijpen

| Term | Definition | |------|------------| | Terminal (emulator) | Een interface voor tekstinvoer en -uitvoer, die communiceert met de computer. Het emuleert vroegere fysieke terminals die direct verbonden waren met een centrale mainframecomputer. | | Shell | Een programma dat fungeert als tussenpersoon tussen de gebruiker en de kernel, en commando's vertaalt naar acties die het systeem kan uitvoeren. | | Terminal Multiplexer | Een programma dat het mogelijk maakt om binnen één terminalvenster meerdere vensters en gesplitste weergaven (panes) te openen en deze sessies te bewaren, zodat men kan uitloggen en later kan verdergaan. Voorbeelden zijn tmux en zellij. | | Bestandsnaamexpansie | Een functie van de shell die patronen gebruikt om overeenkomende bestandsnamen uit te breiden. Als er geen overeenkomst is, wordt het patroon behandeld als een gewone tekenreeks. Symbolen zoals `*` (nul of meer tekens) en `?` (exact één teken) worden gebruikt. | | Brace Expansion (Kolfuitbreiding) | Een shellfunctie die reeksen van tekens of getallen genereert op basis van de opgegeven patronen binnen accolades, zoals `{a,b,c}` of `{0..6}`. Dit hoeft niet overeen te komen met bestaande bestandsnamen. | | Command Substitution (Commando Substitutie) | Een functie die de uitvoer van een commando vervangt door de werkelijke uitvoer ervan. Dit wordt gedaan met behulp van `$( )` of de verouderde backticks ` ` . | | Arithmetic Expansion (Rekenkundige Expansie) | Een shellfunctie die rekenkundige expressies evalueert. Dit wordt gedaan met behulp van `(( ))` en stelt gebruikers in staat om berekeningen direct in de shell uit te voeren. | | Piping (Pijplijn) | Een mechanisme dat de standaarduitvoer van het ene commando doorstuurt als standaardinvoer naar een ander commando. Alleen de standaarduitvoer wordt standaard doorgegeven, geen foutmeldingen. | | Redirection (Herleiding) | Het proces waarbij de standaardinvoer, -uitvoer of -foutstroom van een commando wordt gewijzigd naar een bestand of een andere stream. Symbolen zoals `>` (overschrijven), `>>` (toevoegen), `<` (invoer) en `2>` (fouten) worden gebruikt. | | Virtual Terminal (Virtuele Terminal) | Een tekstgebaseerde interface die wordt gebruikt om meerdere sessies te beheren zonder grafische interface. Deze zijn altijd beschikbaar en worden aangeduid met namen als 'tty1', 'tty2'. | | Pseudo Terminal | Een terminal die dynamisch wordt aangemaakt bij het openen van een nieuwe terminalemulator in een grafische omgeving of via een netwerkverbinding, zoals SSH. | | SSH (Secure Shell) | Een netwerkprotocol dat wordt gebruikt voor veilige netwerkservices over een onbeveiligd netwerk, met name voor veilige externe logins, bestandsoverdrachten (SCP, SFTP) en andere toepassingen. | | SSH Tunneling (SSH Tunneling) | Een techniek waarbij netwerkverkeer via een beveiligde SSH-verbinding wordt geleid. Dit omvat Local Port Forwarding (lokale poort doorsturen naar een externe host) en Reverse Port Forwarding (externe poort doorsturen naar een lokale host). | | SSH Keys | Cryptografische sleutelparen (publiek en privé) die worden gebruikt voor authenticatie en autorisatie in SSH. SSH-sleutels kunnen wachtwoordloze logins mogelijk maken en verhogen de beveiliging door het gebruik van sterke encryptie. | | Restricted Shell (Beperkte Shell) | Een shellconfiguratie die de mogelijkheden van een gebruiker beperkt. `rbash` is een voorbeeld dat de toegang tot bepaalde commando's of functionaliteiten beperkt om de veiligheid te verhogen. | | `/usr/sbin/nologin` | Een speciaal programma dat wordt gebruikt als login-shell voor gebruikers die geen interactieve toegang tot het systeem nodig hebben. Het weigert login-pogingen en toont eventueel een bericht. |