Wissen

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
====== SSH / SSL ======

  * [[http://www.golem.de/news/dan-j-bernstein-krypto-algorithmen-sicher-designen-1501-111605-2.html|Krypto-Algorithmen sicher designen]] von Dan J. Bernstein -> Dan Bernstein fordert Algorithmen, bei denen man weniger falsch machen kann.
  * **[[SSH-Schlüssel austauschen für ein passwortlosen Login]]**
  * [[OpenSSL]]
  * [[::EDV:SSL-Schlüssel generieren]]
    * [[letsencrypt]]
  * [[einzelne Dateien mit openSSL verschlüsseln]]
  * [[Datenbankverbindungen zu einer MySQL mit SSL-Verschlüsselung]]
  * [[https://www.poftut.com/use-openssl-s_client-check-verify-ssltls-https-webserver/|How To Use OpenSSL s_client To Check and Verify SSL/TLS Of HTTPS Webserver?]]
  * [[SCP-only mit Change Root]]
  * [[SFTP-User mit Change Root]]
    * Datenaustausch zwischen **Android** ([[https://play.google.com/store/apps/details?id=nextapp.fx|FX File Explorer]] & [[https://play.google.com/store/apps/details?id=nextapp.fx.rk|FX Plus License]]) und **FreeBSD** per **''SFTP''**: siehe [[#sshd_config|SSHD Config]]
  * [[SSH/BASH mit Change Root]]
  * [[SSH-Tunnel]]
  * [[http://hp.kairaven.de/scpsftp/scp-sftp.html|SCP und SFTP unter Linux & Windows]]
  * __**[[SSH/SCP - Sicherheit und Geschwindigkeit]]**__
    * SSH Key erstellen
      * ''%%ssh-keygen -t rsa -b 4096%%''
      * ''%%ssh-keygen -t ed25519%%''
    * SSH Key erstellen mit höherer KDF Rundenzahl (nur längere Passphrasen Verifikation)
      * ''%%ssh-keygen -t rsa -b 4096 -a 256%%''
      * ''%%ssh-keygen -t ed25519 -a 256%%''
    * ''%%echo 'eval $(ssh-agent)' >> ~/.bashrc%%''
    * ''%%echo "ssh-add" >> ~/.bashrc%%''
    * ''%%ssh fritz@mein.sshserver.de:/home/fritz%%''
      * //''%%ssh -o "StrictHostKeyChecking=no" fritz@mein.sshserver.de%%''//
    * ''%%sftp fritz@mein.sshserver.de:/home/fritz%%''
  * [[SSHFS]]
    * ''%%sshfs fritz@mein.sshserver.de:/home/fritz /mnt%%''
  * [[Fehler: Gesicherte Verbindung fehlgeschlagen]]


===== TLS-Ciphers anzeigen =====

  # openssl ciphers -v | fgrep TLSv1.2 | sed 's/.*/  &/'
  ECDHE-ECDSA-AES256-GCM-SHA384 TLSv1.2 Kx=ECDH     Au=ECDSA Enc=AESGCM(256) Mac=AEAD
  ECDHE-RSA-AES256-GCM-SHA384 TLSv1.2 Kx=ECDH     Au=RSA  Enc=AESGCM(256) Mac=AEAD
  DHE-RSA-AES256-GCM-SHA384 TLSv1.2 Kx=DH       Au=RSA  Enc=AESGCM(256) Mac=AEAD
  ECDHE-ECDSA-CHACHA20-POLY1305 TLSv1.2 Kx=ECDH     Au=ECDSA Enc=CHACHA20/POLY1305(256) Mac=AEAD
  ECDHE-RSA-CHACHA20-POLY1305 TLSv1.2 Kx=ECDH     Au=RSA  Enc=CHACHA20/POLY1305(256) Mac=AEAD
  DHE-RSA-CHACHA20-POLY1305 TLSv1.2 Kx=DH       Au=RSA  Enc=CHACHA20/POLY1305(256) Mac=AEAD
  ECDHE-ECDSA-AES128-GCM-SHA256 TLSv1.2 Kx=ECDH     Au=ECDSA Enc=AESGCM(128) Mac=AEAD
  ECDHE-RSA-AES128-GCM-SHA256 TLSv1.2 Kx=ECDH     Au=RSA  Enc=AESGCM(128) Mac=AEAD
  DHE-RSA-AES128-GCM-SHA256 TLSv1.2 Kx=DH       Au=RSA  Enc=AESGCM(128) Mac=AEAD
  ECDHE-ECDSA-AES256-SHA384 TLSv1.2 Kx=ECDH     Au=ECDSA Enc=AES(256)  Mac=SHA384
  ECDHE-RSA-AES256-SHA384 TLSv1.2 Kx=ECDH     Au=RSA  Enc=AES(256)  Mac=SHA384
  DHE-RSA-AES256-SHA256   TLSv1.2 Kx=DH       Au=RSA  Enc=AES(256)  Mac=SHA256
  ECDHE-ECDSA-AES128-SHA256 TLSv1.2 Kx=ECDH     Au=ECDSA Enc=AES(128)  Mac=SHA256
  ECDHE-RSA-AES128-SHA256 TLSv1.2 Kx=ECDH     Au=RSA  Enc=AES(128)  Mac=SHA256
  DHE-RSA-AES128-SHA256   TLSv1.2 Kx=DH       Au=RSA  Enc=AES(128)  Mac=SHA256
  RSA-PSK-AES256-GCM-SHA384 TLSv1.2 Kx=RSAPSK   Au=RSA  Enc=AESGCM(256) Mac=AEAD
  DHE-PSK-AES256-GCM-SHA384 TLSv1.2 Kx=DHEPSK   Au=PSK  Enc=AESGCM(256) Mac=AEAD
  RSA-PSK-CHACHA20-POLY1305 TLSv1.2 Kx=RSAPSK   Au=RSA  Enc=CHACHA20/POLY1305(256) Mac=AEAD
  DHE-PSK-CHACHA20-POLY1305 TLSv1.2 Kx=DHEPSK   Au=PSK  Enc=CHACHA20/POLY1305(256) Mac=AEAD
  ECDHE-PSK-CHACHA20-POLY1305 TLSv1.2 Kx=ECDHEPSK Au=PSK  Enc=CHACHA20/POLY1305(256) Mac=AEAD
  AES256-GCM-SHA384       TLSv1.2 Kx=RSA      Au=RSA  Enc=AESGCM(256) Mac=AEAD
  PSK-AES256-GCM-SHA384   TLSv1.2 Kx=PSK      Au=PSK  Enc=AESGCM(256) Mac=AEAD
  PSK-CHACHA20-POLY1305   TLSv1.2 Kx=PSK      Au=PSK  Enc=CHACHA20/POLY1305(256) Mac=AEAD
  RSA-PSK-AES128-GCM-SHA256 TLSv1.2 Kx=RSAPSK   Au=RSA  Enc=AESGCM(128) Mac=AEAD
  DHE-PSK-AES128-GCM-SHA256 TLSv1.2 Kx=DHEPSK   Au=PSK  Enc=AESGCM(128) Mac=AEAD
  AES128-GCM-SHA256       TLSv1.2 Kx=RSA      Au=RSA  Enc=AESGCM(128) Mac=AEAD
  PSK-AES128-GCM-SHA256   TLSv1.2 Kx=PSK      Au=PSK  Enc=AESGCM(128) Mac=AEAD
  AES256-SHA256           TLSv1.2 Kx=RSA      Au=RSA  Enc=AES(256)  Mac=SHA256
  AES128-SHA256           TLSv1.2 Kx=RSA      Au=RSA  Enc=AES(128)  Mac=SHA256

  # openssl ciphers -v | fgrep TLSv1.3 | sed 's/.*/  &/'
  TLS_AES_256_GCM_SHA384  TLSv1.3 Kx=any      Au=any  Enc=AESGCM(256) Mac=AEAD
  TLS_CHACHA20_POLY1305_SHA256 TLSv1.3 Kx=any      Au=any  Enc=CHACHA20/POLY1305(256) Mac=AEAD
  TLS_AES_128_GCM_SHA256  TLSv1.3 Kx=any      Au=any  Enc=AESGCM(128) Mac=AEAD


===== Von SSH und SCP unterstützte Ciphers anzeigen =====

  # man ssh_config

  # lsb_release -a
  No LSB modules are available.
  Distributor ID: Ubuntu
  Description:    Ubuntu 18.04.5 LTS
  Release:        18.04
  Codename:       bionic

  # ssh -V
  OpenSSH_7.6p1 Ubuntu-4ubuntu0.3, OpenSSL 1.0.2n  7 Dec 2017

  # ssh -Q cipher
  3des-cbc
  aes128-cbc
  aes192-cbc
  aes256-cbc
  rijndael-cbc@lysator.liu.se
  aes128-ctr
  aes192-ctr
  aes256-ctr
  aes128-gcm@openssh.com
  aes256-gcm@openssh.com
  chacha20-poly1305@openssh.com

Beispiel:
  # ssh -c rijndael-cbc@lysator.liu.se,aes256-cbc,aes256-ctr user@host


===== SSH Config =====

Beispiel Konfiguration, die nur Ed25519 erlaubt (nur als Beispiel, wenn überhaupt sollte der Server Cipher usw. einschränken)
<code yaml ~/.ssh/config>
#https://man.openbsd.org/ssh
#https://man.openbsd.org/ssh_config
#ssh -Q help

Host *
    #ssh -Q sig
    CASignatureAlgorithms ssh-ed25519,sk-ssh-ed25519@openssh.com

    #ssh -Q kex
    KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org

    #ssh -Q mac
    MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com,hmac-sha2-512,hmac-sha2-256

    #ssh -Q cipher
    #ssh -Q cipher-auth
    Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes256-cbc,aes256-ctr

    #ssh -Q key
    HostKeyAlgorithms rsa,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,ssh-ed25519,sk-ssh-ed25519@openssh.com

</code>

Alle 3s ein Nullpaket (keep-alive) an den Server senden (hier bis zu 10 Mal)
<code yaml ~/.ssh/config>
Host *
    ClientAliveInterval 10
    ClientAliveCountMax 3
    TCPKeepAlive yes

</code>

Andere Config-Dateien einlesen
<code yaml ~/.ssh/config>
Include config.d/*.conf

</code>

Für den Host example.com einen anderen Standard-Port verwenden (hier: 2222)
<code yaml ~/.ssh/config.d/example-com.conf>
Host example.com
    Port 2222

</code>


===== SSHD Config =====

siehe [[https://man.openbsd.org/sshd_config]]

==== komplette Beispiel-Config ====


=== Unix-like ===

<code yaml /etc/ssh/sshd_config>
Port 22
AddressFamily any
ListenAddress 0.0.0.0
ListenAddress ::

PermitRootLogin prohibit-password

PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys

HostbasedAuthentication no

PasswordAuthentication no
PermitEmptyPasswords no

KbdInteractiveAuthentication no
ChallengeResponseAuthentication no
KerberosAuthentication no
GSSAPIAuthentication no

UsePAM yes

X11Forwarding yes
PrintMotd no
PrintLastLog yes
TCPKeepAlive yes
ClientAliveInterval 10
ClientAliveCountMax 3
VersionAddendum none
Banner none
# Debian only
DebianBanner no

Subsystem sftp internal-sftp -u 0022

Match User mm
    AllowTcpForwarding no
    ChrootDirectory /public/mm
    ForceCommand internal-sftp
    PasswordAuthentication yes
    PermitTTY no
    X11Forwarding no
</code>


=== Windows ===

<code yaml C:/ProgramData/ssh/sshd_config>
Port 22
Port 23
AddressFamily any
ListenAddress 0.0.0.0
ListenAddress ::

PermitRootLogin prohibit-password

PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys

HostbasedAuthentication no

PasswordAuthentication no
PermitEmptyPasswords no

KbdInteractiveAuthentication no
ChallengeResponseAuthentication no
GSSAPIAuthentication no

PrintMotd yes
PrintLastLog yes
TCPKeepAlive yes
ClientAliveInterval 10
ClientAliveCountMax 3
VersionAddendum none
Banner none

Subsystem sftp internal-sftp

#Match Group administrators
#    AuthorizedKeysFile __PROGRAMDATA__/ssh/administrators_authorized_keys

# configure pwsh as default shell (run command in pwsh as admin):
# New-ItemProperty -Path "HKLM:\SOFTWARE\OpenSSH" -Name DefaultShell -Value "$(Get-Command pwsh | Convert-Path)" -PropertyType String -Force
</code>


==== Zugriff ====

Port 22 und 23 (z.B. extern nur 23 erlauben und intern 22 nutzen)

<code yaml /etc/ssh/sshd_config>
Port 22
Port 23
AddressFamily any
ListenAddress 0.0.0.0
ListenAddress ::
</code>


Port 22 (IPv4+IPv6) und 23 (IPv6) (gleiches Beispiel wie oben, falls man im Router eine IPv4 Portweiterleitung über NAT umleiten will)

<code yaml /etc/ssh/sshd_config>
#Port 22
#AddressFamily any
#ListenAddress 0.0.0.0
#ListenAddress ::
ListenAddress 0.0.0.0:22
ListenAddress [::]:22
ListenAddress [::]:23
</code>

=== Allgemein ===
          
<code yaml /etc/ssh/sshd_config>
PermitRootLogin prohibit-password
PubkeyAuthentication yes
PasswordAuthentication no
PermitEmptyPasswords no
ChallengeResponseAuthentication no
UsePAM no
X11Forwarding yes
PrintMotd yes
PrintLastLog yes
</code>

==== SFTP ====

Um die Standard umask zu verwenden einfach '-u 0022' weglassen

<code yaml /etc/ssh/sshd_config>
# internal sftp (recommended)
Subsystem sftp internal-sftp -u 0022

# external sftp

## Debian/Ubuntu
Subsystem sftp /usr/lib/openssh/sftp-server -u 0022

## FreeBSD
Subsystem sftp /usr/libexec/sftp-server -u 0022

</code>


===== Deprecated option =====

  # The ServerKeyBits option only applies to SSH protocol version 1.

<code>
# Aug 13 13:49:12 sshserver01 sshd[3969]: rexec line 30: Deprecated option UsePrivilegeSeparation
# Aug 13 13:49:12 sshserver01 sshd[3969]: rexec line 33: Deprecated option KeyRegenerationInterval
# Aug 13 13:49:12 sshserver01 sshd[3969]: rexec line 36: Deprecated option ServerKeyBits
# Aug 13 13:49:12 sshserver01 sshd[3969]: rexec line 64: Deprecated option RSAAuthentication
# Aug 13 13:49:12 sshserver01 sshd[3969]: rexec line 77: Deprecated option RhostsRSAAuthentication
# Aug 13 13:49:12 sshserver01 sshd[3969]: reprocess config line 64: Deprecated option RSAAuthentication
# Aug 13 13:49:12 sshserver01 sshd[3969]: reprocess config line 77: Deprecated option RhostsRSAAuthentication
</code>


===== Schwäche von Diffie-Hellman für TLS =====

  * [[http://www.pro-linux.de/news/1/22348/neue-angriffe-auf-dh-verschluesselung.html]]
  * [[https://weakdh.org/]]
    * [[https://weakdh.org/sysadmin.html]]
      - Apache HTTP Server (mod_ssl)
      - nginx
      - Microsoft IIS
      - Lighttpd
      - Apache Tomcat
      - Postfix SMTP
      - Sendmail
      - Dovecot
      - HAProxy
      - Amazon Elastic Beanstalk
      - OpenSSH

Generating a Unique DH Group
  > openssl dhparam -out dhparams.pem 4096

ab Apache 2.4.8 und OpenSSL 1.0.2:
  SSLOpenSSLConfCmd DHParameters "/pfad/zum/dhparams.pem"

Lighttpd:
  > vi /etc/lighttpd/lighttpd.conf
  ...
  ssl.dh-file="/pfad/zum/dhparams.pem"
  ...


===== allgemeines =====


==== SSL/TLS ====

**TLS** hat soviele Probleme, man sollte es mind. in der Version __**1.2**__ einsetzen!


==== Verschlüsselungsverfahren ====

  * __**Serpent**__ - ist der sicherste;
  * **Twofish** - ist der zweitsicherste;
  * **Rijndael** - ist weniger sicher als Serpent oder Twofish, es ist seit dem //02. Oktober 2000// der DES-Nachfolger und somit der US-Standard "AES" (Advanced Encryption Standard);


==== Blockverschlüsselung ====

  * **EBC** - jeder Block wird mit dem selben Schlüssel verschlüsselt (das ist nicht sehr schlau)
  * __**CBC**__ - jeder Block wird mit einem eigenen Schlüssel verschlüsselt


===== OpenSSH ab Version 6.6 (ab Ubuntu 14.04 LTS) =====


==== elliptische Kurven ====

Zur Zeit kann SSH nur den Ellyptischen-Kurven-Algorithmus ED25519, der ED448 und E-521 werden sicher später noch kommen.\\ 
Die DSA-Schlüssel sind alle NSA-optimiert und somit als unsicher anzusehen.
Auch von den Schlüsseln mit elliptischen Kurven wird vermutet, dass sie NSA-optimiert sind.
RSA mit großer Schlüssellänge ist z.Z. die sicherste Alternative.

der ED25519-Schlüssel hat eine __feste Länge von 256 Bit__, hier wird die Option ''-b'' __ignoriert__:
  > ssh-keygen -t ed25519 -a 1024

aus einem privaten Schlüssel einen öffentlichen generieren:
  > ssh-keygen -y -f ~/.ssh/id_ed25519 > ~/.ssh/id_ed25519.pub

Die Option **''-a''** beschreibt, mit wieviel Rotationen die Passphrase verschlüsselt wird.\\
Je größer diese Anzahl ist, desto stärker ist die Passphrase gegen Brut-Force-Angriffe gesichert aber desto langsammer ist auch der Verbindungsaufbau.\\
Die Zeit, die zum generieren des Schlüssels benötigt wird, die Zeit fällt auch bei einem Verbindungsaufbau mit dem generierten Schlüssel an.\\
Also wenn das generieren eines Schlüssels mit 65536 Runden ca. 10 Minuten dauert, dann wird der Vebindungsaufbau mit diesem Schlüssel von diesem Rechner (Intel Core i7-2620M 2.70GHz) aus, auch ca. 10 Minuten benötigen!

In soeinem Fall sollte man die Anzahl der Runden auf einen Wert reduzieren, bei dem die Zeit zum generieren bzw. für den Verbindungsaufbau, in einem verträglichen Zeitrahmen liegt.

Auf einem Rechner mit einer "Intel Core i7-2620M 2.70GHz"-CPU, dauert der Login mit einem ED25519-Schlüssel mit 1024 Runden, ca. 10 Sekunden und mit 65536 Runden ca. 10 Minuten.

Die DSA-Schlüssel sind alle NSA-optimiert und somit als unsicher anzusehen.
Auch von den Schlüsseln mit elliptischen Kurven wird vermutet, dass sie NSA-optimiert sind.
Weiterhin gilt die Einschränkung, dass bei den Algorithmen, die auf elliptischen Kurven basieren, die Schlüssellänge nicht konfigurierbar ist.
Auch wenn von RSA nicht vermutet wird, das es NSA-optimiert ist, so arbeitet RSA doch deterministisch und ist deshalb unter Umständen für bestimmte Angriffe anfällig. In der Praxis wird RSA daher mit dem "Optimal Asymmetric Encryption Padding" kombiniert.
Daraus ergibt sich, dass ein RSA-Algorithmus, der Padding verwendet, grundsätzlich als sicherer einzustufen ist als alle anderen genannten Algorithmen.

Ein 160 Bit langer Schüssel, der auf elliptischen Kurven basieren (ECDH), gilt als ähnlich sicher wie ein 1024 Bit langer RSA-Schlüssel (RSA/DH):
  160 Bit ECDH - 1024 Bit RSA/DH
  224 Bit ECDH - 2048 Bit RSA/DH
  256 Bit ECDH - 3072 Bit RSA/DH
  384 Bit ECDH - 7680 Bit RSA/DH
ECDH-Schlüssel eignet sich daher besonders dann, wenn die Speicher- oder Rechenkapazität begrenzt ist, z. B. in Smartcards oder anderen eingebetteten Systemen.


===== OpenSSH bis Version 6.5 (bis Ubuntu 12.04 LTS) =====

einen eigenen RSA-Schlüssel generieren:
  > ssh-keygen -t rsa -b 8192

aus einem privaten Schlüssel einen öffentlichen generieren:
  > ssh-keygen -y -f ~/.ssh/id_rsa > ~/.ssh/id_rsa.pub


==== Verbindungen mit TTL ====

so werden alle SSH-Verbindungen nach 300 Sekunden (5 Minuten) "nichts tun" automatisch getrennt:
  > vi /etc/ssh/sshd_config
<file>
ClientAliveInterval 300
ClientAliveCountMax 0
</file>

so bleiben alle SSH-Verbindungen solange offen, wie der Rechner eingeschaltet ist:
  > vi /etc/ssh/sshd_config
<file>
#ClientAliveInterval 300
#ClientAliveCountMax 0
</file>

Nicht vergessen, nach einer Änderung an dieser Konfigurationsdatei den SSH-Dienst neu zu starten.


==== ChRoot mit SSH/BASH ====

Benutzer anlegen:
  # useradd -m -c "BESCHREIBUNG" fritz
  # mkdir -p /home/fritz/arbeit

SSH-Schlüssel anlegen:
  # su - fritz
  # ssh-keygen -t rsa -b 4096
  # exit

Die Rechte für die ChRoot-Funktion passend setzen:
  # chown -R 0:0 /home/fritz
  # chown -R fritz:fritz /home/fritz/.ssh
  # chown -R fritz:fritz /home/fritz/.bash*
  # chown -R fritz:fritz /home/fritz/arbeit

Binärdateien in die ChRoot-Umgebung kopieren:
  # tar cvzf bash.tgz /bin/ /lib/ /lib64/ /usr/bin/ ; tar xzf bash.tgz -C /home/fritz/

das "/dev" in der ChRoot-Umgebung anlegen:
  # mknod dev/null c 1 3
  # mknod dev/zero c 1 5
  # chmod 0666 dev/{null,zero}


=== /etc/ssh/sshd_config ===

ganz unten an die Datei anhängen:
  ...
  Match user fritz
          ChrootDirectory %h
          X11Forwarding no
          AllowTcpForwarding no

SSHD neu starten:
  > /etc/init.d/ssh restart


==== ChRoot mit SCP/SFTP ====

Benutzer anlegen:
  # useradd -m -c "BESCHREIBUNG" -g sftpgruppe fritz
  # mkdir -p /home/fritz/arbeit
  # chown -R fritz:0 /home/fritz
  # chown 0:0 /home/fritz
  # chown -R fritz:sftpgruppe /home/fritz/arbeit
  # chmod 0775 /home/fritz/arbeit

Benutzer anlegen:
  # chown -R fritz /home/fritz
  # userdel -r fritz


=== /etc/ssh/sshd_config ===

ganz unten an die Konfigurationsdatei anhängen:
  Match user fritz
          ChrootDirectory %h
          X11Forwarding no
          AllowTcpForwarding no
          ForceCommand internal-sftp -l VERBOSE


==== unerwünschte Wartezeit (wegen IPv6) vor dem Login ====

  * [[http://ubuntuforums.org/showthread.php?t=1865873]]

Die neuen SSH-Versionen versuchen erst per IPv6 eine Verbindung aufzubauen,
erst wenn das nicht geht, versuchen sie es per IPv4.

Mit dieser Option verwendet SSH-Client nur noch IPv4:
  # vi /etc/ssh/ssh_config
  ...
  AddressFamily inet
  ...

Damit der SSHD auch nur mit IPv4 arbeitet:
  # vi /etc/ssh/sshd_config
  ...
  AddressFamily inet
  ...


==== OpenSSH 5.5p1 aus den Quellen bauen ====

Seit der Version 5.4 kann open SSH mit seinem sftp-Server auch die ''umask'' setzen, allerdings hat die Version 5.4 wohl ein paar Sicherheitsprobleme,
woraufhin recht schnell die Version 5.5 veröffentlicht wurde.

Hier zeige ich Beispielhaft, wie man sich auf einem Ubuntu 9.04 ein aktuelles OpenSSH 5.5p1 (openssh-5.5p1.tar.gz) aus den Quellen selber baut.

Agent admitted failure to sign using the key.
  * [[http://mein.homelinux.com/blog/177-agent-admitted-failure-to-sign-using-the-key.html]]


=== Problem ===

Es ist kein automatischer Login möglich, obwohl alle relevanten Verzeichniss- und Dateirechte richtig gesetzt sind:

  fratz@client:~$ ssh fritz@server
  Agent admitted failure to sign using the key.
  Password:


=== Lösung ===

Schlüssel bei Seite legen:
  fratz@client:~$ mv .ssh/id_rsa .ssh/id_rsa.bak
  fratz@client:~$ mv .ssh/id_rsa.pub .ssh/id_rsa.pub.bak

einmal kurz mit Passwort einloggen:
  fratz@client:~$ ssh fritz@server
  Password:
  fritz@server:~$
  fritz@server:~$ exit
  logout
  Connection to server closed.

Schlüssel wieder hervor holen:
  fratz@client:~$ mv .ssh/id_rsa.bak .ssh/id_rsa
  fratz@client:~$ mv .ssh/id_rsa.pub.bak .ssh/id_rsa.pub

jetzt geht der passwortlose Login wieder:
  fratz@client:~$ ssh fritz@server
  fritz@server:~$


==== konvertieren zwischen OpenSSH, SSH2/RFC4716 und RSA/PAM ====

Hier einmal beispielhaft alle Konvertierungsvarianten, die mir eingefallen sind bzw. die bei mir funktioniert haben.

  * ''-e'' -> export ''SSH2/RFC4716'' (ist der Standard)
  * ''-i'' -> import ''SSH2/RFC4716'' (ist der Standard)
  * ''-m'' -> Formate ''RFC4716'' (für SSH2)
  * ''-m'' -> Formate ''PAM'' (für RSA)

''OPENSSH PRIVATE KEY'' + ''OPENSSH PUBLIC KEY'' - generieren:
  > ssh-keygen -t rsa -b 4096
  Enter file in which to save the key (/home/fritz/.ssh/id_rsa):

''OPENSSH PRIVATE KEY'' + ''OPENSSH PUBLIC KEY'' - generieren:
  > ssh-keygen -t rsa -m RFC4716 -b 4096
  Enter file in which to save the key (/home/fritz/.ssh/id_rsa): /home/fritz/.ssh/id_rsa_rfc4716

''RSA PRIVATE KEY'' + ''OPENSSH PUBLIC KEY'' - generieren:
  > ssh-keygen -t rsa -m PEM -b 4096
  Enter file in which to save the key (/home/fritz/.ssh/id_rsa): /home/fritz/.ssh/id_rsa_pem

''OPENSSH KEY'' in ''SSH2 PUBLIC KEY'' konvertieren:
  > ssh-keygen -e -f .ssh/id_rsa                              > .ssh/SSH2_PUBLIC_KEY.pub
  > ssh-keygen -e -f .ssh/id_rsa.pub                          > .ssh/SSH2_PUBLIC_KEY.pub

''OPENSSH KEY'' in ''SSH2 PUBLIC KEY'' konvertieren:
  > ssh-keygen -e -m RFC4716 -f .ssh/id_rsa                   > .ssh/SSH2_PUBLIC_KEY_-_RFC4716.pub
  > ssh-keygen -e -m RFC4716 -f .ssh/id_rsa.pub               > .ssh/SSH2_PUBLIC_KEY_-_RFC4716.pub

''OPENSSH KEY'' in ''RSA PUBLIC KEY'' konvertieren:
  > ssh-keygen -e -m PEM -f .ssh/id_rsa                       > .ssh/RSA_PUBLIC_KEY_-_PEM.pub
  > ssh-keygen -e -m PEM -f .ssh/id_rsa.pub                   > .ssh/RSA_PUBLIC_KEY_-_PEM.pub

''SSH2 KEY'' in ''OPENSSH PUBLIC KEY'' konvertieren:
  > ssh-keygen -i -f .ssh/SSH2_PUBLIC_KEY_-_RFC4716.pub       > .ssh/id_rsa.pub

''SSH2 KEY'' in ''OPENSSH PUBLIC KEY'' konvertieren:
  > ssh-keygen -i -m RFC4716 -f SSH2_PUBLIC_KEY_-_RFC4716.pub > .ssh/id_rsa.pub

''RSA KEY'' in ''OPENSSH PUBLIC KEY'' konvertieren:
  > ssh-keygen -i -m PEM -f SSH2_PUBLIC_KEY_-_RFC4716.pub     > .ssh/id_rsa.pub


==== automatische Passwortübergabe mit sshpass ====

Wenn man auf dem Zielsystem keinen eigenen Schlüssel liegen hat
oder wegen der Verzeichnisrechte eine Pub-Key-Auth nicht funktionieren würde,
dann kann man das einloggen mit //sshpass// trotzdem automatisieren:
  > sshpass -p geheim ssh 192.168.0.100 'df -h'

installation mit FreeBSD 13:
  > pkg install security/sshpass


==== Bug ====

  * [[http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=422327%E2%90%A3]]

Wenn man //IPv6// abschaltet (sysctl.conf per net.ipv6.conf.all.disable_ipv6=1), funktioniert //X11Forwarding// auch nicht mehr.


==== Vorbereitungen ====

Als erstes alle Pakete installieren die zum bauen gebraucht werden:
  # aptitude -y install build-essential install zlib1g-dev pam-dev libwrap0-dev libcurl4-openssl-dev libpam-dev wget

hier ist die Baustelle:
  # cd /usr/src/

jetzt saugen wir uns die Quellen (siehe [[http://openssh.org/de/portable.html]]):
  # wget ftp://ftp-stud.fht-esslingen.de/pub/OpenBSD/OpenSSH/portable/openssh-5.5p1.tar.gz

Quellen auspacken:
  # tar xzf openssh-5.5p1.tar.gz -C /usr/src/

ins Quellverzeichnis wechseln:
  # cd openssh-5.5p1


==== bauen ====
Dann die Optionen lesen, um die richtigen auszuwählen:
  # ./configure --help

Jetzt die gewünschten Optionen setzen:
  # ./configure --prefix=/opt/openssh_5.5p1 --with-tcp-wrappers --with-ssl-engine --with-pam --with-mantype=man --with-privsep-path=/var/run/sshd

Am Ende sollte dann soetwas in der Art stehen:
  OpenSSH has been configured with the following options:
                       User binaries: /opt/openssh_5.5p1/bin
                     System binaries: /opt/openssh_5.5p1/sbin
                 Configuration files: /opt/openssh_5.5p1/etc
                     Askpass program: /opt/openssh_5.5p1/libexec/ssh-askpass
                        Manual pages: /opt/openssh_5.5p1/share/man/manX
                            PID file: /var/run
    Privilege separation chroot path: /var/run/sshd
              sshd default user PATH: /usr/bin:/bin:/usr/sbin:/sbin:/opt/openssh_5.5p1/bin
                      Manpage format: man
                         PAM support: yes
                     OSF SIA support: no
                   KerberosV support: no
                     SELinux support: no
                   Smartcard support: 
                       S/KEY support: no
                TCP Wrappers support: yes
                MD5 password support: no
                     libedit support: no
    Solaris process contract support: no
         IP address in $DISPLAY hack: no
             Translate v4 in v6 hack: yes
                    BSD Auth support: no
                Random number source: OpenSSL internal ONLY
  
                Host: x86_64-unknown-linux-gnu
            Compiler: gcc
      Compiler flags: -g -O2 -Wall -Wpointer-arith -Wuninitialized -Wsign-compare -Wno-pointer-sign -Wformat-security -fno-strict-aliasing -fno-builtin-memset -fstack-protector-all -std=gnu99 
  Preprocessor flags: 
        Linker flags:  -fstack-protector-all
           Libraries: -lcrypto -ldl -lutil -lz -lnsl  -lcrypt -lresolv
           +for sshd:  -lwrap -lpam

Sicherheitshalber erstmal sauber machen:
  # make clean

Wenn alles ohne Fehler durchgelaufen ist, geht es mit dem eigentlichen //bauen// weiter.
Sonst muss natürlich erst der Fehler behoben werden, meist fehlt nur ein ''*-dev''-Paket, welches man mit aptitude schnell nachinstallieren kann.
  # make

Ist das auch ohne Fehler durchgelaufen, dann kann man jetzt installieren:
  # make install


==== Anpassungen im System ====

Zum Schluss muss nur noch das //Start-/Stop-Script// angepasst werden:

  # vi /etc/init.d/ssh

In der alten Datei gibt es unter anderem diese Zeilen:
  set -e
  
  # /etc/init.d/ssh: start and stop the OpenBSD "secure shell(tm)" daemon
  
  test -x /usr/sbin/sshd || exit 0
  ( /usr/sbin/sshd -\? 2>&1 | grep -q OpenSSH ) 2>/dev/null || exit 0
  
  umask 022

Das ändern wir in:
  set -e
  
  #SSHD="/usr/sbin/sshd"
  SSHD="/opt/openssh_5.5p1/sbin/sshd"
  
  # /etc/init.d/ssh: start and stop the OpenBSD "secure shell(tm)" daemon
  
  test -x ${SSHD} || exit 0
  ( ${SSHD} -\? 2>&1 | grep -q OpenSSH ) 2>/dev/null || exit 0
  
  export PATH="/opt/openssh_5.5p1/bin:$PATH"
  
  umask 022

Im Rest der Datei muss jetzt nur noch
  /usr/sbin/sshd

gegen
  ${SSHD}

ausgetauscht werden.

Jetzt kann man ganz einfach zwischen der alten Version un der neuen Version umschalten.


neue Version (selbst gebaute Version) aktivieren:
  #SSHD="/usr/sbin/sshd"
  SSHD="/opt/openssh_5.5p1/sbin/sshd"

alte Version (Betriebssystem-Version) aktivieren:
  SSHD="/usr/sbin/sshd"
  #SSHD="/opt/openssh_5.5p1/sbin/sshd"