Einfaches VPN mit Wireguard für Homeoffice

Aufgrund der „Corona-Kriese“ möchte auch ich etwas für unser Land tun und hier eine leicht Verständliche Anleitung schreiben wie man einen VPN-Zugang mithilfe von Wireguard für die Anwendung im Homeoffice einrichten kann.

Wireguard ist eine recht neue VPN-Lösung mit einem sehr schlanken und effizienten Protokoll, welches sich zudem auch noch sehr einfach einrichten lässt (im Vergleich z.B. zu OpenVPN).
Im Idealfall nutzen wir als Host-Betriebssystem für den Server ein Debian-Derivat-Linux mit einem 5.x Kernel, da die Wireguard Kernelmodule in Kerneln ab Version 5 bereits einkompiliert sind und man diese dann nicht selbst für den aktuell verwendeten Kernel neu bauen muss.

Hat man nicht den Genuss einen 5er Linux Kernel zu nutzen oder auf ihn zu upgraden, muss man die Wiregiard-Kernel Module für den verwendeten Kernel selbst bauen.
Dazu Installieren wir das Meta-Paket „wireguard“ aus dem Unstable zweig, welches dann die Pakete „wireguard-dkms“ und „wireguard-tools“ installiert:

# echo "deb http://deb.debian.org/debian/ unstable main" | sudo tee /etc/apt/sources.list.d/unstable-wireguard.list
# printf 'Package: *\nPin: release a=unstable\nPin-Priority: 90\n' | sudo tee /etc/apt/preferences.d/limit-unstable
# apt update
# apt install wireguard

Nun werden die besagten Pakete „wireguard-dkms“ und „wireguard-tools“ installiert und „wireguard-dkms“ sorgt dafür dass das Kernel-Modul erstellt wird:

Holen:1 http://deb.debian.org/debian unstable/main amd64 wireguard-dkms all 0.0.20200215-2 [252 kB]
Holen:2 http://deb.debian.org/debian unstable/main amd64 wireguard-tools amd64 1.0.20200206-2 [85,2 kB]
Holen:3 http://deb.debian.org/debian unstable/main amd64 wireguard all 1.0.20200206-2 [7.316 B]
Es wurden 345 kB in 0 s geholt (1.497 kB/s).
Vormals nicht ausgewähltes Paket wireguard-dkms wird gewählt.
(Lese Datenbank ... 67277 Dateien und Verzeichnisse sind derzeit installiert.)
Vorbereitung zum Entpacken von .../wireguard-dkms_0.0.20200215-2_all.deb ...
Entpacken von wireguard-dkms (0.0.20200215-2) ...
Vormals nicht ausgewähltes Paket wireguard-tools wird gewählt.
Vorbereitung zum Entpacken von .../wireguard-tools_1.0.20200206-2_amd64.deb ...
Entpacken von wireguard-tools (1.0.20200206-2) ...
Vormals nicht ausgewähltes Paket wireguard wird gewählt.
Vorbereitung zum Entpacken von .../wireguard_1.0.20200206-2_all.deb ...
Entpacken von wireguard (1.0.20200206-2) ...
wireguard-dkms (0.0.20200215-2) wird eingerichtet ...
Loading new wireguard-0.0.20200215 DKMS files...
Building for 4.9.0-6-amd64
Building initial module for 4.9.0-6-amd64
Done.

wireguard:
Running module version sanity check.
 - Original module
   - No original module exists within this kernel
 - Installation
   - Installing to /lib/modules/4.9.0-6-amd64/updates/dkms/

depmod....

DKMS: install completed.
wireguard-tools (1.0.20200206-2) wird eingerichtet ...
wireguard (1.0.20200206-2) wird eingerichtet ...
Trigger für man-db (2.7.6.1-2) werden verarbeitet ...

Damit haben wir Wireguard und das passende Kernel-Modul installiert und können nun an die Konfiguration gehen.
Hierfür gehen wir in /etc/wireguard und erstellen uns einen public-key und einen private-key:

# cd /etc/wireguard
# wg genkey | tee privatekey | wg pubkey > publickey

Für mein Beispiel nutze ich folgende Keys:
Private: 8NTdGTXDBH2pGLb08nMC007ZjpQE666PYrqmgyASUS=
Public: I2btYR+gLPYDi76p/MyAnniSWbubELyh5YHoseKxu0s=

