Security - WhatWeb Open-Source-Webscanner: Webanwendungen analysieren identifizieren

WhatWeb ist ein Open-Source-Webscanner, der speziell dafür entwickelt wurde Webanwendungen zu analysieren und zu identifizieren. Ein ähnliches Vorgehen habe ich bereits unter Security - Nmap Netzwerkscanner und Kali Linux und Hacking - Netzwerkscanner, nmap, Reverse Shell und Password Cracking mit hashcat beschrieben.

Da eine Installation per Windows nicht direkt möglich ist, empfehle ich eine Installation per Windows-Subsystem für Linux (WSL) oder über Distrobox.

WhatWeb erkennt, welche Technologien eine Website nutzt z. B. Content-Management-Systeme (CMS) wie WordPress oder Joomla, Webserver (Apache, Nginx), Programmiersprachen (PHP, Python), Frameworks (React, Angular) und vieles mehr.

Durch Skripte und Automatisierung kann WhatWeb große Mengen an Websites scannen, um z. B. veraltete Software oder unsichere Konfigurationen zu finden.

Installation

git clone https://github.com/urbanadventurer/WhatWeb.git

Da WhatWeb in Ruby geschrieben ist, müssen jetzt noch die Abhängigkeiten installiert werden:
sudo apt install -y ruby ruby-dev ruby-bundler build-essential make libssl-dev zlib1g-dev libyaml-dev

Jetzt in den Ordner "./WhatWeb" wechseln und den Webscanner installieren:
sudo make install

Metadaten anzeigen in in eine XML-Datei schreiben
whatweb shemel.de --log-xml=results.xml

User-Agent hinzufügen
whatweb --user-agent "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36" https://shemel.de

DNS - HTTPS Resource Record verwenden (Backup Server, Port-Signalisierung)

In meinem letzten Beitrag zum Thema DNS habe ich gezeigt, wie man die Eigene Domain auf eine andere IP mit Hilfe von Bind umleiten kann. Mit Hilfe des Domain Name System (DNS) wird die Namensauflösung im Internet durchgeführt. Diese Einträge werden als Resource Records (RR) bezeichnet. Die A- und die AAAA-Records sind zum Beispiel die Einträge für IPv4-/IPv6-Adressen der Server. Der DNS-Record „HTTPS“ kann als weiteres Steuerelement verwendet werden.

Der HTTPS-Record ist eine Variante des SVCB-Records und wurde speziell für die Verwendung mit dem HTTPS-Protokoll entwickelt. Um eine HTTPS-Verbindung aufzubauen, muss ein Client in der Regel zuerst eine HTTP-Verbindung aufbauen, dies erzeugt Latenz. Der DNS-Eintrag vom Typ HTTPS kann diese Latenz zu verringern.

Aufbau des HTTPS Resource Records

example.com. 300 IN HTTPS 10 backup01.example.com. alpn="h3,h2" port=8443

• example.com. => Name - Domainname der Website
• 300 => TTL - Time to Live: maximale Caching-Zeit
• IN => Klasse Internet (konstanter Wert)
• HTTPS => Typ des Resource Records
• 10 => SvcPriority - Priorität des Eintrags (kleiner Wert = höhere Priorität)
• backup01.example.com. => TargetName - Hostname des Webservers. Der Wert „.“ bedeutet, dass der Hostname dem Domainnamen der Website entspricht
• alpn="h3,h2" port=8443 => SvcParams - Liste von definierten Parametern nach dem Schema „key=value“.

Quelle: https://de.wikipedia.org/wiki/HTTPS_Resource_Record

Die Abfrage des HTTPS-Record ist mit den Tools dig oder kdig möglich. Nicht aber mit nslookup!
dig google.com https

Installation mit Hilfe von sudo pacman -S dnsutils

Beispiele für die Nutzung des HTTPS-Record

Backup Server
example.com. 300 IN HTTPS 10 backup01.example.com.
example.com. 300 IN HTTPS 20 backup02.example.net.
example.com. 300 IN HTTPS 30 backup03.example.de.

Port-Signalisierung
app1.example.de IN HTTPS 1 . port=8443
Hier wird die Applikation nicht über den üblichen Port 443 ausgeliefert. Die Eingabe vom Port https://app1.example.de:8443/login in der URL kann entfallen.

Beispiel Abfragen von Records mit Hilfe von nslookup

