Hope This Helps

Ich habe hier einen kleinen Server am laufen der mir als Gateway dient. Dieser läuft ohne GUI und ein tcpdump ist nicht so schön zu lesen wie der Output von Wireshark. Da ich aber keine GUI installieren wollte der Weg über remote Wireshark

Wenn noch nicht passiert installieren wir erstmal Wireshark

sudo apt install wireshark

jetzt erstellen wir eine PIPE auf der Kiste auf der Wireshark läuft

mkfifo /tmp/remote-wire

dann können wir auch schon Wireshark starten

wireshark -k -i /tmp/remote-wire
# Erklärung Parameter
# -k starte sofort das capturing
# -i definiert das interface hier ist es die PIPE

jetzt noch eine ssh Verbindung aufbauen und alles in die PIPE leiten

ssh root@GATEWAY-IP "tcpdump -s 0 -U -n -w - -i ens9 not port 22" > /tmp/remote-wire

ens9 ist bei mir die Netzwerkkarte ins Internet.

Auf dem Remote System muss natürlich tcpdump installiert sein.

apt install tcpdump

In meinem Beispiel muss root der ssh Zugang erlaubt werden. Das kann in der Datei /etc/ssh/sshd_config erledigt werden. Dort den Parameter PermitRootLogin auf yes setzen.

PermitRootLogin yes

Bei dem Versuch ein git push zu machen erfolgt eine Abfrage nach Passwort & User. Der Hash des SSH Keys war aber sauber im Server registriert. Mit dem Befehl git remote -v habe ich mir erstmal die Quellen angesehen. Der initiale pull wurde scheinbar mit https ausgeführt, somit wird der ssh key gar nicht angefragt.

git remote -v
origin https://[URL]/[GRUPPE]/[PROJEKT].git (fetch)
origin https://[URL]/[GRUPPE]/[PROJEKT].git (push)

Nachdem ich die Quelle auf ssh konfiguriert habe lief auch alles so wie erwartet.

git remote set-url origin git@[FQDN]:[GRUPPE]/[PROJEKT].git

Ein erneutes Abfragen der Konfiguration

git remote -v
origin	git@[FQDN]:[GRUPPE]/[PROJEKT].git (fetch)
origin	git@[FQDN]:[GRUPPE]/[PROJEKT].git (push)

Da ich es einfacher finde für die Archivierung von Webcam Bildern Videos zu verwenden habe ich diese Script geschrieben. Die Webcam erstellt ein Bild wenn Sie Bewegung wahrnimmt. Diese werden von diesem Skript zu einen einzelnen Video vereint.
Ihr müsst nur die Variablen euren Gegebenheiten anpassen.
Variablen :

{FTP-USER} = der FTP Benutzer
{FTP-GROUP} = die FTP Gruppe
{QUELL-PFAD} = quelle der Snapshots
{ZIEL-PFAD} = wo soll das Video abgelegt werden ?

Script :