Der Private-Key wird für die Server-Config genutzt. Der Public-Key wird dann in der Config der Clients hinterlegt.
Sinnvollerweise befinden sich die VPN-Clients alle in einem seperaten IP-Netz (10.0.0.x) wobei der VPN-Server die IP 10.0.0.1 bekommt und der erste Client dann die 10.0.0.2.
Mit diesem Wissen erstellen wir nun die Server-Konfiguration in /etc/wireguard/wg0.conf:

[Interface]
Address = 10.0.0.1/24
SaveConfig = false
PostUp   = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -A FORWARD -o wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE; 
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -D FORWARD -o wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE; 
ListenPort = 51820
FwMark = 0xca6c
PrivateKey = 8NTdGTXDBH2pGLb08nMC007ZjpQE666PYrqmgyASUS=

Das war es auch schon grundsätzlich zur Server-Config. Später mussen hier noch die Zugänge der Clients mit rein – das folgt weiter unten.
Der Wireguard-Server läuft auf Port 51820, was bedeutet das wir diesen Port in der Firewall freigeben bzw ein Portforwarding für diesen Port erstellen müssen.
Ausserdem muss der Eintrag „net.ipv4.ip_forward = 1“ in der /etc/sysctl.conf auskommentiert werden.

Mein Wireguard Client ist ein Windows10 PC.
Die Client-Installation können wir uns unter https://www.wireguard.com/install bzw. als Direktlink (64Bit) unter https://download.wireguard.com/windows-client/wireguard-amd64-0.1.0.msi herunterladen und installieren.
Nachdem Wireguard auf dem Client installiert und geöffnet ist, können wir über „Strg+N“ oder „Add empty Tunnel..“ einen neuen Tunnel definieren.
Wichtig ist hier als erstes der Public-Key welcher oben eingeblendet wird (z.B. 6n89/e9rMmXYaymRDMYnnjJ7LgiVnP6GKplHYN6+BQY=).
Diesen Client-PublicKey brauchen wir um den Client in der Server-Config mit aufzunehmen.
An dieser Stelle geht es aber erst einmal mit der Client-Config weiter.

# Angabe des VPN-Client (PrivateKey und VPN-IP)
[Interface]
PrivateKey = 8OvLmuLKv2GUSfeJ4bcEGF2mTeuySKJhoBQPlSgmGUA=
Address = 10.0.0.2/32
 
# Angabe des VPN-Servers (Public-Key, IP´s welche über VPN geroutet werden und der Endpunkt des VPN-Servers)
[Peer]
PublicKey = I2btYR+gLPYDi76p/MyAnniSWbubELyh5YHoseKxu0s=
AllowedIPs = 10.0.0.1, 192.168.1.0/24
Endpoint = vpn.meinefirma.de:51820

Kurze Erklärung: Mein „Firmen-Netz“, welches ich über den VPN-Tunnel erreichen möchte ist das 192.168.1.x Netz.
Über den Eintrag „AllowedIPs“ gebe ich hier an welche IP´s/Netze über den VPN-Tunnel geroutet werden sollen.

Im Wireguard-Client selbst sieht das ganze dann so aus:

Jetzt müssen wir weider zurück zu der Server-Config und den Client in der Konfiguration mit angeben.
Dafür fügen wir Analog zur Client-Config auch einen [Peer] Abschnitt unten mit in die /etc/wireguard/wg0.conf ein:

# VPN-Client Sven (Angabe des PublicKey und der IP des Clients)
[Peer]
PublicKey = 6n89/e9rMmXYaymRDMYnnjJ7LgiVnP6GKplHYN6+BQY=
AllowedIPs = 10.0.0.2/32

Das wars auch schon. Jetzt haben wir Wireguard auf Server und Client Installiert und eingerichtet.
Dann wollen wir den Server auch mal starten. Der Start und Stop funktioniert über die wg-quick Befehle.
Zum Starten reicht ein „wg-quick up wg0“ und zum beenden analog dazu ein „wg-quick down wg0“.
Die Ausgabe des „wg-quick up wg0“ sollte dann so aussehen:

# wg-quick up wg0
[#] ip link add wg0 type wireguard
[#] wg setconf wg0 /dev/fd/63
[#] ip -4 address add 10.0.0.1/24 dev wg0
[#] ip link set mtu 1420 up dev wg0
[#] iptables -A FORWARD -i wg0 -j ACCEPT; iptables -A FORWARD -o wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE;

Damit läuft Wireguard als VPN-Server.
Im Windows-Client muss man nun nur noch auf dem Knopf „Activate“ drücken – und es wird eine Verbindung zum VPN-Server aufgebaut.
Ab nun können wir von „remote“ auf das „Firmen“-Netz zugreifen.

1  

Arduino – Einführung

Dies ist der erste Teil einer Arduino-Reihe.
Aufgrund aktueller Projekte habe ich wieder vermehrt mit Arduino zu tun, so dass ich in meinen Unterlagen von 2016 rumsuchen und experimentieren musste – also wollte ich meine Unterlagen in diesem Zuge gleich mit digitalisieren.

Meine Projekte führe ich zum Großteil mit dem Arduino Nano durch – einfach aus dem Grund weil es diese Boards im China-Shop im 10er Pack recht günstig gibt.
Normalerweise fangen die Leute mit dem Arduino Uno an – beide Boards (Uno und Nano) unterscheiden sich aber kaum von der Technischen Seite.
Hier der Offizielle Link zum Arduino Uno: https://store.arduino.cc/arduino-uno-rev3
Und hier zum Arduino Nano: https://store.arduino.cc/arduino-nano

Der größte unterschied den man auf dem ersten Blick sieht ist wohl die Größe des Boards an sich.
Der Arduino Nano eignet sich eher für die Steckbrett-Versuche aufgrund der Breadboard-kompatiblen Größe.

Okay.. dann fangen wir mal an.
Wir haben jetzt im Idealfall einen Arduino Uno oder Nano vor uns liegen, ein Steckbrett, ein paar Kabel, ein paar LED´s und ein paar Wiederstände (dazu später mehr).

Wie fangen wir nun an?
Als erstes brauchen wir eine Software um die Programme zu schreiben die später auf den Arduino laufen sollen.
Hierfür nutzt man Standardmäßig die Arduino-IDE welche man in der Version 1.8.5 unter https://www.arduino.cc/download_handler.php?f=/arduino-1.8.5-windows.zip als portable Version herunterladen kann.
Diese habe ich bei mir in das Verzeichnis C:\Arduino\arduino-1.8.5 gelegt. Dort drin befindet sich nun die IDE, welche wir über die Arduino.exe aufrufen können.

Sobald man die IDE Aufgerufen hat, bekommt man einen neuen Sketch angezeigt.
Sketche nennt man die Programme, welche man mit der Arduino-IDE schreibt.
Der neue Sketch sieht dann in etwa so aus:

1
2
3
4
5
6
7
8
9
void setup() {
  // put your setup code here, to run once:
 
}
 
void loop() {
  // put your main code here, to run repeatedly:
 
}

Im Prinzip gibt es eine setup() Funktion in der man alle relevanten Einstellungen VOR dem Programmstart hinterlegt – und es gibt eine loop(), also eine Endlosschleife, welche immer wieder durch den Arduino aufgerufen wird.
Nun kennen wir auch das Funktionsprinzip des Arduinos – alles wird in einer Endlosschleife ausgeführt.

Um das etwas genauer zu sehen, öffnen wir eines der vielen Beispiele, welche zusammen mit der Arduino-IDE ausgeliefert werden unter: Datei -> Beispiele -> 01.Basics -> Blink
Dieses Blink-Programm läuft Standardmäßig auf jedem Arduino Board. Wenn man jetzt den UNO oder Nano über USB an eine Stromquelle anschließen würde, würde dieses Programm vom Werk aus darauf laufen – und eine LED auf dem Arduino-Board blinken.

Der Sketch dafür sieht dann so aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin 13 as an output.
  pinMode(13, OUTPUT);
}
 
// the loop function runs over and over again forever
void loop() {
  digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);              // wait for a second
  digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);              // wait for a second
}

Wie oben erwähnt setzen wir in der Setup() Funktion die Einstellungen die vor dem eigentlichen Programmstart feststehen sollen. In diesem Fall wird der GPIO-Pin 13 als Ausgang definiert. An diesem Pin ist in den meisten Fällen eine LED auf dem Board angeschlossen.
In der loop() wird nun gesagt das am Pin 13 ein HIGH Signal angelegt werden soll.
Dies geschieht durch die Funktion digitalWrite() da der Pin 13 ein Digitaler Pin ist.
Da der Arduino mit einer Spannung von 5V arbeitet bedeutet das HIGH Signal hier, das diese 5V durchgereicht werden und die LED leuchtet.
Danach wird über das delay(1000) eine Wartezeit von 1000ms – also einer Sekunde – festgelegt, bevor das Programm weiter ausgeführt wird.
Dann wird ein LOW Signal, also 0V am Pin 13 ausgegeben – damit leuchtet die LED dann nicht mehr.
Und am ende wird wieder eine Sekunde gewartet.

Da uns eine Sekunde zu langsam ist, ändern wir die 1000ms hier einfach mal in 100ms ab.
Wenn wir nun den Arduino über ein USB-Kabel an den PC anschließen, können wir diesen in der Arduino-IDE auswählen:
Unter „Werkzeuge“ -> „Board, Prozessor, Port“: Arduino Nano, ATmega328 on COM3
Über den Button1 (erste Knopf oben links in der Arduino-IDE) kann man nun das Programm kompilieren und schauen ob man Fehler gemacht hat. Für dieses Beispiel werden aber keine Fehler gefunden.
Nun kann man über den Button2 (Rechts neben Button1 in der Arduino-IDE) das Programm zum Arduino geben.
In der IDE sollte dann in etwa so eine Ausgabe erscheinen:

1
2
3
Der Sketch verwendet 1.030 Bytes (3%) des Programmspeicherplatzes. Das Maximum sind 30.720 Bytes.
Globale Variablen verwenden 9 Bytes (0%) des dynamischen Speichers, 2.039 Bytes für lokale Variablen verbleiben. 
Das Maximum sind 2.048 Bytes.

Wenn dieser dann fertig ist, startet er neu und das neue Programm läuft. Was wir nun sehen ist das die LED nicht mehr jede Sekunde blinkt, sondern alle 100 Millisekunden.

Sehr schön! Da haben wir doch schon einiges für den Anfang geschafft 🙂

0  

SQL Server localdb – Mehrere Versionen verwalten

Vor einiger Zeit habe ich HIER schon mal etwas über SQLServer 2012 localdb geschrieben.
Mittlerweile gibt es von der localdb installation mehrere Versionen (Aktuell: 2012 / 2014 / 2016).

Um Herauszufinden welche Versionen auf dem System installiert sind, kann der Befehl „sqllocaldb versions“ genutzt werden:

1
2
3
4
5
E:\Programme\cmder>sqllocaldb versions
Microsoft SQL Server 2012 (11.0.5058.0)
Microsoft SQL Server 2014 (12.0.4100.1)
Microsoft SQL Server 2016 (13.0.1601.5)
Microsoft SQL Server 2017 (14.0.1000.169)

Standardmäßig wird eine neue Datenbank-Instanz über den „Create“-Befehl mit der aktuelleren Version angelegt.
Möchte man eine Instanz mit der 2012er Version anlegen, geht dies so:

1
2
E:\Programme\cmder>sqllocaldb create SQL2012 11.0.5058.0
LocalDB instance "SQL2012" created with version 11.0.5058.0.

Und für die 2014er Version so:

1
2
E:\Programme\cmder>sqllocaldb create SQL2014 12.0.4100.1
LocalDB instance "SQL2014" created with version 12.0.4100.1.

Ebenfalls kann so auch explizit eine 2016er Instanz angelegt werden:

1
2
E:\Programme\cmder>sqllocaldb create SQL2016 13.0.1601.5
LocalDB instance "SQL2016" created with version 13.0.1601.5.

Oder für eine 2017er Instanz:

1
2
E:\Programme\cmder>sqllocaldb create SQL2017 14.0.1000.169
LocalDB instance "SQL2017" created with version 14.0.1000.169.

Read more »

0  

Vorstellung: RDLViewer

Hier möchte ich mal den RDLViewer vorstellen.
Im Prinzip macht er nichts anderes als Lokale SQL Server Reports mit integrierter Datenquelle im XML Format anzuzeigen.
Entwickelt wurde das ganze ursprünglich mal als Kostenfreie Reporting-Alternative für diverse interne Tools.
Ziel des ganzen war dabei möglichst einfach Berichtsdaten ausgeben – und aus diesen einen Bericht erstellen und anzeigen zu können.

Das ganze sieht dann z.B. mit dem Beispiel-Bericht (einer kleinen Rechnung) wie folgt aus:
1_testbericht

Read more »

0  

MarkdownEditor

Heutzutage scheint jeder seinen eigenen Markdown-Editor zu bauen..
Naja, das Projekt liegt schon länger auf meiner Platte rum – damals wusste ich noch nichts davon das es mittlerweile so viele Editoren für Markdown gibt.

Jedenfalls habe ich auch einen gebaut.
Hauptaugenmerkt dabei war:
– einfache Bedienung
– HTML-Vorschau
– Syntax Highlighting
– Halbwegs ansehnlich

Momentan ist dies eine WinForms anwendung, welche das MetroFramework nutzt.
Die HTML Vorschau wird durch MarkDig gerendert, welcher ein wirklich phänomenaler MD2HTML Konverter darstellt – und für die Eingabe und das Syntax Highlighting habe ich die FastColoredTextBox genutzt, welche ein paar RegEx´s von SlimDown nutzt.

Das ganze sieht dann so im „Bearbeitungs-Modus“ aus:
markdownEditor1
Read more »

0  

LDAP – 8. SSL und TLS in OpenLDAP

​Da wir unser LDAP nicht nur unverschlüsselt, sondern auch verschlüsselt nutzen wollen, hier eine Anleitung wie wir SSL/TLS mit OpenLDAP zum laufen bekommen.

SSL/TLS Zertifikat erstellen
Dies muss in einem Debian (Hostsystem oder Buildroot) erfolgen:

# apt-get install gnutls-bin
# certtool --generate-privkey --outfile /etc/ssl/private/ldap-ca-key.pem
# certtool --generate-self-signed --load-privkey /etc/ssl/private/ldap-ca-key.pem --outfile /etc/ssl/certs/ldap-ca-cert.pem

Die Fragen sollten nach Möglichkeit gewissenhaft beantwortet werden.
Die Schlüssel kopieren wir anschließend in die Openldap Chroot:

cp -a /etc/ssl /chroots/openldap/etc/ssl

Read more »

0  

LDAP – 7. TestSystem & Beispiele

Hier nun ein paar Beispiele für Gogs, Redmine und Dokuwiki zur verwendung von OpenLDAP als User-Backend.

​Gogs
Benutzer: gogstest (befindet sich in der Gruppe „gogs“)
Passwort: test
Einrichtung:

Authentication Type: LDAP (via BindDN)
Authentication Name: LDAP
Host: server.ip
Port: 389
Bind DN: cn=admin,dc=freifunk,dc=net
Bind Password: password
User DN: ou=users;dc=freifunk,dc=net
User Filter: (&(objectClass=posixAccount)(uid=%s)(memberof=cn=gogs,ou=groups,dc=freifunk,dc=net))
First name attribute: givenName
Surname attribute: sn
E-mail attribute: mail

Kein Enable TLS Encryption
kein Skip TLS Verify

Read more »

0  

LDAP – 6. Freifunk-Template für LDAPAdmin

Um im LDAPAdmin (http://ldapadmin.org) die Attribute der LDAP-Benutzer leichter bearbeiten zu können, bietet es sich an ein Template für die eigenen Wünsche zu erstellen.
Dieses Template erweitert das normale „User“ Template um einen Neuen Tab „Freifunk-Account“, der wiederum 3 Tabs beinhaltet: „Benutzer“, „Linux“, und „SSH Key“.
Dieses Template speichert man z.b. in den Eigenen Dateien und teilt LDAPAdmin über „Tools“ → „Options“ → Karteireiter „Templates“ mit, dass es im Verzeichnis für die Eigenen Dateien nach evtl. Vorhandenen Templates suchen soll.
Danach (und nach jeder Änderung an den Templates) muss man LDAPAdmin neu starten, da die Templates nur beim Start geladen werden.
Nach dem Neustart sollte in der „normalen User-Form“ die Erweiterten Eigenschaften unseres Freifunk-Accounts drin stehen:

LDAPAdmin-1LDAPAdmin-2LDAPAdmin-3
Read more »

0  

LDAP – 5. Einrichtung Openssh mit Public Key

Hier eine Anleitung zur Verwendung von Public/Private-Key Authentifizierung an OpenSSH über LDAP.

​OpenLDAP
Als erstes brauchen wir ein Schema im LDAP.
Dieses definiert die Objektklasse „ldapPublicKey“ welche uns erlaubt das Attribut „sshPublicKey“ nutzen zu können.
Read more »

0  

LDAP – 4. PAM mit OpenLDAP

Hier nun eine Anleitung für Debian zur Benutzer-Authentifizierung mit libpam über LDAP.

Zuerst die benötigten Debian-Pakete installieren:

apt-get install libnss-ldap libpam-ldap

Read more »

0  
Unterstütze den Frickelblog!