Nslookup gefolgt vom Domänennamen zeigt den „A-Record“ (IP-Adresse) der Domain an.

(deck@steamdeck ~)$ nslookup shemel.de
Server:         127.0.0.53
Address:        127.0.0.53#53

Non-authoritative answer:
Name:   shemel.de
Address: 178.254.0.77


Abfrage des NS-Eintrags einer Domain
Der NS-Eintrag zeigt alle Nameserver einer Domain an.

(deck@steamdeck ~)$ nslookup -type=ns shemel.de
Server:         127.0.0.53
Address:        127.0.0.53#53

Non-authoritative answer:
shemel.de       nameserver = ns01.1blu.de.
shemel.de       nameserver = ns02.1blu.de.


Abfrage des MX-Eintrags
Der MX-Eintrag (Mail-Exchange-Server) einer Domain. Siehe auch Mailserver - Zugriff auf TCP Port 25 (smtp) mit telnet testen.

(deck@steamdeck ~)$ nslookup -type=mx microsoft.com
Server:         127.0.0.53
Address:        127.0.0.53#53

Non-authoritative answer:
microsoft.com   mail exchanger = 10 microsoft-com.mail.protection.outlook.com

Security - Click-Jacking-Angriffe vermeiden mittels CSP-Header (Content Security Policy)

Die Content-Security-Policy (CSP) entstand ursprünglich unter dem Namen "Content-Restriction", der Grund dafür war die damals zunehmenden Sicherheitslücken bei Internetskripten wie z.B. durch Cross-Site-Scripting (XSS). In diesem Artikel gehe ich auf die Implementierung des CSP-Frame-Vorfahren ein.

Die Richtlinie "frame-ancestors", legt fest welche Domains die Seite in Frames und iFrames einbauen bzw. einbetten dürfen und funktioniert mit allen aktuellen Browserversionen außer dem Internet Explorer IE. Siehe hierzu auch https://caniuse.com/?search=frame-ancestors oder https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors .

• "frame-ancestors 'none';" ==> Alle ablehnen
• "frame-ancestors 'self';" ==> Selber erlaubt, aber alle anderen ablehnen
• "frame-ancestors 'self' 'shemel.de' 'test.de';" ==> Selber erlaubt, und bestimmte Domains zulassen

Damit der Browser die Content Security Policy anwendet, muss vor der Auslieferung des HTML-Dokuments ein spezieller HTTP-Header gesetzt werden. Hierfür gibt es die folgenden Möglichkeiten:

HTML-Code: <meta>-Element hinzufügen

Wird vom Webserver kein CSP-Header versendet, kann dies mit den den folgenden <meta>-Elementen nachgeholt werden:

<head>
...
  <meta http-equiv="Content-Security-Policy" content="frame-ancestors 'none';">
  <meta http-equiv="X-Content-Security-Policy" content="frame-ancestors 'none';">
  <meta http-equiv="X-WebKit-CSP" content="frame-ancestors 'none';">
...
</head>

Ähnlich funktioniert dies auch bei serverseitigen Scriptsprachen, wie zum Beispiel PHP:

<?php
...
header("Content-Security-Policy: frame-ancestors 'none';");
header("X-Content-Security-Policy: frame-ancestors 'none';");
header("X-WebKit-CSP: frame-ancestors 'none';");
...
?>

Webserver Konfiguration: Apache HTTP

Das Modul mod_headers muss aktiv sein:
a2enmod headers //Enabling module headers.

Anschließend muss die Konfiguration in der httpd.conf angepasst werden:
Header set Content-Security-Policy "frame-ancestors 'none';"

Nach dem Speichern der Datei muss der Apache Webserver neu gestartet werden.

Apache HTTP Server - Basis Wissen (Module mod_info, mod_status, mod_remoteip)

Als Erweiterung zum Artikel Apache HTTP Server - vHost Konfiguration bietet sich ein Blick in die offizielle Apache Dokumentation für die Module mod_info, mod_status und mod_remoteip an.

Apache Module mod_info

Bietet einen umfassenden Überblick über die Serverkonfiguration, https://httpd.apache.org/docs/2.4/mod/mod_info.html.

Achtung: Sobald mod_info auf den Server geladen ist, ist seine Funktion in allen Konfigurationsdateien verfügbar, einschließlich Dateien pro Verzeichnis (z. B. .htaccess). Dies kann sicherheitsrelevante Auswirkungen auf die Webseiten haben. Daher am Besten den Zugriff auf den "localhost" beschränken, bzw. nur für bestimmte IP-Adressen freigeben.

