===== SSH (Secure Shell) =====

Verwendeter Port: 22/tcp

=== Ausführung eines Scripts beim SSH-Login ===
<WRAP center round important 60%>

/etc/sshrc 	-> Script wird ausgeführt, sobald ein User sich per SSH authentifiziert hat, das geschieht noch vor dem Laden einer Shell


</WRAP>
Möglicher Inhalt, der eine Mail raussendet, wenn ein SSH-Login erfolgt ist
<code>
#!/bin/bash

ip=`echo $SSH_CONNECTION | cut -d " " -f 1`
hostname=`hostname`
fqdn=`hostname -f`

logger -t ssh-wrapper $USER login from $ip

sendmail -t <<EOF
To: MeinName <meine_email>
From: MeinAbsender
Subject: SSH Login $USER from $ip
User $USER just logged in from $ip
EOF
</code>

			   
Mit der Option -p kann man einen alternativen Port nutzen, falls der Server so konfiguriert wurde 
  ssh -p <Port> <user>@<Server> 
								

Konfigurationsdatei:
  /etc/ssh/sshd_config
  
<WRAP center round important 60%>
Wichtige Parameter:
  PermitRootLogin yes|no         -> Default: no
  PubKeyAuthentication yes|no    -> Default: yes
  AllowUsers <user1> <user2> ...
  PasswordAuthentication         -> Default: yes		
  Protocol 2,1                   -> Default: 2,1
</WRAP>


Client-Config:
  /etc/ssh/ssh_config
 
  
==== SSH-Tunnel ====
=== 1. Szenario ===
== Einen Webserver, der auf dem Zielhost auf Port 80 lüuft, über localhost port 4711 erreichbar machen ==

In der /etc/ssh/sshd_conf muss folgende Option aktiviert sein: 
  AllowTcpForwarding yes
 
Verbindungsaufbau: A → B 
  ssh -L<LokalerPort>:Zielserver:<RemoterPort> <user>@Zielserver
  z. b. ssh -L4711:192.168.178.20:80 root@192.168.178.20
  
Test: Internet Browser
  http://localhost:4711 -> man erhalt den Inhalt vom Webserver auf dem Zielserver Port 80


=== 2. Szenario ===
== Webserver vom Zielserver Port 80, über einen Drittserver erreichen und  über localhost:<lokaler Port> erreichbar machen ==

Verbindungsaufbau: A → C
  ssh -L<LokalerPort>:Zielserver:<RemotePort auf Zielserver> <user>@<Dritt-Server>

Der "Dritt-Server" muss Zugriff auf den Zielserver haben und das Forwarding muss erlaubt sein

Test: Internet Browser
  http://localhost:<LoaklerPort>


==== SSH per Key ====
=== SSH-Key Paar auf Debian-Client [debian-efi] erzeugen ===
<code>
  mkdir -p ~/.ssh
  chmod 700 ~/.ssh
  cd ~/.ssh
  # SSH-Key erzeugen 
  ssh-keygen -t <TYPE_OF_KEY> -b 4096 # 4096 ist hier die Bitlänge, TYPE_OF_KEY: dsa | ecdsa | ed25519 | rsa
  z. B. ssh-keygen -t rsa -b 4096
</code>

=== Methode 1 -> Debian: SSH-Schlüssel manuell übertragen ===
<code>
   scp id_rsa-pub $USER@172.16.17.1:/tmp/debian-efi_rsa.pub
</code>
\\
\\
=== Centos7 - SSH-Server: Public-Key Authentifizierung einrichten ===
<code>
  mkdir -p ~/.ssh
  # Berechtigungen des neuen Ordners anpassen
  chmod 700 ~/.ssh
  
Den vom Client kopierten public key /tmp/debian-efi_<TYPE_OF_KEY>.pub an die ~/.ssh/authorized_keys anhängen

  cat /tmp/debian-efi_rsa.pub >> ~/.ssh/authorized_keys

  # Berechtigungen der Datei setzen
  chmod 600 authorized_keys
</code>
\\
** Fertig! Der Zugriff ohne Passwort ist jetzt per SSH möglich. **
\\
\\
=== Methode 2 -> Schlüsseltausch per ssh-copy-id ===

== Mit ssh-copy-id den pubic-key direkt in die authorzed_keys Datei auf dem Zielsystem einstellen: ==
<code>
  ssh-copy-id -i ~/.ssh/id_rsa.pub $USER@172.16.17.1
</code>

sshd_config anpassen:
<code>
  cd /etc/ssh
  cp sshd_config sshd_config.<YYYYMMDDSSMM>
  vi sshd_config
  # folgende Option setzen/ändern
  PubkeyAuthentication yes
</code>
  
systemctl restart sshd

SSH-Anmeldung vom Client [debian-efi] zum Centos7-Server:
  ssh -i ~/.ssh/id_rsa_pub $USER@172.16.17.1

identity file in /etc/ssh/ssh_config eintragen, damit man diesen nicht immer mit -i ... angeben muss:
<code>
  cd /etc/ssh
  vi ssh_config
  # folgende Zeile einfügen
  IdentityFile ~/.ssh/id_rsa_pub
</code>


==== SSH-Agent =====

ssh-agent starten:
  eval `ssh-agent -s`

== Privaten SSH-Schlüssel erzeugen: ==
  mkdir -p ~/.ssh
  chmod 700 ~/.ssh
  # SSH-Key mit Passphrase anlegen
  ssh-keygen -t <TYPE_OF_KEY> -f debian-efi-p_<TYPE_OF_KEY>   # TYPE_OF_KEY: dsa | ecdsa | ed25519 | rsa
  z. B. mit ssh-keygen -t rsa -b 4096 -f ~/.ssh/debian-efi-p_rsa                                                           

== Privaten Schlüssel hinzufügen: ==
  ssh-add debian-efi-p_<TYPE_OF_KEY>   # Passphrase wird abgefragt
  z. B. ssh-add debian-efi-p_rsa       

== Anmeldung vom Client [debian-efi] testen: ==
  ssh -i ~/.ssh/debian-efi-p_<TYPE_OF_KEY> user1@172.16.17.1 # es wird keine Passphrase mehr abgefragt
  z. B. ssh- i ~/.ssh/debian-efi-p_<TYPE_OF_KEY> $USER@172.16.17.1