#!/bin/bash
#
# Konvertiert Einzelbilder zu Video mit ffmpeg
_src_folder={QUELL-PFAD}
_src_file_format=jpg
_tar_folder={ZIEL-PFAD}
_tar_file_format=mpg
_tar_file_name="video_$(date +%Y-%m-%d_%R)"
_temp_folder=$(mktemp -d)
_length=5
_cnt_files_in_src=$(ls -l ${_src_folder}/*.${_src_file_format} 2>/dev/null | wc -l)
_ftp_user={FTP-USER}
_ftp_group={FTP-GROUP}
_bin_ffmpeg=$(which ffmpeg)
_bin_chown=$(which chown)
_bin_rm=$(which rm)
_bin_find=$(which find)
# Bilder nach konvertieren löschen ?
DELFILESAFTERVIDEO=TRUE # TRUE OR FALSE
# setze symlinks in tempfolder
cnt=1
if [ ${_cnt_files_in_src} != "0" ]; then
        if [[ -d  "${_temp_folder}" && -d "${_src_folder}" ]]; then
                for i in ${_src_folder}/*.${_src_file_format};
                do
                        ln -s "${i}" "${_temp_folder}/$(printf %0${_length}d $cnt).jpg"
                        ((cnt++))
                done
                ${_bin_ffmpeg} -f image2 -i "${_temp_folder}/%0${_length}d.jpg" -r 25 -vcodec libx264 "${_tar_folder}/${_tar_file_name}.${_tar_file_format}" > /dev/null 2>&1
                ${_bin_rm} -rf "${_temp_folder}"
                ${_bin_chown} ${_ftp_user}:${_ftp_group} "${_tar_folder}/${_tar_file_name}.${_tar_file_format}"
                # löscht alle vorhanden bilder
                if [ ${DELFILESAFTERVIDEO} == "TRUE" ]; then
                ${_bin_find} ${_src_folder}/ -name "*.${_src_file_format}" -exec ${_bin_rm} {} \;
                fi
        else
                echo "ERROR : TEMP FOLDER OR SOURCE FOLDER DO NOT EXISTS"
                exit 99
        fi
else
                echo "found no files in source exit"
                exit 99
fi

Kleines lokales Plugin für check_mk um die HAProxy Backends zu monitoren.

das Skript muss unter /usr/lib/check_mk_agent/local angelegt werden.

touch /usr/lib/check_mk_agent/local/haproxy-local.sh

Dort dann den nachfolgenden Code reinkopieren und Konfiguration anpassen.

#!/bin/bash
#
# checks haproxy
#

_awk_bin=$(which awk)
_status_url="http://localhost:9090/haproxy/"
_server_name="ha-cap-"
a=0

# $(curl -s ${_status_url}\;csv | grep "^${_server_name}" | grep -vE "(FRONTEND|BACKEND)")

for line in $(curl -s ${_status_url}\;csv | grep "^${_server_name}" | grep -vE "(FRONTEND|BACKEND)"); do
        _name=$(echo $line | ${_awk_bin} -F',' '{ print $1; }' )
        _host=$(echo $line | ${_awk_bin} -F',' '{ print $2; }' )
        _stat=$(echo $line | ${_awk_bin} -F',' '{ print $18; }')
        STATUSTXT="${_name}  ${_host}  ${_stat}"
        if [ ${_stat} == "UP" ]; then
                _check_response="0"
        else
                _check_response="2"
        fi
        if [ ${a} -lt 10 ]; then
                echo "${_check_response} BEHIND-HAPROXY-0${a} - ${STATUSTXT}"
        else
                echo "${_check_response} BEHIND-HAPROXY-${a} - ${STATUSTXT}"
        fi
        a=$((a+1))
done

Ergebnis sieht dann so aus

Natürlich muss auch der haproxy so konfiguriert sein das er die Statusseite ausliefert. Hier Auszug aus der haproxy.cfg

listen status
    bind *:9090
    mode http
    stats enable
    stats uri /haproxy
    acl localhost  src  127.0.0.1
    acl stats      path_beg  /haproxy
    http-request allow if stats localhost
    http-request deny  if stats !localhost

Es kommt immer wieder vor das die Webserver unter Volllast geraten da jemand unsere API exzessiv anfragt. Da hier alle anderen Anfragen auch mit betroffen sind ist hier ein möglicher Weg einen Apache dagegen abzusichern. In meinem Fall handelt es sich um ein Debian 9 bei anderen Linux Derivaten sollte es ähnlich funktionieren.

Distributor ID:	Debian
Description:	Debian GNU/Linux 9.5 (stretch)
Release:	9.5
Codename:	stretch

Erstmal installieren wir die benötigten Packete

apt install libapache2-mod-qos fail2ban

Dann machen wir die Konfiguration für mod_qos

vi /etc/apache2/conf-available/mod_qos.conf

dort tragen wir erstmal eine Grundkonfiguration ein

## QoS Settings
<IfModule mod_qos.c>
    # Gleichzeitige Verbindungen von 100000 IP Adressen zulassen 
    QS_ClientEntries 100000
    # maximal 20 Verbindungen pro IP Adresse
    QS_SrvMaxConnPerIP 20
    # maximale Anzahl der aktiven TCP Verbindungen hier 256
    MaxClients              256
    # QS_SrvMaxConnClose <Nummer> [%] definiert die maximale Anzahl der gleichzeitigen TCP-Verbindungen,
    # bis der Server Keep-Alive für diesen Server deaktiviert (die Verbindung wird nach jeder Anforderung geschlossen. 
    # Sie können die Anzahl der Verbindungen als Prozentsatz von MaxClients angeben, wenn Sie das Suffix hinzufügen '%' auf den angegebenen Wert.
    QS_SrvMaxConnClose      70%
    # minimum request/response speed (https://de.wikipedia.org/wiki/Slowloris Schutz):
    QS_SrvMinDataRate       150 1200
    # QS_SrvMinDataRate <bytes pro seconds> [<max bytes pro second> [<connections>]], definiert den minimalen Upload / Download-Durchsatz
    # QS_SrvMaxConnExcludeIP <addr>
    # QS_SrvMaxConnExcludeIP 192.168.x.xxx
    #
    # Quelle : https://www.mankier.com/1/mod_qos
</IfModule>

Jetzt geben wir noch die Statusseite für qos frei damit wir auch sehen was hier so passiert.

<Location /qos>
   SetHandler qos-viewer
   Require ip [Eigene IP Adresse oder IP Range (CIDR)]
   # z.B. Require ip 127.0.0.1
</Location>

Jetzt aktivieren wir noch das Modul und die Konfiguration

a2enmod qos
a2enconf mod_qos

dann der obligatorische Neustart des Apaches

systemctl restart apache2

nun kann man den ersten Test durchführen, von einem anderen Rechner die IP Adresse des Servers über das Apache Benchmark Tool einfach mal anfragen mit diesen Werten

ab -n 1500 -c 100 http://[IP des Webservers]/index.html

im Errorlog des Apaches sollten jetzt solche Meldungen erscheinen

[xxx] [:error] [xxx] mod_qos(034): access denied, QS_SrvMinDataRate rule (in): min=354, this connection=26, c=192.168.x.xxx
[xxx] [:error] [xxx] mod_qos(031): access denied, QS_SrvMaxConnPerIP rule: max=50, concurrent connections=51, c=192.168.x.xxx

Dann machen wir mit fail2ban weiter

vi /etc/fail2ban/jail.d/http-requests.conf

dort fügen wir diesen Inhalt ein

[http-requests]
enabled = true
port = http,https
filter = http-requests
logpath = /var/log/apache2/access.log
# maxretry bedeutet wieviele GET / POST wir im Log finden bevor wir die IP sperren
maxretry = 30
# findtime ist die Zeitperiode in der wir GET/POST zählen (10 Sekunden)
findtime = 10
# Wielange wird die IP gebannt in Sekunden (600 Sekunden = 10 Minuten)
bantime = 600
action = iptables[name=HTTP, port=http, protocol=tcp]

den Filter dazu erstellen

vi /etc/fail2ban/filter.d/http-requests.conf

und dort diesen Inhalt rein

# Fail2Ban configuration file
# http-requests.conf
#
[Definition]
# failregex = es wird gegen GET/POST im Logfile gematched
failregex = ^<HOST> -.*"(GET|POST).*
# ignoreregex = 
ignoreregex =

ein neustart von fail2ban aktiviert die Config

systemctl restart fail2ban

Jetzt kann wieder mit dem Apache Benchmark Tool getestet werden, bevor wir allerdings das Benchmark Tool von einem anderen Rechner aus starten öffnen wir lokal das Logfile von fail2ban damit wir sehen was passiert.

tail -f /var/log/fail2ban.log

jetzt den Benchmark starten wie oben angegeben. Im Log sollten jetzt solche Meldungen erscheinen

2018-07-20 00:25:27,998 fail2ban.filter         [6203]: INFO    [http-requests] Found 192.168.x.xxx
2018-07-20 00:25:27,998 fail2ban.filter         [6203]: INFO    [http-requests] Found 192.168.x.xxx
2018-07-20 00:25:28,096 fail2ban.actions        [6203]: NOTICE  [http-requests] 192.168.x.xxx already banned
2018-07-20 00:25:29,098 fail2ban.actions        [6203]: NOTICE  [http-requests] 192.168.x.xxx already banned

In fail2ban kann man sich jetzt den Status anzeigen lassen

root@ddev-01: fail2ban-client status http-requests
Status for the jail: http-requests
|- Filter
|  |- Currently failed:	1
|  |- Total failed:	1629
|  `- File list:	/var/log/apache2/access.log
`- Actions
   |- Currently banned:	1
   |- Total banned:	2
   `- Banned IP list:	192.168.x.xxx

möchte man die IP wieder entsperren genügt ein

fail2ban-client set http-requests unbanip 192.168.x.xxx

wenn eine bestimmte IP oder eine IP Range freigegeben werden muss ist das in der jail.conf zu erledigen

vi /etc/fail2ban/jail.conf

dort nach ignoreip = suchen und die eigene IP hinzufügen

Quellen :
http://mod-qos.sourceforge.net/#variables
https://de.wikipedia.org/wiki/Slowloris
https://www.fail2ban.org/wiki/index.php/Main_Page
https://sourceforge.net/p/mod-qos/discussion/
http://mod-qos.sourceforge.net/#statusviewer
http://mod-qos.sourceforge.net/glossary.html
http://mod-qos.sourceforge.net/dos.html

Problem : In manchen Fällen bekommt man Dateien von Kunden geschickt die irgendein unbekanntes encoding enthalten. mit recode und iconv kam in meinem Fall auch nur Mist raus.

Lösung :
Die Datei mit vim öffnen und das encoding auf utf8 festnageln.

set fenc=utf8

dann können die unbekannten Zeichen ersetzt werden. Hier ein paar Beispiele.

:%s#\%x86#Ü#g
:%s#\%x9f#ü#g
:%s#\%x8a#ä#g
:%s#\%x9a#ö#g
:%s#§#ß#g