<Location "/server-info">
    SetHandler server-info
    # Allow access from server itself
    Require ip 127.0.0.1

    # Additionally, allow access from local workstation
    Require ip 192.168.1.111
</Location>

Apache Module mod_status

Bietet Informationen zur Serveraktivität und -leistung, https://httpd.apache.org/docs/2.4/mod/mod_status.html.

Achtung: Auch hier ist zu beachten, dass beim Laden des Moduls mod_status der Server die Funktion in allen Konfigurationsdateien verfügbar ist, einschließlich der Dateien pro Verzeichnis (z. B. .htaccess). Dies kann auch hier sicherheitsrelevante Auswirkungen auf die Webseite haben! Daher am Besten den Zugriff auf den "localhost" beschränken, bzw. nur für bestimmte IP-Adressen freigeben.

<Location "/server-status">
    SetHandler server-status
    # Allow access from server itself
    Require ip 127.0.0.1

    # Additionally, allow access from local workstation
    Require ip 192.168.1.11
</Location>

Apache Module mod_remoteip

Das Module Remote IP https://httpd.apache.org/docs/2.4/mod/mod_remoteip.html ersetzt die ursprüngliche Client-IP-Adresse durch die IP-Adresse des useragent, die von einem Proxy oder einem Load Balancer über die Anforderungsheader angezeigt wird. So kann man dennoch auf die IP-Adresse des Besuchers reagieren.

Apache Serversignatur

Anpassung unter: /etc/apache2/conf-available/security.conf

ServerSignature
Bestimmt ob die Serversignatur angezeigt wird.
ServerSignature On | Off

ServerTokens
Bestimmt die Art der Serversignatur, wobei Full die meisten und Prod die wenigsten Informationen ausgibt.
ServerTokens Full | OS | Minimal | Minor | Major | Prod

WordPress - Brute-Force Angriffe mit XML-RPC und REST-API

Das freie Content-Management-System WordPress ist weit verbreitet und oft werden nach einer Erstinstallation keine neuen Releases bzw. Security Updates mehr eingespielt. Hierdurch ergeben sich über die XML-RPC Schnittstelle in Verbindung mit der REST-API Möglichkeiten für eine Brute-Force-Attacke.

1. Schritt: REST-API Wordpress User herausfinden

• Unter der URL http://DOMAIN.DE/wp-json/wp/v2/users lassen sich die User der Wordpress Installation auslesen, sofern die API von Wordpress nicht deaktiviert wurde.

• Gleichzeitig lassen sich hier ggf. massenhaft E-Mail Adressen abgreifen, wenn die User als E-Mail Adressen angelegt wurden. 
• Beheben lässt sich dies durch anpassen der functions.php, siehe auch https://wordpress.stackexchange.com/questions/252328/wordpress-4-7-1-rest-api-still-exposing-users oder alles unter dem Pfad "/wp-json" auf dem Webserver selber mit Hilfe von HTTP-Basic-Auth absichern.
  

2. Brute-Force-Angriff über die XML-RPC Schnittstelle

• Über die xmlrpc.php lassen sich Anfragen zur Authentifizierung per Webservice mit Benutzernamen und das Passwort senden.
• Benötigt man diese Schnittstelle nicht, sollte man die xmlrpc.php deaktivieren. Mit Hilfe des WordPress XML-RPC Validation Service kann man überprüfen, ob der Service aktiv ist.
• Bei GitHub finden sich viele xmlrpc-bruteforcer, mit nur wenigen Schritten, lassen sich so mit Hilfe von einem Python-Script Brute-Force-Angriffe starten.

• Passende Listen mit Passwörtern finden sich z.B. unter https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/10k-most-common.txt.
• Die 10 Tausend am häufigsten verwendeten Passwörter lassen sich so in nur wenigen Sekunden mit dem Script überprüfen.
• Deswegen auch hier der Tipp, Passwörter am Besten mit einer Länge von mind. 12 Zeichen immer per Zufall generieren lassen!

 

Firefox - command line option, start from a batch file

Will man nach dem Starten von Windows direkt mit seinen Lieblingswebseiten surfen, bietet sich beim Firefox Browser die folgenden Möglichkeiten per "command line" oder "batch file" an.

Aufruf per command line (cmd):

"C:\Program Files\Mozilla Firefox\firefox.exe" -new-window "http://www.ebay.de/" -new-window "https://www.mydealz.de/" -new-window "https://mail.google.com/mail/u/0/#inbox"


Aufruf per batch file (.bat):

@echo off
start "" "C:\Program Files\Mozilla Firefox\firefox.exe" -new-window "http://www.ebay.de/" -new-window "https://www.mydealz.de/" -new-window "https://mail.google.com/mail/u/0/#inbox"

Clickjacking - Schutz mit Hilfe von Content Security Policy (CSP) oder X-Frame-Options

Bei Clickjacking versucht eine böswillige dritte Website die eigentliche Website des Nutzers in einem unsichtbaren Rahmen zu laden bzw. zu überlagern (z.B. per iframe). Der Benutzer wird dann dazu verleitet, Aktionen auf der ursprünglichen (böswilligen) Website auszulösen ohne dass er sich dessen bewusst ist.

Hintergrund: Clickjacking ist ein konzeptionelles Problem von JavaScript und Webanwendungssicherheit. (Quelle: https://de.wikipedia.org/wiki/Clickjacking)
 

Welche Gegenmaßnahmen gibt es?

Um so einen Angriff zu verhindern, sollte man eine explizite Whitelist von Seiten definieren, die die aktuelle Seite über die Direktive für Frame-Vorfahren in die Content Security Policy (CSP) einbetten können.

Damit auch ältere Browser unterstützt werden, kann der (veraltete) Header X-Frame-Optionen zusätzlich auf DENY oder SAMEORIGIN gesetzt werden. Die Option DENY verhindert, dass Browser die Website in einem iframe anzeigt.

Header set X-Frame-Options "DENY"

Wird der Header auf SAMEORIGIN gesetzt, kann die Website in iframes auf anderen Seiten derselben Domain eingebettet werden, verhindert jedoch das Einbetten in Websites von dritten.

Header always set X-Frame-Options "SAMEORIGIN"

Wichtig: X-Frame-Options funktioniert nur durch den HTTP-Header, und NICHT per meta-tag! Daher muss die Einstellung direkt im Apache vorgenommen oder per .htaccess gesetzt werden.

Leaflet.js - draggable marker und Ausgabe der Koordinaten (lat, lng)

In dem Beitrag "Webseite mit interaktiver Karte ohne Google Maps? Leaflet.js" hatte ich beschrieben, wie man Leaflet.js auf seiner Webseite als gute Alternative zu Google Maps einbindet. 

In diesem Beispiel geht es darum einen "ziehbaren" Marker zu erstellen und die Koordinaten in zwei Feldern (lat, lng) anzuzeigen.

Es wird die Dragend-Methode für den Marker verwendet um lat und lng abzufangen:

<script type="text/javascript">
    function showMap() {
      
        var map = L.map('map_leaflet').setView([50.9033081, 9.5924615], 14);
        var my_divicon = L.divIcon({
            className: 'arrow_box'
        });
        var marker = L.marker([50.9033081, 9.5924615], {
            draggable:true
        });
        function addToTextBox(lt,ln){
            document.getElementById('lat').innerHTML = lt;
            document.getElementById('lng').innerHTML = ln;
          
        }
        marker.on('dragend', function(event){
            //alert('drag ended');
            var marker = event.target;
            var location = marker.getLatLng();
            var lat = location.lat;
            var lon = location.lng;
            addToTextBox(lat,lon);
            //alert(lat);
            //retrieved the position
          });
       
        // load a tile layer
        L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
            {
                attribution: 'Map data © OpenStreetMap and contributors CC-BY-SA',
                maxZoom: 18,
                minZoom: 9
            }).addTo(map);
          
        // initialize the map
        //var map = L.map('map_leaflet', { layers: osm, tap: false } );
        L.control.scale({imperial:false}).addTo(map); // metrisch

        marker.addTo(map);
    }
</script>

JavaScript - Fetch API File Upload: Apache 403 Forbidden error SecFilterEngine

Für eine Erweiterung meiner Webcamseiten, benötigte ich ein Formular mit Bild-Upload-Funktion. Das Hochladen von Dateien ist eine der häufigsten Funktionen für eine Webanwendung. Ich verwende in meinem Beispiel KEINE der vielen JavaScript-Bibliotheken, sondern die Fetch-API (eine native JavaScript Funktion).

Als erstes benötigt man auf der Webseite ein HTML Formular mit einem Eingabeelement:

...
    <form action="xyz.php" name="melderForm" method="post" enctype="multipart/form-data">
...
        <input id="formMelderImage-file" class="form-control" type="file">
...
    </form>


Mit dem folgenden JavaScript Code wird ein Event-Listener hinzugefügt, wenn der Benutzer eine Datei auswählt. Mit der Methode fileUpload () wird ein Dateiobjekt als Eingabe empfangen und es mit fetch () auf den Server hochgeladen (inklusive einer Überprüfung des Dateityps (nur Bilder) und der Dateigröße (< 10MB).

<script>
    // Datei vom Formular
    const fileInput = document.getElementById('formMelderImage-file');

    // event listener
    fileInput.addEventListener('change', () => {
        fileUpload(fileInput.files[0]);
    });
   
    const fileUpload = (file) => {
        // Check des Dateityps
        if(!['image/jpeg', 'image/gif', 'image/png', 'image/svg+xml'].includes(file.type)) {
            console.log('Es sind nur Bilder erlaubt!');
            return;
        } else if(file.size > 10 * 1024 * 1024) { // Check der Groesse (< 10MB)
            console.log('Die Datei muss kleiner 10MB sein!');
            return;
        } else {
            // Datei zum FormData object hinzufügen
            const fd = new FormData();
            fd.append('formMelderImage-file', file);

            // `POST` request senden
            fetch('/upload/image', {
                method: 'POST',
                body: fd
            })
            // Abfangen von Fehlern
            .then(res => res.json())
            .then(json => console.log(json))
            .catch(err => console.error(err));
        }
    }
</script>

SyntaxError: "JSON.parse: unexpected character at line 1 column 1 of the JSON data" - 403 Forbidden

404- oder 403-Fehlern nach dem Senden eines Formulars können an der mod_security-Einstellung in Apache auf dem Server liegen. Das Apaches-Modul mod_security hat standardmäßig ein Upload-Limit von 60 KB, sodass bei jedem größeren Upload ein 403-Fehlercode ausgegeben wird.

Man kann versuchen diese zu deaktivieren, und folgendes zu der .htaccess-Datei hinzuzufügen, man wird aber vermutlich keinen Erfolg mehr haben (support for .htaccess files was discontinued in 2.x as it raised too many security issues https://stackoverflow.com/questions/19093542/how-to-disable-mod-security-and-mod-security2-in-htaccess/19196856#19196856)

<IfModule mod_security.c>
  SecFilterEngine Off
</IfModule>

Oder wenn man direkten Zugriff auf die Apache Einstellungen hat, geht dies auch direkt unter nano  /etc/httpd/conf.d/mod_security.conf .

<IfModule mod_security.c>

    # Turn the filtering engine On or Off
    SecFilterEngine Off

Webseite mit interaktiver Karte ohne Google Maps? Leaflet.js

Leaflet.js ist eine Open-Source-JavaScript-Bibliothek für interaktive Karten auf der eigenen Webseite.

Die JavaScript Bibliothek ist klein, einfach und flexibel und derzeit wahrscheinlich die beliebteste Open-Source-Mapping-Bibliothek. Gleichzeitig ist Leaflet.js auch eine gute Alternative zu Google Maps, da eine Verwendung nur noch nach Registrierung möglich ist und nur noch in einem geringen Umfang kostenlos ist.

Die Bibliothek ist kostenlos und frei nutzbar (2-Clause BSD License).

Desweiteren ist es möglich, dass die Karten vom eigenen Server ausgeliefert werden können, somit muss im Impressum bei der Datenschutzerklärung (DSGVO) nicht auf einen externen Service verwiesen werden.

Aktuelles Beispiel, wenn die Verwendung der Google Maps API ohne Registrierung erfolgt:

Folgende Informationen fehlen Google: https://developers.google.com/maps/documentation/javascript/error-messages?utm_source=maps_js&utm_medium=degraded&utm_campaign=keyless#api-key-and-billing-errors

• Are you using an API key?
• Is billing enabled on your account?
• Is the provided billing method no longer valid (for example an expired credit card)?
• Is there an exceeded self-imposed daily limit on the API?
• Does your API key have an IP addresses restriction?

Integration von Leaflet.js in die eigene Webseite:

• Download der Bibliothek: https://leafletjs.com/download.html

• Ordner entpacken und unter ../leaflet speichern

• In der HTML-Datei ein div element mit einer id hinterlegen:
• <div id="map_leaflet"></div>

• Die CSS‐Datei und das Leaflet‐API‐Script einbinden:
• <link rel="stylesheet" href="leaflet/leaflet.css" rel="stylesheet" />
• <script src="leaflet/leaflet.js"></script>

• Der Kartencontainer (mapid) muss eine definierte Höhe hat z.B. per CSS festlegen:
• #map_leaflet{ height: 392px; } 
• <div id="map_leaflet" style="width:800px; height:392px"></div>

• Damit ein Layer anzeigt werden kann, muss der Kartenbereich (hier mit den Koordinaten) initalisiert werden:
• var map = L.map('map_leaflet').setView([50.869333, 9.715948], 14);

• Wie auch die Google Maps API benötigt die Leaflet API Kartenbilder (Tiles im .png oder .jpeg Format), diese werden je nach Zoomstufe schachbrettartig zu einer Karten zusammengesetzt:
• https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png (Templatestring hinzufügen)
• Servernummer = (s)
• Zoomlevel = (z)
• Koordinaten = (x,y)
• Zoom Bereich und Copyright werden festgelegt

L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
{
    attribution: 'Map data © OpenStreetMap and contributors CC-BY-SA',
    maxZoom: 18,
    minZoom: 9
}).addTo(map);

• Metrischen Maßstab in der Karte einblenden:
• L.control.scale({imperial:false}).addTo(map); // metrisch

• Mit der Methode L.marker. kann man Orte auf der Karte markieren:
• L.marker([50.869333, 9.715948]).addTo(map);

• Mit bindPopup kann ein Popup hinterlegt werden und beim Aufrufen der Karte geöffnet werden:
• L.marker([50.869333, 9.715948]).addTo(map).bindPopup("Bahnhofsmission Bad Hersfeld").openPopup();

Weitere Beispiele finden sich auch auf der Herstellerseite: https://leafletjs.com/examples.html

Anbei der komplette Quellcode:

<html>
    <head>
...
        <link rel="stylesheet" href="leaflet/leaflet.css" rel="stylesheet" />
...
        <script src="leaflet/leaflet.js"></script>
...
        <script type="text/javascript"> 
            function showMap() {           
                // initialize the map
                var map = L.map('map_leaflet').setView([50.869333, 9.715948], 14);
               
                // load a tile layer
                L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
                    {
                        attribution: 'Map data © OpenStreetMap and contributors CC-BY-SA',
                        maxZoom: 18,
                        minZoom: 9
                    }).addTo(map);
               
                L.control.scale({imperial:false}).addTo(map); // metrisch
               
                //L.marker([50.869333, 9.715948]).addTo(map);
                L.marker([50.869333, 9.715948]).addTo(map).bindPopup("Bahnhofsmission Bad Hersfeld").openPopup();
            }
        </script>
    </head>
   
    <body onload="showMap()">
...
        <div id="map_leaflet" style="width:800px; height:392px"></div>
...
    </body>
</html>

Retro - Surfen mit historischen Browsern

Auf der Webseite https://evolt.org/ gibt es ein Archiv von fast allen historischer Browsern. Möchte man einen "nostalgischen" Ausflug in die Anfänge des Web machen, ist man hier genau richtig.

Push-Nachrichten von Webseiten im Firefox komplett abschalten

Jeder kennt das Problem, viele Webseiten fragen mittlerweile nach "Berechtigungen um Push-Nachrichten senden zu dürfen".

Eine schnelle Lösung um das Problem zu beheben, bietet jetzt der Firefox Browser von Mozilla:

• Im Menü links "Einstellungen" wählen,
• links "Datenschutz und Sicherheit" auswählen
• und den Punkt "Benachrichtigungen" anklicken.

Sicher surfen? Folgende Plugins helfen

Möchte man sicher mit seinem Browser im Internet unterwegs sein, sollten mindestens die folgenden Plugins installiert sein:

• uBlock Origin: https://www.heise.de/download/product/ublock-origin-97011
• Sehr guter Werbeblocker (schneller als das bekannte Adblock Plus) mit sehr vielen Einstellungsmöglichkeiten.
• HTTPS Everywhere: https://www.heise.de/download/product/https-everywhere-74840
• Nicht immer erfolgt sofort bei jeder Webseite eine Kommunikation per https, mit diesem Plugin wird immer die verschlüsselte Webseite aufgerufen.
• Disconnect: https://www.heise.de/download/product/disconnect-80319 
• Perfekt als Erweiterung zu dem oben genannten Werbeblocker. Tracker von Google oder auch den sozialen Medien wie z.b. Facebook werden geblockt.

DNS - Eigene Domain auf eine andere IP mit Bind umleiten

Mit Hilfe des Domain Name System (DNS) wird die Namensauflösung im Internet durchgeführt. Gibt man z.B. die Domain beispiel.de ein, dann wird diese vom DNS in die zugehörige IP-Adresse umgewandelt.

Zum Beispiel wird eine Domain in eine

• IPv4-Adresse 82.165.229.138 oder eine 
• IPv6-Adresse 2a02:2e0:3fe:1001:7777:772e:2:85

umgewandelt und der Browser leitet die Anfragen zu dem richtigen Server weiter.

Dies kann man selber z.B. mit dem Befehl ping in der Komandozeile testen:

Möchte man sichergehen, dass eine IPv6 Adresse angezeigt wird (sofern vorhanden), dann verwendent man ping -6 www.domainname.de .

DNS Eintrag einer eigenen Domain ändern

Besitzt man einen eigenen Server (z.B. virtueller Server von Host Europe) kann man diesen als DNS-Server mit Hilfe des Programms Bind verwenden. Hierdurch ist es möglich, eine Domain auf einen anderen Server zeigen zu lassen. Anwendungsfälle wären  z.B. ein Server Umzug oder ein schneller Domainumzug ohne auth-code.

Bind ist die aktuell am häufigsten verwendete DNS Software im Internet. Dieser kann mit dem folgenden Befehl installiert werden:

sudo apt-get install bind9

Des weiteren ist es auch sinnvoll, die Programme dig und dnsutils zu installieren, damit man die Namensauflösungen anschließend testen kann.

sudo apt-get install dnsutils
sudo apt-get install dig

Beispiel: Anpassen der IP-Adresse für eine Domain

Bevor man mit der Anpassung starten kann, ist es nötig die neue IP-Adresse noch bei einem weiteren DNS-Server einzutragen (secondary DNS). Denn nur so, wird auch wirklich die neue IP-Adresse übernommen. Hierfür kann man z.B. den Service von http://www.twisted4life.com verwenden.

Man gibt dafür den Domainnamen ein und die IP-Adresse des primären DNS Server (auf den wir soeben bind installiert haben).

Anschließend sagt uns der Service auch, welchen Eintrag wir in der Zonendatei (named.conf.local) vornehmen müssen:

zone "simxxxxxx.xe" { //yourdomain.com
    type master;
    file "/etc/bind/db.simxxxxxx.xe"; //yourdomain.com
    allow-transfer {
       202.157.182.142;
    };
};

Nach der Installation befinden sich alle nötigen Dateien unter /etc/bind/ , hier ist die zentrale Datei /etc/bind/named.conf . In der die folgenden Dateien inkludiert werden:

include "/etc/bind/named.conf.options";
include "/etc/bind/named.conf.local";
include "/etc/bind/named.conf.default-zones";

Jetzt wird der oben genannte Eintrag in named.conf.local vorgenommen und es muss noch eine Zonendatei für den Master Eintrag erstellt werden.

Die Datei db.simxxxxxx.xe sollte dann in etwa so aussehen (IPextern ist dann die neue IP-Adresse der Domain):

// Serial aufbau: Form YYYYMMDDSS, mit YYYY=Jahr, MM=Monat, DD=Tag und SS=zweistellige Seriennummer, die bei mehreren Änderungen an einem Tag jeweils um eins erhöht wird.
// Kommentare werden durch „;“ (Semikolon) eingeleitet. Alles, was rechts von einem „;“ auftaucht, gilt als Kommentar.

; simxxxxxx.xe
$TTL    604800
@       IN      SOA     simxxxxxx.xe root.simxxxxxx.xe. (
2014010301 ; Serial
28800 ; refresh - 8 Stunden
7200 ; retry - 2 Stunden
604800 ; expire - 1 Woche
604800 ; Negative Cache TTL
                        )

@               IN      NS      ns1.simxxxxxx.xe.
@               IN      NS      ns1.twisted4life.com.


;MX-Records
@ IN MX 1 aspmx.l.google.com.
@ IN MX 3 alt1.aspmx.l.google.com.
@ IN MX 3 alt2.aspmx.l.google.com.
@ IN MX 5 aspmx2.googlemail.com.
@ IN MX 5 aspmx3.googlemail.com.
@ IN MX 5 aspmx4.googlemail.com.
@ IN MX 5 aspmx5.googlemail.com.
@ 86400 IN TXT "v=spf1 include:_spf.google.com ~all"

ns1.simxxxxxx.xe.   1800  IN  A    178.2XX.XX.X4 ; IPvserver
@                   1800  IN  A    85.2XX.XX.X8  ; IPextern
*                   1800  IN  A    85.2XX.XX.X8  ; IPextern
 

In dem oben genannten Beispiel wurden auch die MX-Records auf Google angepasst, damit dieser Mailserver verwendet werden kann. Siehe auch https://support.google.com/a/answer/33915 .

Anschließend muss ein reload von Bind erfolgen.

sudo /etc/init.d/bind9 reload

Zu guter Letzt muss auf der Provider Seite (wo die Domain gebucht ist) eine Anpassung des DNS Eintrags erfolgen:

Mit einem nslookup kann jetzt überprüft werden, ob die neue IP-Adresse für die Domain übernommen werden konnte.

nslookup simxxxxxx.xe 178.2XX.XX.X4

Apache HTTP Server - vHost Konfiguration

Wie kann man mehrere Webseiten mithilfe von einem Webserver betreiben?

Dies geht mit Hilfe des "Virtual Hosting". Dabei wird der Webserver (z.B. Apache) so konfiguriert, dass er auf unterschiedliche Hostnamen (Doamins) reagieren kann. Somit ist es möglich, auf einem Webserver, mehrere Webseiten unter der gleichen IP-Adresse gleichzeitig zu betreiben. Der Webserver entscheidet auf Basis des HTTP-Headers, welche Webseite ausgeliefert werden soll.

Auszug eines HTTP Headers:

Beispiele von Apache für die Konfiguration befindet sich unter /etc/apache2/sites-available

• default
• default-ssl 

Diese können als Basis für eine eigene Konfiguration verwendet werden:

Konfiguration der eigenen "Virtual Host" Datei

Im Verzeichnis /etc/apache2/sites-available habe ich eine neue Datei namens hemel angelegt. Dazeu habe ich ein Verzeichnis unter /var/www/virtual/hemel angelegt, da sich dann hier die eigentlichen "html Dateien" befinden werden.

Hier meine Beispiel Konfigiration um auf die Domain "beispiel.de" reagieren zu können:
#############################################################
# www.beispiel.de
#############################################################
<VirtualHost *:80>
     ServerName www.beispiel.de:80
     ServerAdmin server@beispiel.de
     ServerAlias www.beispiel.de

     # -Indexes - Verzeichnis Inhalt nicht anzeigen!
     Options -Indexes
     DocumentRoot /var/www/virtual/hemel/htdocs/beispiel-de
     ScriptAlias /cgi-bin/ /var/www/virtual/hemel/cgi-bin/

     LogLevel warn
     ErrorLog /var/log/apache2/beispiel-error.log
     CustomLog /var/log/apache2/beispiel-access.log combined

     # Leitet alle Anfragen an den ssl-host weiter.
     #RedirectPermanent / https://beispiel.de/
</VirtualHost>

• ServerAdmin: E-Mail-Adresse des Server-Administrators hinterlegen, diese würde man bei Fehlermeldungen im Apache sehen. 
• ServerName: Unter diesem Namen ist die Seite erreichbar. Muss aber per DNS oder über /etc/hosts auflösbar sein.
• DocumentRoot: Basisverzeichnis "document root" des Virtual Hosts. http://BEISPIEL.de/datei.html => Zugriff auf die Datei /var/www/virtual/hemel/htdocs/beispiel-de/datei.html

Nach dem ein neuer Virtual Host angelegt wurde ("available"), muss diese noch im Webserver aktiviert werden ("enabled"). Dies geht mit dem folgenden Befehl:

• sudo a2ensite hemel

Jetzt ist die angelegt Datei unter /etc/apache2/sites-enabled verlinkt und aktiviert.

Hinweis: Mehr Details zu den einzelnen Konfigurationen finden sich in der Apache Dokumentation http://httpd.apache.org/docs/2.2/de/mod/core.html#virtualhost