Lua-Filter

Um das eleganter zu lösen, habe ich einen kleinen Lua-Filter geschrieben (multicolumn.lua), der automatisch jede ::: {.multicolumn}-Umgebung in den passenden #place(...)-Befehl für Typst übersetzt:

function Div(div)
  if div.classes:includes("multicolumn") then
    local typst_start = pandoc.RawBlock("typst", '#place(top+center, scope: "parent", float: true)[')
    local typst_end = pandoc.RawBlock("typst", ']')

    local result = {typst_start}
    for _, el in ipairs(div.content) do
      table.insert(result, el)
    end
    table.insert(result, typst_end)
    return result
  end
end

Den Filter aktiviere ich im YAML-Header wie folgt:

      filters:
        - multicolumn.lua

Dann kann ich im Markdown einfach folgende Struktur verwenden:

:::{.multicolumn}

| **Default** | **Left** | **Right** | **Center** | **Default** | **Left** | **Right** | **Center** |
|:-----------|:--------|---------:|:--------:|:-----------|:--------|---------:|:--------:|
| 12         | 12      | 12       | 12       | 12         | 12      | 12       | 12       |
| 123        | 123     | 123      | 123      | 123        | 123     | 123      | 123      |
| 1          | 1       | 1        | 1        | 1          | 1       | 1        | 1        |

: My span table {#tbl-span2}

:::

Das Ergebnis: Die Tabelle erscheint über beide Spalten hinweg, ganz ohne manuelle Typst-Blöcke. Das funktioniert genauso gut auch mit Bildern oder R-Code-Chunks.

Typsttabellen direkt spannen

Markdowntabellen sind in ihren Manipulationsmöglichkeiten stark eingeschränkt. Sie können z.B. kein colspan, keine Farben und keine Strichmodifikationen; Typst hingegen schon. Und so kann es bei aufwendigen Tabellen eine praktikable Lösung sein, direkt den Typst-Code zu verwenden.

Damit diese Tabelle per crossref referenziert werden kann, sollte die in Quarto integrierte Tabellenumgebung verwendet werden:

:::{#tbl-REFERENZLABEL}
```{=typst}
#table( TOLLE TYPST TABELLE )
```

BESCHRIFTUNG
:::

Die Tabelle kann jetzt per @tbl-REFERENZLABEL referenziert werden.

Damit diese aufwendig gestalteten Typsttabellen auch über beide Spalten gespannt werden, wickeln wir das Ganze in die oben erstellte .mulitcolumn Umgebung:

::::{.multicolumn}
:::{#tbl-REFERENZALBEL}
```{=typst}
#table( TOLLE TYPST TABELLE )
```

BESCHRIFTUNG
:::
::::

Viel Spass beim Coden!

Weblinks

• https://quarto.org/
• https://typst.app
• https://github.com/quarto-dev/quarto-cli/discussions/13065

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

custom word list

Die Wörterlisten liegen im Verzeichnis /usr/share/apps/kvtml/LANGUAE, wobei LANGUAGE durch den Ländercode ersetzt werden muss. Die deutschen Wörterlisten liegen also unter /usr/share/apps/kvtml/de und haben die Dateiendung .kvtml. Für jede Wörterliste existiert eine eigene .kvtml-Datei.

Die Skelettstruktur einer solchen Wörterliste sieht so aus:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE kvtml PUBLIC "kvtml2.dtd" "http://edu.kde.org/kvtml/kvtml2.dtd">
<kvtml version="2.0">
  <information>
    <generator>converter</generator>
    <title>TITEL DER LISTE</title>
    <comment>DEINE BESCHREIBUNG</comment>
  </information>

  <identifiers>
    <identifier id="0">
      <locale>de</locale>
    </identifier>
  </identifiers>
  
  <entries>
  
    <entry id="0">
      <inactive>false</inactive>
      <inquery>false</inquery>
      <translation id="0">
        <text>DEIN WORT</text>
        <comment>EIN KOMMENTAR</comment>
      </translation>
    </entry>

    </entries>
</kvtml>

• in Zeile 6 und 7 wird der Name der Liste samt einer kleinen Beschreibung angegeben. Unter diesem Namen ist die Wortliste später in KHangMan auffindbar.
• in Zeile 12 geben wir an, dass die Sprache der Liste de ist.
• Die Zeilen 18 bis 25 bilden einen Entry-Block für ein gewünschtes Wort. Dabei wird
  • in Zeile 18 eine eindeutige <entry id> angegeben (hochzählen)
  • in Zeile 22 das eigentliche Wort definiert
  • in Zeile 23 ein kurzer Hilfetext gesetzt.
• diese Entry-Blöcke müssen für jedes Wort erzeugt werden.

Für ein Statistik-Quiz könnte die vollständige Datei so aussehen:

sudo nano /usr/share/apps/kvtml/statistikquiz.kvtml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE kvtml PUBLIC "kvtml2.dtd" "http://edu.kde.org/kvtml/kvtml2.dtd">
<kvtml version="2.0">
  <information>
    <generator>converter</generator>
    <title>Statistik</title>
    <comment>Statistik</comment>
  </information>
  <identifiers>
    <identifier id="0">
      <locale>de</locale>
    </identifier>
  </identifiers>
  <entries>
    <entry id="0">
      <inactive>false</inactive>
      <inquery>false</inquery>
      <translation id="0">
        <text>Boxplot</text>
        <comment>graphische Darstellung einer metrischen Werteverteilung</comment>
      </translation>
    </entry>
    <entry id="1">
      <inactive>false</inactive>
      <inquery>false</inquery>
      <translation id="0">
        <text>Histogram</text>
        <comment>graphische Darstellung klassierter Häufigkeiten</comment>
      </translation>
    </entry>
    <entry id="2">
      <inactive>false</inactive>
      <inquery>false</inquery>
      <translation id="0">
        <text>Kausalität</text>
        <comment>ursächlicher Zusammenhang</comment>
      </translation>
    </entry>
    <entry id="3">
      <inactive>false</inactive>
      <inquery>false</inquery>
      <translation id="0">
        <text>Konfidenzintervall</text>
        <comment>Sicherheitsbereich</comment>
      </translation>
    </entry>
    <entry id="4">
      <inactive>false</inactive>
      <inquery>false</inquery>
      <translation id="0">
        <text>Korrelation</text>
        <comment>Zusammenhang (aber nicht kausal)</comment>
      </translation>
    </entry>
    <entry id="5">
      <inactive>false</inactive>
      <inquery>false</inquery>
      <translation id="0">
        <text>Regressionsgerade</text>
        <comment>Wird beschrieben mit y=a+bx</comment>
      </translation>
    </entry>
    <entry id="6">
      <inactive>false</inactive>
      <inquery>false</inquery>
      <translation id="0">
        <text>Signifikanz</text>
        <comment>liegt vor wenn p kleiner alpha ist</comment>
      </translation>
    </entry>
    <entry id="7">
      <inactive>false</inactive>
      <inquery>false</inquery>
      <translation id="0">
        <text>Standardabweichung</text>
        <comment>Wurzel aus der Varianz</comment>
      </translation>
    </entry>
    <entry id="8">
      <inactive>false</inactive>
      <inquery>false</inquery>
      <translation id="0">
        <text>Varianz</text>
        <comment>Quadrat der Standardabweichung</comment>
      </translation>
    </entry>
  </entries>
</kvtml>

Nachdem die Datei gespeichert ist, wird KHangMan gestartet.

Unten links wird die derzeit aktive Wörterliste angezeigt. In meinem Beispiel ist das “Tiere”.

Wenn man darauf klickt, kann eine andere Wörterliste ausgewählt werden. Da meine Systemsprache deutsch ist, sucht KHangMan im Ordner /usr/share/apps/kvtml/de nach validen .kvtml-Dateien.

Hier sollte - wenn alles richtig gemacht wurde - die neue eigene Liste auftauchen.

Ist diese ausgewählt, kann das Spiel beginnen.

:=)

Python-Script

Unter Umständen kann es mühsam sein, eine oder mehrere solcher .kvtml-Dateien zu erstellen und zu pflegen. Beispielsweise ist es mühselig, die entry id nachzuverfolgen, wenn ein Entry-Block zwischen bestehende Blöcke eingeschoben werden soll.

Daher hab ich mir ein kleines naives Python-Script geschrieben, welches mir die Arbeit etwas erleichtert.

Das Script nimmt eine Textdatei entgegen, und erzeugt daraus die passende .kvtml-Datei.

Für das Statistikquiz sieht die Datei so aus:

nano statistik.txt

Boxplot       graphische Darstellung einer metrischen Werteverteilung
Histogram       graphische Darstellung klassierter Häufigkeiten
Kausalität         ursächlicher Zusammenhang
Konfidenzintervall         Sicherheitsbereich
Korrelation        Zusammenhang (aber nicht kausal)
Regressionsgerade        Wird beschrieben mit y=a+bx
Signifikanz        liegt vor wenn p kleiner alpha ist
Standardabweichung       Wurzel aus der Varianz
Varianz        Quadrat der Standardabweichung

Jede Zeile repräsentiert einen Worteintrag. Zuerst kommt das gesuchte Wort, dann mindestens 2 Leerzeichen, und anschließend der Hinweistext.

Hier nun das Python-Script, welches diese Datei ausliest

nano create-wordlist.py

#!/usr/bin/env python3
import sys
import re
import xml.etree.ElementTree as ET
from xml.dom import minidom
import string

def prettify(elem):
    """Return a pretty-printed XML string for the Element."""
    rough_string = ET.tostring(elem, 'utf-8')
    parsed = minidom.parseString(rough_string)
    return parsed.toprettyxml(indent="  ")

def sanitize_filename(name):
    """Sanitize the title to create a safe filename."""
    # Entfernt alle Zeichen außer Buchstaben, Zahlen, Bindestrich und Unterstrich
    valid_chars = f"-_.() {string.ascii_letters}{string.digits}"
    sanitized = ''.join(c if c in valid_chars else '_' for c in name)
    return sanitized.replace(' ', '_') + ".kvtml"

def main():
    if len(sys.argv) < 4:
        print("Usage: python3 generate_kvtml.py input.txt title comment")
        sys.exit(1)

    input_file = sys.argv[1]
    title = sys.argv[2]
    comment = sys.argv[3]
    output_file = sanitize_filename(title)

    with open(input_file, "r", encoding="utf-8") as f:
        lines = [line.strip() for line in f if line.strip()]

    kvtml = ET.Element("kvtml", version="2.0")

    info = ET.SubElement(kvtml, "information")
    ET.SubElement(info, "generator").text = "converter"
    ET.SubElement(info, "title").text = title
    ET.SubElement(info, "comment").text = comment

    identifiers = ET.SubElement(kvtml, "identifiers")
    identifier = ET.SubElement(identifiers, "identifier", id="0")
    ET.SubElement(identifier, "locale").text = "de"

    entries = ET.SubElement(kvtml, "entries")

    for idx, line in enumerate(lines):
        parts = re.split(r'\t+| {2,}', line)
        if len(parts) != 2:
            print(f"Warning: Skipping invalid line {idx + 1}: {line}")
            continue
        text, comment_text = parts
        entry = ET.SubElement(entries, "entry", id=str(idx))
        ET.SubElement(entry, "inactive").text = "false"
        ET.SubElement(entry, "inquery").text = "false"
        trans = ET.SubElement(entry, "translation", id="0")
        ET.SubElement(trans, "text").text = text
        ET.SubElement(trans, "comment").text = comment_text

    pretty_xml = prettify(kvtml)

    with open(output_file, "w", encoding="utf-8") as f:
        f.write('<?xml version="1.0" encoding="UTF-8"?>\n')
        f.write('<!DOCTYPE kvtml PUBLIC "kvtml2.dtd" "http://edu.kde.org/kvtml/kvtml2.dtd">\n')
        f.write('\n'.join(pretty_xml.split('\n')[1:]))

    print(f"✅ KVTML-Datei wurde geschrieben: {output_file}")

if __name__ == "__main__":
    main()

Das Script wird ausführbar gemacht mittels

chmod +x create-wordlist.py

…und aufgerufen per:

./create-wordlist.py TEXTDATEI LISTENNAME BESCHREIBUNG

Im Falle des Statistikquiz lautet der Aufruf

./create-wordlist.py statistik.txt Statistik Grundbegriffe

Das Script erzeugt die Datei LISTENNAME.kvtml, also in unserem Falle Statistik.kvtml, welche alle Entry-Blöcke der Wörterliste enthält. Diese kann nun ins kvtml-Verzeichnis kopiert werden.

cp Statistik.kvtml /usr/share/apps/kvtml/de/

Viel Spass beim Ausprobieren!

Weblinks

• https://apps.kde.org/khangman/
• https://apps.kde.org/education/khangman/tutorials/khangman-addwords.pdf

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

Installation

Unter https://ollama.com/download könnt ihr Versionen für macOS, Windoof und Linux herunterladen. Unter Archlinux erfolgt die Installation per

sudo pacman -S ollama

Wenn Ollama nicht in eurem Repository vorhanden ist, könnt ihr diesen Befehl verwenden:

curl -fsSL https://ollama.com/install.sh | sh

Nach der Installation kann Ollama per systemd gesteuert werden:

sudo systemctl enable ollama.service
sudo systemctl start ollama.service

Speicherort anpassen

Um den Speicherort für die Modelle festzulegen, könnt ihr die Servicedatei /etc/systemd/system/ollama.service wie folgt anpassen (bei mir soll alles unter dem Pfad /media/SILO/Ollama abgelegt werden)

[Unit]
Description=Ollama Service
After=network-online.target

[Service]
ExecStart=/usr/bin/ollama serve
WorkingDirectory=/media/SILO/Ollama
Environment="HOME=/media/SILO/Ollama"
Environment="OLLAMA_MODELS=/media/SILO/Ollama/models"
User=ollama
Group=ollama
Restart=always
RestartSec=3

[Install]
WantedBy=default.target

Modelle installieren

Sobald Ollama gestartet ist, können die Modelle wie folgt installiert werden:

ollama pull MODELLNAME

Den MODELLNAMEN erhaltet ihr von der Ollama-Homepage https://ollama.com/search. Dort findet ihr das DeepSeek-R1-Modell unter https://ollama.com/library/deepseek-r1. Die Modelle sind jeweils in verschiedenen Varianten verfügbar, z.B. 1.5b, 7b, 14b, 70b. Hierbei handelt es sich um die Parameter, die das Modell verwendet (das b steht für Milliarden). Je kleiner die Zahl, desto “abgespeckter” ist die Version. Je größer die Zahl ist, desto krasser muss eure Hardware sein, damit das Modell nicht Tage benötigt, um zu antworten. Startet am besten mit der kleinsten Zahl, und wenn das gut läuft, dann nehmt die nächst höhere Zahl. Auf einem halbwegs aktuellem Laptop sollten die 7b-Versionen gut laufen.

Ihr installiert das konkrete Modell, indem ihr die Variante per Doppelpunkt an den MODELLNAMEN anhängt. Für DeepSeek-R1 in der Variante 7b lautet der Befehl:

ollama pull deepseek-r1:7b

Ihr könnt auch Modelle von HuggingFace verwenden, z.B. die abliterated Version von DeepSeek von huihui:

ollama pull huihui_ai/deepseek-r1-abliterated:14b

Modell benutzen

Eine Übersicht eurer installierten Modelle erhaltet ihr mittels

ollama list

NAME                                     ID              SIZE      MODIFIED       
deepseek-r1:7b                           0a8c26691023    4.7 GB    2 minutes ago     
llama2-uncensored:7b                     44040b922233    3.8 GB    53 minutes ago    
deepseek-r1:14b                          ea35dfe18182    9.0 GB    55 minutes ago    
huihui_ai/deepseek-r1-abliterated:14b    6b2209ffd758    9.0 GB    57 minutes ago 

Um eines dieser Modelle zu starten, gebt ihr ein:

ollama run MODELLNAME

Also zum Beispiel

ollama run deepseek-r1:7b

oder

ollama run huihui_ai/deepseek-r1-abliterated:14b

Der Promt startet, und ihr könnt eure Eingabe machen. Das interessante bei DeepSeek-R1 ist, dass ihr den Reasoning-Prozess verfolgen könnt. Zwischen den tags <think></think> könnt ihr mitlesen, wie das Modell “nachdenkt”.

Fazit

Ollama macht es mir super einfach, verschiedene Modelle zu installieren und zu nutzen. Und es ist echt interessant, dem “thinking” zuzuschauen.

Generell ist es sowieso immer besser, seine lokale “KI” zu befragen, statt den Datenkraken die Infos einzuwerfen.

Weblinks

• https://https://ollama.com/
• https://huggingface.co/huihui-ai/DeepSeek-R1-Distill-Qwen-14B-abliterated-v2
• https://workos.com/blog/how-to-run-deepseek-r1-locally
• https://blog.fefe.de/?ts=996bef34 (fefe initial über DeepSeek)

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

Implementationen

Stand 2025 stehen zwei Implementationen von I2P zur Verfügung:

1. i2prouter (Java suite, Standard) - benutzerfreundliche und interaktive Web-Benutzeroberfläche, welche viele Funktionen beinhaltet (z.B. E-Mail-Client, Torrent-Client, Webserver).
2. i2pd (C++, Alternative) - benötigt kein Java und kommt mit weniger Systemressourcen aus, ist dafür aber auch “nur” ein nackter Router.

yay -S i2p-bin jdk-openjdk

archlinux-java status
archlinux-java set JAVAVERSION

sudo systemctl start i2prouter.service
sudo systemctl enable i2prouter.service

sudo pacman -S i2pd

sudo systemctl start i2pd.service
sudo systemctl enable i2pd.service

i2p Webseiten (eepsites)

Ähnlich wie bei TOR können im I2P-Netz hidden services eingerichtet werden. Webseiten heissen in I2P eepsites und haben die Topleveldomain *.i2p.

Um eine solche Seite ansurfen zu können, müssen 2 Aufgaben erfüllt sein:

1. Wir benötigen einen Browser, der den Proxydienst des I2P-Routers für Webanfragen benutzt. Bei beiden Implementationen (i2prouter und i2pd) lauscht dieser Proxy auf Port http://127.0.0.1:4444. Grundsätzlich empfiehlt es sich, für die Nutzung von I2P einen eigenen Browser zu benutzen. Zumindest solltet ihr ein eigenes Browserprofil für I2P verwenden. Hierbei ist die Firefox-Extension Zero Omega Switch empfehlenswert. Ist diese installiert, kann ihr “Auto-Switch” so eingestellt werden, dass nur Anfragen an *.i2p-URLs an den Proxy weitergereicht werden. So können “normales” Web und I2P Darknet nebeneinander genutzt werden.

   Hierfür lege ich mir in den Einstellungen der Extension ein Profil “i2p proxy” an, welches auf Port 4444 verweist…

   … unter “Auto switch” wähle ich “Host wildcard” und trage das Pattern *.i2p ein. Dieses zeigt dann auf mein Profil “i2p proxy”.

2. Wir benötigen die “richtige” Adresse der Webseite. Das I2P-Netz ist dezentral organisiert. Das bedeutet, dass jede Installation ihr eigenes DNS-Adressbuch aufbauen muss. Die meisten *.i2p-Webseiten sind daher nach einer frischen Installation noch gar nicht erreichbar, weil der Router nicht weiss, welche “echte” Adresse sich hinter dem Namen verbirgt. Eine typische I2P-Adresse lautet

gOSToOvSkRewCcwl5mWXbnn1IElEBlGH92vAe0TI8C-Z4tC1DVMNdNlcnUTRcB7znjFTP0vQ42dIDs1dN2Co1kSJ~nXaef4QUS-Ou5kDogPLwJxI1Hj0djktSLKWJSL40FdQvWZ1rwQ7dnaRSyOm8lrgo~HbVlh682CM1JHmEGapQaYiF6zaP4uOpeTFlkk6wEYevQ3Pn4pctJD4XElVLrS2slEsbzim3O5FzFrIVYyskEbnpyMpyffwvsq0R~RF6bhDhQ15rAmJuju91WZ8iUlORQKipougCwBP9DxQ5zdXQWxxhSJ~h604dKhxncetl0skdErLHjwhSI2gl4o66juP9wsjaczBZo4RSil2uWMWApMgvan~9FSRtxriI5f6-X2fTopWa9KlUwMCBTiqYAy9bIdVVhS-xSdFhM~IGPEZ-rlIscdb3Z5Gh1osoO-~SglUcOpj7E-8XjjvsmLkUu9VBxscdD4p3aiyaHGSljkd3WPvlfaOBmqejqEgEWwqBQAEAAEAAA==

Solche Adressen sind jedoch viel zu lang und unpraktisch. Daher wird ein Hashwert aus der Adresse generiert, über den die Seite einfacher aufgerufen werden kann – die sogenannte b32-Adresse. Im obigen Beispiel lautet die entsprechende b32-Hash-Adresse:

http://nytzrhrjjfsutowojvxi7hphesskpqqr65wpistz6wa7cpajhp7a.b32.i2p/

Dies ist schon eher handlebar und ähnelt den *.onion-Adressen des TOR-Netzes. Wenn ihr diese Adresse in euren Browser eingebt, könnt ihr die Seite direkt ansurfen. Schöner wäre natürlich, wenn die Seite über eine “menschenlesbare” Adresse erreichbar wäre, z.B. http://notbob.i2p/. Um dies zu erreichen, muss ein lokaler DNS-Eintrag im Adressbuch des eigenen I2P-Routers erfolgen. Hierfür stehen im I2P-Netz so genannte “Helperlinks” zur Verfügung, die das Eintragen vereinfachen. Um die URL notbob.i2p mit der Adresse nytzrhrjjfsutowojvxi7hphesskpqqr65wpistz6wa7cpajhp7a.b32.i2p zu verknüpfen, könnt ihr einfach diesem Link folgen:

http://notbob.i2p/?i2paddresshelper=nytzrhrjjfsutowojvxi7hphesskpqqr65wpistz6wa7cpajhp7a.b32.i2p.

Adressbuch

Die Adresse für notbob.i2p kann so im Adressbuch gespeichert werden.

(bitte nicht wundern, warum im Screenshot “produnis.i2p” steht. Ich recycle das Bild von weiter unten…)

Dabei besteht das Adressbuch aus 3 Teilen:

1. Router Adressbuch
2. Lokales Adressbuch
3. Privates Adressbuch

Alle Bücher können über das Webinterface unter http://127.0.0.1:7657/dns eingesehen werden.

http://i2p-projekt.i2p/hosts.txt
http://identiguy.i2p/hosts.txt
http://notbob.i2p/hosts.txt
http://reg.i2p/hosts.txt
http://skank.i2p/hosts.txt
http://stats.i2p/cgi-bin/newhosts.txt

E-Mail

Unter dem Link http://127.0.0.1:7657/webmail ist der Mail-Client SusiMail erreichbar. In I2P lauten die Standardmailadressen USERNAME@mail.i2p. Ihr könnt euch beliebig viele Mailadressen kostenlos anlegen. Klickt dafür auf “Konto anlegen” oder folgt dem Link http://hq.postman.i2p/?page_id=16. Die Adresse von postman.i2p ist bereits im Router-Adressbuch gespeichert, sofern ihr die oben genannten Dienst abonniert habt.

Torrent

Mit I2Psnark steht euch unter http://127.0.0.1:7657/torrents ein Torrent-Client zur Verfügung. Das Datenverzeichnis liegt standardmäßig unter /opt/i2p/.i2p/i2psnark/. Wenn ihr in dieses Verzeichnis eine Torrentdatei ablegt, wird sie automatisch dem Client hinzugefügt. Natürlich geht das auch über das Webinterface.

Der bekannteste Tracker ist unter https://tracker2.postman.i2p/ erreichbar. Die Seite steht dauerhaft unter “heavy use”, weshalb es sein kann, dass ihr zwei bis drei Anläufe nehmen müsst, um draufzukommen. Dies gilt generell für alle eepsites: wenn sie mal nicht erreichbar ist, wartet einfach 60 Sekunden und versucht es erneut. Dabei wird ein neuer Verbindungstunnel aufgebaut, und die Seiten sind dann meist erreichbar.

Ich habe bei mir noch die Bandbreit für die Torrents angepasst. Klickt hierfür auf der Torrentseite unten auf “Konfiguration”. Meine Bandbreite für Uploads habe ich auf 2048, und für Downloads auf 4096 Kbps gestellt.

Das I2P-Netz ist eher langsam, so dass es eine Zeit dauert, bis größere Torrents vollständig sind, aber: steter Tropfen höhlt den Stein.

mktorrent -a http://tracker2.postman.i2p/announce.php -o MeineDaten.torrent MeineDaten

mktorrent -a http://tracker2.postman.i2p/announce.php -o grSchlarmann2024--Angewandte-Uebungen-in-R.torrent grSchlarmann2024--Angewandte-Uebungen-in-R.pdf

# kopieren
sudo cp grSchlarmann2024* /opt/i2p/.i2p/i2psnark/

# Rechte anpassen
sudo chown i2p:i2p -R /opt/i2p/.i2p/i2psnark/*

Webserver

Ebenfalls enthalten ist der Webserver Jetty, mit welchem ihr eure eigene eepsite bereitstellen könnt. Am besten eigenen sich hierfür statische Seiten, die z.B. mittels HUGO gebaut wurden.

Legt zunächst eure HTML-Dateien samt Zubehör in den Ordner /opt/i2p/.i2p/eepsite/docroot/.

Im Webinterface findet ihr den Eintrag “Versteckte Dienst verwalten” unter http://127.0.0.1:7657/i2ptunnelmgr. Dort seht ihr unter “I2P Versteckte Services” den Eintrag “I2P webserver”. Klickt darauf, um die grundlegenen Informationen eurer eepsite anzugeben. Bei mir sieht das so aus:

Jetzt muss der Webserver an zwei Stellen aktiviert werden. Geht zunächst nach http://127.0.0.1:7657/config und wählt dort den Reiter “Teilnehmer”.

Hier muss der Startknopf gedrückt werden. Optional könnt ihr den Haken setzen, so dass der Server beim Neustart automatisch mitgestartet wird.

Nun läuft der Webserver Jetty, aber der I2P-Tunnel zum Webserver ist noch nicht aktiviert. Klickt hierfür wieder auf http://127.0.0.1:7657/i2ptunnelmgr und dort auf den Start-Knopf.

Der Status sollte nun von rot auf grün welchseln.

Ebenfalls wurde ein Helperlink erzeugt, der nun fleissig weiterverteilt werden kann. Bei mir lautet der klassische I2P-DNS-Dreisatz: http://produnis.i2p/ (b32) (Helper)

Speichert mich gerne in euer lokales Adressbuch :-)

Ich wünsche euch viel Spaß beim Ausprobieren und Herumexperimentieren. Eine echt coole Seite ist übrigens http://i2puzzle.i2p/ (helper), falls ihr gerne Rätsel löst…

Weblinks

• https://de.wikipedia.org/wiki/I2P
• https://geti2p.net/de/
• https://i2pd.website/
• https://www.youtube.com/watch?v=95hSAMEwrlM
• https://github.com/zero-peak/ZeroOmega
• https://wiki.archlinux.org/title/I2P

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

Vorteile von Typst gegenüber LaTeX

• Es ist unglaublich schnell! Typst ist in Rust geschrieben und verwendet inkrementelle Kompilierung, was schnellere Kompilierungszeiten ermöglicht. Selbst bei einfachen einseitigen Dokumenten ist es spürbar schneller als LaTeX.
• Es ist direkt in Quarto enthalten und muss nicht zusätzlich installiert werden.
• Die Syntax ist (ein wenig :-) ) einfacher als bei LaTeX.
• Die Fehlermeldungen sind aussagekräftiger als bei LaTeX.

Nachteile

• LaTeX kann viel mehr als Typst.
• Typst ist noch relativ neu, es kann noch nicht alles. Es hat nichtmals einen Wikipediaeintrag (Stand 11/2024).
• Falls ihr euch von “KI” inspirieren lassen wollt: ChatGTP und Co. können Typst quasi gar nicht und erzeugen großen Müll-Code.

PDF-Dokumente

Seit Jahrzehnten (ja, ich bin alt) verwende ich LaTeX. Mittlerweile erzeuge ich alle meine Dokument mit Quarto, aber immerhin habe ich meine schönsten LaTeX Vorlagen in Quarto-Extensions ausgelagert, so dass ich sie “unter der Haube” immer noch verwende (siehe z.B. diesen Blogpost). Das funktioniert sehr gut, und eigentlich bin ich auch zufrieden damit.

Dennoch habe ich einfach mal aus Spaß Typst ausprobiert, und vor allem die Geschwindigkeit des rendering hat mich sehr begeistert. Meine LaTeX Dokumente benötigen mindestens 2 (manchmal sogar 3) LaTeX-Läufe, die für sich schon relativ lange brauchen, um durchzulaufen. Typst hingegen ist nach einem Lauf fertig, und dieser Lauf ist einfach unglaublich schnell.

Also habe ich auf den Bahnfahrten angefangen, meine LaTeX-Extensions um Typst zu erweitern.

Eine Quarto Extension erstellen

Um eine neue Extension zu erstellen folge ich grob der Anleitung auf der Quarto Webseite.

Für meine Extensions habe ich ein eigenes Verzeichnis. Per Terminal wechsel ich in dieses Verzeichnis und starte dort ein neues Extensionprojekt mit dem Befehl

Terminal

$ quarto create extension format

Nun wähle ich typst aus der Auswahlliste und gebe erneut den Namen der Extension (foobar) ein. Anschließend kann der Ordner z.B. mit vscodium geöffnet werden.

Ich bearbeite die Dateien nicht in RStudio, da dort kein Syntax Highlighting für Typst angeboten wird. Ich nutze Positron, aber grundsätzlich geht es natürlich mit jedem Texteditor.

In meinem Ordner liegt nun ein neues Verzeichnis foobar, und in diesem sind die folgenden Dateien und Verzeichnisse zu finden:

Dateistruktur im Ordner foobar

template.qmd
README.md
_extensions/
_extensions/foobar/
_extensions/foobar/_extension.yml
_extensions/foobar/typst-show.typ
_extensions/foobar/typst-template.typ

Die Dateien sind bereits mit Standardinhalt befüllt, so dass die die Datei template.qmd direkt gerendert werden kann. Probiert es mal direkt aus!

Schaut euch die generierten Dateien an:

• template.qmd - Das Dokument, welches gerendert werden soll.
• README.md - Eine README-Datei mit allen Infos zur Extension.
• _extensions/ - Hier liegen alle Extensions, auf die template.qmd zugreifen kann.
• _extensions/foobar/ - Hier liegt unsere Extension.
• _extensions/foobar/_extension.yml - Hier geben wir die Metadaten unserer Extension (Name, Autor, Beschreibung, etc.) an, sowie die bereitsgestellten Formate nebst Standardparameter
• _extensions/foobar/typst-show.typ - Diese Datei ruft unser eigentliches Template auf. Hier können zudem Pandoc-Metadaten an Funktionsparameter gemappt werden.
• _extensions/foobar/typst-template.typ - Unsere eigentliche Templatedatei.

Für mich als Autodidakt war es herausfordernd, die Typst-Syntax zu lernen. Eine sehr wichtige Nachschlageseite hierfür ist https://typst.app/docs/. Die Standardinhalte von typst-show.typ und typst-template.typ haben mich zunächst stark verwirrt, so dass ich in diesem Blogbeispiel mit leeren .typ-Dateien anfangen möchte.

typst-show.typ

#show: foobar.with(

)

typst-template.typ

#let foobar(
  // Welche Werte erwartet mein Template?
  body
) = {
  // Hier beginnt die Ausgabe
  body
}

typst-template.typ

#let foobar(
  // Welche Werte erwartet mein Template?
  body
) = {
  // Hier beginnt die Ausgabe
  
  // title anzeigen
  text(36pt)[$title$]
  
  body
}

typst-show.typ

#show: foobar.with(
  meintitel: "$title$",
)

typst-show.typ

#show: foobar.with(
  $if(title)$
    meintitel: "$title$",
  $endif$
)

typst-template.typ

#let foobar(
  // Welche Werte erwartet mein Template?
  meintitel: none,
  body
) = {
  // Hier beginnt die Ausgabe
  
  // title anzeigen
  text(36pt)[#meintitel]
  
  body
}

typst-template.typ

#let foobar(
  // Welche Werte erwartet mein Template?
  meintitel: "Du hast den Titel vergessen",
  body
) = {
  // Hier beginnt die Ausgabe
  
  // title anzeigen
  text(36pt)[#meintitel]
  
  body
}

_extension.yml

title: Foobar
author: Joe Slam
version: 1.0.0
quarto-required: ">=1.5.0"
contributes:
  formats:
    typst:
      logo: MeinLogo.png
      template-partials:
        - typst-template.typ
        - typst-show.typ

Dateistruktur im Ordner foobar

template.qmd
README.md
_extensions/
_extensions/foobar/
_extensions/foobar/_extension.yml
_extensions/foobar/typst-show.typ
_extensions/foobar/typst-template.typ
_extensions/foobar/MeinLogo.png

typst-show.typ

#show: foobar.with(
  $if(title)$
    meintitel: "$title$",
  $endif$
  $if(logo)$
    logo: "$logo$",
  $endif$
)

typst-template.typ

#let foobar(
  // Welche Werte erwartet mein Template?
  meintitel: "Du hast den Titel vergessen",
  logo: none,
  body
) = {
  // Hier beginnt die Ausgabe

  // Logo-Pfad escapen
  let logo_path = logo.replace("\\", "")
  // Logo anzeigen
  image(logo_path, width: 70mm)

  // title anzeigen
  text(36pt)[#meintitel]

  body
}

Beispiel

Herausgekommen ist beispielsweise diese simple Extension, die ich für Aushänge an der Hochschule nutze. Sie nimmt die Parameter title und logo entgegen. In der Kopfzeile wird rechts das Logo ausgegeben, und links ein schöner blauer Kasten mit dem title in weißer Schrift.

In unserer foobar-Extension müssen die Dateien wie folgt geändert werden:

_extension.yml

title: Foobar
author: Joe Slam
version: 1.0.0
quarto-required: ">=1.5.0"
contributes:
  formats:
    typst:
      logo: MeinLogo.png
      lang: de
      font: "Times New Roman"
      font-size: 12pt
      template-partials:
        - typst-template.typ
        - typst-show.typ

typst-show.typ

#show: foobar.with(
    // Diese Werte kommen aus dem YAML
    title: "$title$",
    lang: "$lang$",
    logo: "$logo$",
    font: "$font$",
    font-size: $font-size$,
)

typst-template.typ

#let foobar(
  // welche Wert werden aus dem YAML-Header gelesen?
  title: none,
  logo: none,
  lang: none,
  font: none,
  font-size: none,
  body
) = {

  // Hier startet die eigentliche Funktion

  // Der Logo-Pfad muss escaped werden
  let logo_path = logo.replace("\\", "")

  // Schriftart und Sprache einstellen
  set text(font: font,
           size: font-size,
           lang: lang,)
  // Blockschrift aktivieren
  set par(justify: true)
  
  // Farben definieren
  let HSNRblue1 = rgb("185191")
  let HSNRblue2 = rgb("07A1E2")

  // Seitengröße und -ränder festlegen
  set page(width: 210mm,
           height: 297mm,
           margin: (top: 30mm, bottom: 30mm, left: 20mm, right: 20mm),
           numbering: "1",
           number-align: center,
           // Kopfzeile
           header: grid(
                        columns: (1fr, 1fr),
                        align: (left, right),
                          rect(fill: HSNRblue1,
                               width: 70%,
                               outset: (x: 54pt))[#text(white, 18pt)[#title]],
                          image(logo_path, width: 70mm),
           ),
           // Fußzeile
           footer: align(center)[#context counter(page).display("1 von 1",both: true,)]
  )

  // Abstand zwischen Header und Body
  v(5mm)

  // Hauptteil des Dokuments
  body
}

Das sieht dann so aus:

Zudem habe ich meine quarto-letter-Extension auf typst angepasst und bei Github veröffentlicht, siehe https://github.com/produnis/quarto-letter.

Weblinks

• https://typst.app/docs
• https://quarto.org/docs/output-formats/typst.html
• https://quarto.org/docs/output-formats/typst-custom.html
• https://qwinsi.github.io/tex2typst-webapp/
• https://www.produnis.de/blog/posts/2022-09-12-quarto-briefvorlage/
• https://nrennie.rbind.io/blog/pdf-quarto/making-pdf-with-quarto-typst-latex/
• https://typst.app/docs/guides/guide-for-latex-users/
• https://github.com/quarto-dev/quarto-cli/discussions/11364
• https://github.com/quarto-dev/quarto-cli/discussions/11392
• https://github.com/produnis/quarto-letter

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

eigene Hexsticker erzeugen

In R gibt es dafür ein eigenes Paket, das {hexSticker} heisst.

# Paket installieren
install.packages("hexSticker", dependencies = TRUE)

Der grundlegende Aufruf lautet

sticker(BILD, package="PAKETNAME", filename="Sticker.png")

Dabei kann das Aussehen über mehrere Parameter verändert werden:

• s_x, s_y Position des Bildes

• s_width, s_height Größe des Bildes

• p_x, p_y Position des Paketnamens

• p_color, p_family, p_fontaface, p_size Texteigenschaften des Paketnamens

• h_fill, h_color Rahmen- und Füllfarben des Hexagon

• h_size Größe des Hexagon

• url optionale Webadresse

• u_x, u_y Position der URL

• u_color, u_family, u_angle, u_size Texteigenschaften der URL

Das BILD kann ein R-Plot oder eine Bilddatei sein.

Für mein R-Buch habe ich so folgenden Sticker erzeugt:

library(hexSticker)
library(ggplot2)
# lade Daten
load(url("https://www.produnis.de/R/data/epa.RData"))

# plotten
titelbild <- ggplot(epa) +
  aes(x=age) +
  geom_histogram(aes(y=after_stat(density)),
                 color="white", lwd=0.3,
                 fill="#8a658a") +
  stat_density(geom="area",
               color="blue",
               fill="seagreen3",
               linetype="dotted",
               alpha=0.5)+
  stat_function(fun=dnorm,
                args=(c(mean=mean(epa$age),sd=sd(epa$age))),
                color = "red",
                linetype = "dashed") +
  theme_void()
#----------------------------------------------------------------------

# Sticker erzeugen
sticker(titelbild, package="jgsbook", 
        p_color="white", p_x=0.7, p_size=20,
        s_x=1.05, s_y=1.06, s_width=1.5, s_height=1.4,
        h_fill="#07A1E2", h_color="#185191",
        url="produnis.de/R", u_size=5, u_color="white",
        filename="jgsbook.png")

Und auch mein trainingslageR hat bereits einen Hexsticker. Hierfür habe ich allerdings das Hintergrundbild mit GIMP vorbereitet und dann “nur” eingelesen.

sticker("trainingslageR-Vorlage2.png", 
        package="t", p_color="white", p_x=0.7, p_size=0.001,
        s_x=1, s_y=1, s_width=1.02, s_height=1.02,
        h_fill="white", h_color="#185191",
        url="github.com/produnis/trainingslager", 
        u_size=4.2, u_color="white", u_y=0.06,
        filename="trainingslageR-hexsticker.png")

Weblinks

• https://github.com/GuangchuangYu/hexSticker

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

Weblinks

• https://discuss.kde.org/t/logout-reboot-and-shutdown-using-the-terminal/743/9

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

Weblinks

• https://a.hollywood.computer/
• https://snapcraft.io/install/hollywood/ubuntu

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

iFrame einbinden

• Im Verzeichnis der .qmd-Datei erstellt ihr einen weiteren Unterordner, und nennt ihn z.B. iframes.
• Ladet ein passendes iframe herunter, z.B. von der GitHub-Seite von Emil Hvitfeldt.
• Den Ordner des iframes schiebt ihr in euren iframes-Ordner.
• Hinter die Rauten einer neuen Folie schreibt ihr {background-iframe="Pfad/zur/index.html"}, also z.B.

## title {background-iframe="iframes/meatballs/index.html"}

• Im YAML-Header muss zudem der Parameter preload-iframes: true gesetzt werden.
• Eine Beispieldatei könnte so aussehen:

---
title: "iframe backgrounds"
preload-iframes: true
format:
  revealjs:
    embed-resources: true
---

## {.center .white background-iframe="iframes/ambient/index.html"}
::: {.r-fit-text}
Ambient
:::

## {.center background-iframe="iframes/moving-waves/index.html"}
::: {.r-fit-text}
Moving Waves
:::

Das sieht dann in etwa so aus:

(es kann uU etwas dauern, bis der Hintergrund sichtbar ist. Das ist lokal in der “echten” Präsentation aber nicht der Fall)

Nachteil

Einen Nachteil habe ich ebenfalls festgestellt: da die Hintergründe per iframe eingebunden werden, sind sie in der HTML-Präsentationsdatei selbst nicht enthalten, auch nicht, wenn der Parameter embed-resources: true gesetzt ist. Das heisst, man kann die Präsentationsdatei nicht “einfach so” weitergeben, weil dann die animierten Hintergründe nicht mehr funktionieren.

Wenn die Präsentation mittels decktape in eine PDF-Datei umgewandelt wird, bleibt ein Screenshot des Hintergrunds erhalten.

Weblinks

• https://emilhvitfeldt.github.io/quarto-iframe-examples/
• https://github.com/EmilHvitfeldt/quarto-iframe-examples
• https://quarto.org
• https://github.com/astefanutti/decktape

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

Paarweise Chiquadrat-Tests

Ich habe aus edukativen Gründen eine Funktion programmiert, die dennoch paarweise Chiquadrat-Tests durchführt.

Durch die Mehrfachvergleiche (multiples Testen) entsteht das erhöhte Risiko von falsch-positiven Ergebnissen (Typ-I-Fehler). Bei unserer Funktion müssen wir das Problem der Mehrfachtestung berücksichtigen. In Zeile 50 übergeben wir die berechneten p-Werte der p.adjust()-Funktion, und korrigieren die Werte mit dem gewünschten Verfahren (standardmäßig bonferroni).

pairwise.chisq.test <- function(A, B, p.adjust.method="bonferroni"){
  
  # wir überprüfen, ob die Objekte vom Typ factor sind.
  if (!is.factor(A) | !is.factor(B)) {
    stop("Both objects need to be factors.")
  }

  # erstelle ein Hilfsdatenframe
  df <- data.frame(A=A, B=B)

  # Erzeuge alle möglichen 2er-Kombinationen von B
  kombi <- combn(levels(B), 2)

  # Erzeuge ein Datenframe für die Werterückgabe
  # die erste Zeile wird später wieder gelöscht.
  result <- data.frame(group1 = "A",
                       group2 = "B",
                       xsquare = "9",
                       df = "9999",
                       pvalue = "9",
                       padjust = "9",
                       adjust = p.adjust.method,
                       sig = "")

  # Berechne für jedes Paar
  for (i in 1:(length(kombi)/2)) {
    # füge die aktuelle Paarung in einem Datenframe zusammen
    help <- rbind(df[df$B==kombi[,i][1],],
                  df[df$B==kombi[,i][2],])
    # führe den Chi-Quadrat-Test durch
    pups <- chisq.test(help$A, help$B)
    
    # setze das Signifikanz-Signal zurück
    sig = ""
    
    # setze einen Punkt wenn p < 0.055
    if(p.adjust(as.numeric(pups$p.value), method = p.adjust.method, n=(length(kombi)/2)) < 0.055) {sig="."}
    # setze einen Stern wenn p < 0.05
    if(p.adjust(as.numeric(pups$p.value), method = p.adjust.method, n=(length(kombi)/2)) < 0.05)  {sig="*"}
    # setze zwei Sterne wenn p < 0.01
    if(p.adjust(as.numeric(pups$p.value), method = p.adjust.method, n=(length(kombi)/2)) < 0.01)  {sig="**"}
    # setze drei Sterne wenn p < 0.001
    if(p.adjust(as.numeric(pups$p.value), method = p.adjust.method, n=(length(kombi)/2)) < 0.001) {sig="***"}
    # speichere die Ergebnisse in ein Datenframe
    loop <- data.frame(group1 = kombi[,i][1],
                       group2 = kombi[,i][2],
                       xsquare = as.numeric(pups$statistic),
                       df = as.numeric(pups$parameter),
                       pvalue = as.numeric(pups$p.value),
                       padjust = p.adjust(as.numeric(pups$p.value), method = p.adjust.method, n=(length(kombi)/2)),
                       adjust = p.adjust.method,
                       sig = sig
    )
    # füge die aktuellen Ergebnisse dem "result"-Objekt hinzu
    result <- rbind(result, loop)
  }
  # Fertig mit allen Paarungen
  
  # Entferne den Dummy-Eintrag 
  result <- result[-1,]
  # Korrigiere die Zeilennummerierung
  row.names(result) <- NULL
  # Gebe die Ergebnisse zurück
  return(result)
}
#----------------------------------------------------------------------#

Die Funktion nimmt folgende Parameter entgegen:

• A: die erste Variable, ein Faktor, welche die Zieldaten enthält (z.B. Geschlecht)
• B: die zweite Variable, ein Faktor, welcher die Gruppeneinteilung enthält (z.B. Ort)
• p.adjust.method: die Methode zur Alphafehler-Korrekur, standardmäßig “bonferroni”, es gehen aber auch “alle anderen”, wie zB holm oder hochberg.

Als Ergebnis liefert uns die Funktion ein Datenframe zurück, mit den Einträgen:

• Name von Gruppe 1
• Name von Gruppe 2
• Teststatistik (xsquare)
• Freiheitsgrade (df)
• p-Wert des Chi-Quadrat-Test
• adjustierter p-Wert (nach gewählter Methode)
• die gewählte Methode zur p-Wert-Adjustierung
• Signifikanz-Signal für die adjustierten p-Werte (., *, **, ***)

Beispiel

Als Beispiel untersuchen wir im Datensatz pf8, ob sich die Geschlechter je nach Standort unterscheiden.

# verwende pf8 Datensatz
load(url("https://www.produnis.de/R/data/pf8.RData"))

# führe exakten Test durch
pairwise.chisq.test(pf8$Geschlecht, pf8$Standort)

      group1    group2           xsquare df               pvalue              padjust     adjust sig
1     Rheine   Münster  1.10471703224467  2     0.57559066836014                    1 bonferroni    
2     Rheine      Bahn 0.484729064039409  2    0.784770051592051                    1 bonferroni    
3     Rheine Ladbergen  3.82435691920203  2    0.147758150572077                    1 bonferroni    
4     Rheine  Internet  14.0768553245862  2 0.000877505212656076  0.00877505212656076 bonferroni  **
5    Münster      Bahn                 0  1                    1                    1 bonferroni    
6    Münster Ladbergen  3.97980963867552  1   0.0460487671171598    0.460487671171598 bonferroni    
7    Münster  Internet   8.4878079618588  1  0.00357534323663839   0.0357534323663839 bonferroni   *
8       Bahn Ladbergen  2.85957778936492  1   0.0908313368796546    0.908313368796546 bonferroni    
9       Bahn  Internet  5.76636469124268  1   0.0163357933303218    0.163357933303218 bonferroni    
10 Ladbergen  Internet  16.0075693112762  1 6.30897415058098e-05 0.000630897415058098 bonferroni ***

Es ist zu erkennen, dass sich die Geschlechterverteilungen zwischen den Standortvergleichen Internet-Rheine, Internet-Münster und Internet-Landbergen unterscheiden.

reporttools::pairwise.fisher.test(pf8$Geschlecht, 
                                  pf8$Standort, 
                                  p.adjust.method = "bonferroni")

    Pairwise comparisons using 

data:  pf8$Geschlecht and pf8$Standort 

          Rheine  Münster Bahn    Ladbergen
Münster   1.00000 -       -       -        
Bahn      1.00000 1.00000 -       -        
Ladbergen 1.00000 0.40161 0.64522 -        
Internet  0.00292 0.02852 0.13207 0.00065  

P value adjustment method: bonferroni 

Weblinks

• https://www.produnis.de/R/schliessende-statistik.html#sec-posthocsig
• https://cran.r-project.org/web/packages/jgsbook/index.html

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

ddclient

ddclient ist ein Perl-Client, der dynamische DNS-Einträge für Konten vieler dynamischer DNS-Dienste aktualisieren kann. Auf der Github-Seite steht eine Liste der kompatiblen Dienste bereit, viele weitere Dienste funktionieren aber ebenfalls, da sie die selben Protokolle verwenden.

Ich nutze ddclient mit folgenden freien DynDNS-Anbietern:

• DuckDNS
• Dynv6.com
• spDYN (nimmt keine neuen User auf)

Da ich einen echten Dual-Stack habe, sollen IPv4 und IPv6 gleichzeitig aktualisiert werden.

# Ubuntu
sudo apt-get install ddclient

# Arch, btw
pacman -S ddclient

Konfiguration

[Unit]
Documentation=man:ddclient(8)
Description=Update dynamic domain name service entries
After=network-online.target
Wants=network-online.target

[Service]
Type=forking
Environment=daemon_interval=10m
EnvironmentFile=-/etc/default/ddclient
ExecStart=/sbin/ddclient -syslog -file /etc/ddclient/%I.conf -cache /var/cache/ddclient/%I.cache
Restart=on-failure

[Install]
WantedBy=multi-user.target

# externe IPv4
curl -s4 http://ifconfig.me/ip

# externe IPv6
curl -s6 http://ifconfig.me/ip

curl -s4 http://ifconfig.me/ip

curl -s6 http://ifconfig.me/ip

daemon=300                       # check every 300 seconds
syslog=yes                       # log update msgs to syslog
pid=/var/run/ddclientduckdns.pid # record PID in file.
ssl=yes                          # use ssl-support.
debug=yes                        # write to journal log
verbose=yes                      # write to journal log
usev4=cmdv4, cmdv4=/etc/ddclient/myipv4address.sh # IPv4
usev6=cmdv6, cmdv6=/etc/ddclient/myipv6address.sh # IPv6

#### DUCKDNS.org ########
#------------------------
protocol=duckdns,    # Komma muss bleiben
password=9a5dc6a5-FUCK-AFD-bbaf-foobar # ersetze dein Token
YOURNAME.duckdns.org # deinen Namen ersetzen

daemon=300                     # check every 300 seconds
syslog=yes                     # log update msgs to syslog
pid=/var/run/ddclientdynv6.pid # record PID in file.
ssl=yes                        # use ssl-support.
debug=yes                      # write to journal log
verbose=yes                    # write to journal log
usev4=cmdv4, cmdv4=/etc/ddclient/myipv4address.sh # für IPv4
usev6=cmdv6, cmdv6=/etc/ddclient/myipv6address.sh # für IPv6

#### DYNv6.com ##########
#------------------------
protocol=dyndns2
server=dynv6.com
password='sKx3hF_stPT_fuck_AfD_1rPmskxiTga' 
login=none
YOURNAME.dynv6.net

ddclient starten

Zunächst können die Einstellungen getestet werden, ohne Daten zum Server zu senden:

ddclient -daemon=0 -debug -verbose -noquiet -file /etc/ddclient/dynv6.conf

Sieht alles gut aus, können wir die Dienste wie folgt aktivieren:

# aktivieren und starten
sudo systemctl enable --now ddclient@duckdns
sudo systemctl enable --now ddclient@dynv6

# Logs ansehen
journalctl -u ddclient@duckdns -f
journalctl -u ddclient@dynv6 -f

Tolle Sache, funktioniert prima!

Weblinks

• https://github.com/ddclient/ddclient
• https://dynv6.com/
• https://www.duckdns.org
• https://wiki.ubuntuusers.de/Archiv/DDNS-Clients/
• https://wiki.archlinux.org/title/Dynamic_DNS

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

VPN

Mein Wireguard-VPN soll unter den Netzen 10.3.3.0/24 und fd04:bab0:3::/64 laufen. Alle Clients sollen sich gegenseitig sehen und anpingen können. Auf Wunsch soll der gesamte Traffic über das VPN geroutet werden.

Installation

Unter Ubuntu lässt sich Wireguard auf Server und Clients wie folgt installieren:

#Ubuntu
apt install wireguard
 
#Arch, btw
pacman -S wireguard-tools

Schlüssel erzeugen

Auf meiner Zertifikationsinstanz (oder auf jedem anderen Rechner) erstelle ich mir einen neuen Ordner und erzeuge für den Server sowie für jeden Client ein Paar aus privatem und öffentlichem Schlüssel.

sudo bash
umask 077 && wg genkey | tee server-private.key | wg pubkey > server-public.key
umask 077 && wg genkey | tee client1-private.key | wg pubkey > client1-public.key
umask 077 && wg genkey | tee client2-private.key | wg pubkey > client2-public.key
umask 077 && wg genkey | tee client3-private.key | wg pubkey > client3-public.key

Die Inhalte der Schlüsseldateien werden gleich plaintext in die Configdateien geschrieben.

Server aufsetzen

Nach der Installation existiert das Verzeichnis /etc/wireguard. In diesem Verzeichnis liegen die .conf-Dateien der VPNs, egal ob Server oder Client. Der Name der .conf-Datei entscheidet über den Namen der Interfaceschnittstelle. Benenne ich die Datei foobar.conf, so wird ein Tunneldevice mit dem Namen foobar erzeugt. Die Datei tun0.conf erzeugt ein Interface mit dem Namen tun0. Standardmäßig (also in den Manuals im Netz) werden für Wireguard wg0-Interfaces erzeugt.

Wir erzeugen also die Datei wg0.conf und geben ihr folgenden Inhalt:

# ---------- Server Config ----------
[Interface]
## welche IP4-Adresse hat der Server im Tunnel?
Address = 10.3.3.1/24

## welche IPv6-Adresse hat der Server im Tunnel?
Address = fd04:bab0:3::1/64 

# Wenn ihr iptables nutzt, dann wird hier das NAT zum Internet klargemacht
# Mein Device heisst eth0, eures auch? ansonsten ändern!
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -s 10.3.3.0/24 -o eth0 -j MASQUERADE; ip6tables -A FORWARD -i wg0 -j ACCEPT; ip6tables -t nat -A POSTROUTING -s fd04:bab0:3::/64 -o eth0 -j MASQUERADE 
# Sobald der VPN beendet wird, werden die iptables Regeln rückgängig gemacht
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -s 10.3.3.0/24 -o eth0 -j MASQUERADE; ip6tables -D FORWARD -i wg0 -j ACCEPT; ip6tables -t nat -D POSTROUTING -s fd04:bab0:3::/64 -o eth0 -j MASQUERADE

# Hier kommt der private Key des Servers hin, in Plaintext
PrivateKey = OHUJätschibätschifasfdeg92wz4CvFqlWWUW74dfgM5+zPfuEU=
# Auf welchem Port soll der Server lauschen?
# Diesen Port in der Firewall freigeben!
ListenPort = 45881 

## Für jeden Client kommt hier eine eigene Identifikation
[Peer] # Client1
# Schreibe hier den öffentlichen Schlüssel des Client1 hinein
PublicKey = AfuckAfDfejoqfooobaaarmHILbtoxReB6ZjzNuMtyYNxlM= 
# Mit welchen IP4 und IPv6-Adressen soll sich der Client verbinden?
# Hier müssen ein /32  und /128 verwendet werden (= genau 1 IP-Adresse erlaubt)
AllowedIPs = 10.3.3.2/32, fd04:bab0:3::2/128 


# Hier wiederholt sich das Ganze für Client2
[Peer] # CLient2
# Client public key
PublicKey = 1xejE9Z2OnkqkuckuckFcOsoLA623M1yRr+7/v7SmAtP36UmG8=  
# IPs client can connect as (IPv4 /32  and IPv6 /128)
AllowedIPs = 10.3.3.3/32, fd04:bab0:3::3/128 

[Peer] # Client3
# Client public key
PublicKey = sCid523sdfXwQHoErOyXyIk8UNEz36aff7+R9MIU8Xm4wc=  
# IPs client can connect as (IPv4 /32  and IPv6 /128)
AllowedIPs = 10.3.3.4/32, fd04:bab0:3::4/128 

• Der Server lauscht unter IP4 und IPv6 auf Port 45881. Ihr könnt auch irgendeinen anderen Port auswählen.
• Der Server wird unter den Adressen 10.3.3.1/24 und fd04:bab0:3::1/64 über den Tunnel ereichbar sein. Ebenso haben derzeit 3 Clients Zugriff, wobei jeder Client eine fixe IP4 und IPv6 im Tunnelnetz erhält.
• Bei den AllowedIPs ist euch sicherlich aufgefallen, dass bei IP4 ein /32 und bei IPv6 ein /128 hinter die Adresse geschrieben werden muss.
  • Auf dem Server fungiert AllowedIPs ähnlich wie ein Router und gibt an, wohin der Datenverkehr geroutet werden soll. Daher genügt die Angabe von /32 oder eben /128 (genau eine IP-Adresse).
  • In der gleich folgenden Client-Config fungiert AllowedIPs wie eine Access-Controll-List. Daher muss in der Client-Config ein /24 bzw. /64 definiert werden, um alles von 10.3.3.* bzw. fd04:bab0:3:: zu akzeptieren.
• Soll ein weiterer Client hinzugefügt werden, muss in der Server-Config ein neuer [Peer]-Block mit dem puplic key des neuen Clients hinzugefügt werden.

# Starten
systemctl start wg-quick@wg0.service
# Logs ansehen
journalctl -u wg-quick@wg0.service -f

Firewall anpassen

Falls ihr eine Firewall benutzt (und ich hoffe doch sehr, dass dies der Fall ist), muss diese für Wireguard angepasst werden. Einerseits muss der Server-Port freigegeben werden (ich habe da ja 45881), anderseits müssen wir intern NAT einrichten, wenn der Internetverkehr über den Tunnel geroutet werden soll.

## Akzeptiere Pakete von den wg+ Interfaces
iptables -A INPUT -i wg+ -j ACCEPT
iptables -A FORWARD -i wg+ -j ACCEPT

## auf dem Server muss Port 45881 tcp/udp geöffnet werden
iptables -A INPUT -i eth0 -p tcp --dport 45881 -j ACCEPT
iptables -A INPUT -i eth0 -p udp --dport 45881 -j ACCEPT

sudo ufw allow 45881

nano /etc/default/ufw 

DEFAULT_FORWARD_POLICY="ACCEPT"

nano /etc/ufw/before.rules

# NAT-Tabelle hinzufügen
*nat
:POSTROUTING ACCEPT [0:0]
# OpenVPN-Regeln hinzufügen
-A POSTROUTING -s 10.3.3.0/24 -o eth0 -j MASQUERADE
COMMIT

nano /etc/ufw/before6.rules

# NAT-Tabelle hinzufügen
*nat
:POSTROUTING ACCEPT [0:0]
# OpenVPN-Regeln hinzufügen
-A POSTROUTING -s fd04:bab0:3::/64 -o eth0 -j MASQUERADE
COMMIT

nano /etc/ufw/sysctl.conf

net/ipv4/ip_forward=1
net/ipv6/conf/default/forwarding=1
net/ipv6/conf/all/forwarding=1

Client einrichten

Auf den Clients erzeugen wir ebenfalls die Datei /etc/wireguard/wg0.conf und geben ihr diesen Inhalt:

# -------- Client Config ------------------
[Interface]
# IP4 Adresse des Clients, so wie in der Server-Config angegeben (/32!)
# Dieser Client bekommt 10.3.3.2
Address = 10.3.3.2/32 
# IPv6 Adresse des Clients (use /128!)
# Dieser Client bekommt fd04:bab0:3::2
Address = fd04:bab0:3::2/128 
# Der Private Key von Client1 im Plaintext
PrivateKey = GNJJAJT0MQnxRHga8Rzp/hLGoCtsefljhelahDks6EMD8Vw= 


[Peer]
# Wie ist der Server erreichbar? Adresse und Port
#Endpoint = [2a02:08:15:4500:fckafd:4]:45881
#Endpoint = 192.168.0.1:45881
Endpoint = vpn.myserver.org:45881

# Der öffentliche Schlüssel des Servers im Plaintext
PublicKey = emV/wFCKAFD4WIyakB/JEi7jp9wH7zBCi81W+qjuMkWc= 

# Sende alle x Sekunden einen Ping an das Netz 
# um den Tunnel aufrecht zu erhalten. 
# Sollte NIE auf dem Server gesetzt werden, 
# sondern nur dort, wo auch "Endpoint" definiert ist. 
# Also hier im Client...
PersistentKeepalive = 5

# Was soll durch den Tunnel geroutet werden?
## Option 1: nur Tunnelkrams durch den Tunnel routen
AllowedIPs = 10.3.3.0/24, fd04:3::/64 
## Option 2: ALLES durch den Tunnel routen
#AllowedIPs = 0.0.0.0/0, ::/0 

• Diese Datei muss ich nun bei jedem Client nach dem selben Muster anlegen.
• Der Client erhält seine fest IP4 und IPv6 über den Tunnel
• Dieses Mal müssen unter Address jeweils ein /32 bzw /128 vergeben werden (= 1 IP Adresse).
  • Der Parameter AllowedIPs fungiert im Clientmodus wie eine Access-Controll-List. Daher wird an dieser Stelle wieder ein /24 bzw. /64 definiert, um alles von 10.3.3.* bzw. fd04:bab0:3:: über den Tunnel zu routen.
• Soll der gesamte Datenverkehr über den VPN-Tunnel geroutet werden, muss die zweite AllowedIPs-Zeile aktiviert (und die darüberstehende auskommentiert) werden.

Android

Für mein Handy erstelle mich mir wie oben beschrieben ein Schlüsselpaar und generiere mir eine Clientconfig wie oben, wobei ich die zweite AllowedIPs-Option wähle (alles übers VPN routen). Diese wg0.conf übertrage ich per KDE Connect auf mein Handy.

Als App installiere ich mittels F-Droid WG Tunnel von Zane Schepke, da die Original-Wireguard-App Ende 2023 aus dem F-Droid-Repository geflogen ist (weil sie einen integrierten Aktualisierer bekommen hat, der standardmäßig aktiviert ist und nicht transparent angibt, von wo aus er Aktualisierungen herunterlädt; noch fragt er um Zustimmung).

Jetzt kann ich einfach die übertragene wg0.conf-Datei in der App importieren, und alles funktioniert bestens. Ok, in den App-Einstellungen musste ich noch “Tunnel on untrusted wifi” und “Tunnel on mobile data” aktivieren, dann hat es aber sofort funktioniert.

Weblinks

• https://www.wireguard.com/
• https://www.timoschindler.de/tag/arch-linux/
• https://github.com/zaneschepke/wgtunnel
• https://git.zilium.de/-/snippets/8
• https://android.stackexchange.com/questions/254262/why-isnt-wireguard-available-on-f-droid
• https://requestforcomments.de/archives/682

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

IPv6

Mein Heimserver, der die VPNs aufbaut, ist sowohl per IPv4 als auch per IPv6 erreichbar. Da das Mobilnetz an Handy und Tablet fast ausschließlich IPv6 nutzt, ist es eine gute Idee, auf beiden Netzen zu lauschen. Damit der openVPN-Server sowohl per IPv4 als auch per IPv6 auf Anfragen antwortet, ändere ich in der Server-Config die Stelle

proto udp

auf

proto udp6

proto udp6
multihome

server-ipv6 fd04:bab0::/64        # ULA IPv6 Subnetz für OpenVPN-Clients
push "route-ipv6 fd04:bab0::/64"  # ULA IPv6 Subnetz an die Clients weitergeben

ifconfig-ipv6-push fd04:bab0::xyz/64

IPv6 Internet durch den Tunnel routen

Damit auch das globale IPv6-Internet durch den Tunnel geroutet werden kann, müssen die Firewallregeln angepasst werden.

# iptables
ip6tables -t nat -D POSTROUTING -s fd04:bab0::/64 -o eth0 -j MASQUERADE

nano /etc/ufw/before6.rules

# NAT-Tabelle hinzufügen
*nat
:POSTROUTING ACCEPT [0:0]
# OpenVPN-Regeln hinzufügen
-A POSTROUTING -s fd04:bab0::/64 -o eth0 -j MASQUERADE
COMMIT

Zertifikate erstellen

Damit Handy und Tablet das VPN nutzen können, benötigen sie wieder gültige Zertifikate und den ta.key des VPNs (siehe letzter Blogpost).

Dazu wechsle ich auf meine Zertifikationsinstanz und erstelle wie gewohnt Zertifiakte für Handy und Tablet, z.B. so:

sudo bash
cd /etc/easy-rsa
easyrsa gen-req handy nopass
easyrsa sign-req client handy

easyrsa gen-req tablet nopass
easyrsa sign-req client tablet

openssl pkcs12 -export -in CERT -inkey KEY -certfile CA -name CLIENTNAME -out OUTPUT.p12

openssl pkcs12 -export -in pki/issued/handy.crt -inkey pki/private/handy.key -certfile pki/ca.crt -name handy -out handy.p12

openVPN for Android

Für Android steht z.B. über F-Droid das Paket von blinkt zur Verfügung, siehe https://f-droid.org/packages/de.blinkt.openvpn/

• In der Client-App erstelle ich ein neues Profil mit dem Namen “test” (Name ist ja egal).
• Im Reiter “Basic” klicke ich bei “Client Certificate” auf den Select-Button. So kann ich das eben in Android importierte Zertifikat auswählen.

• Im Reiter “Server List” trage ich meinen Server ein und wähle unter “Protocol” UDP.

• Unter dem Reiter “Authentication/Encryption” müssen folgende Einstellungen getroffen werden:
  • bei TLS-Settings entferne ich den Haken bei “Certificate Hostname Check”

• dafür setze ich den Haken bei “Use Control Channel Authentication/Encryption”
  • als “TLS Auth/TLS Encrpytion File” wähle ich den auf das Handy kopierten ta.key
  • als “Authentication/encryption method” wähle ich Encryption (--tls-crypt)

• bei “Encryption ciphers” trage ich (gemäß meiner Server-Config) AES-256-CBC:AES-256-GCM ein.

Das funktioniert wunderbar, und mein Handy kann sich mit meinem VPN verbinden.

Jetzt können sich alle Clients (auch die Mobilgeräte über IPv6) mit dem Server verbinden und sich gegenseitig anpingen.

redirect-gateway def1 # leitet gesamten Datenverkehr über das VPN

Weblinks

• https://wiki.archlinux.org/title/OpenVPN
• https://f-droid.org/packages/de.blinkt.openvpn/
• https://github.com/schwabe/ics-openvpn
• https://community.openvpn.net/openvpn/ticket/442
• https://requestforcomments.de/archives/682

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

Hardware

Folgende Geräte kommen zum Einsatz:

• Master-CA- ist die Zertifikationsinstanz, welche die Zertifikate ausstellt und signiert. Dies übernimmt mein Desktoprechner zuhause
• openVPN-Server - das übernimmit mein Homeserver
• Clients - mein Desktoprechner, mein Laptop sowie mein Büro-PC

Installieren

Zunächst installiere ich die benötigten Pakete:

sudo apt install openvpn easy-rasa

Ich nutze Arch, btw, daher nutze ich Pacman:

pacman -S openvpn easy-rsa 

Zertifikate anlegen

Bevor es wirklich los gehen kann, müssen die grundlegenden Zertifikate erstellt werden.

sudo bash
mkdir /etc/easy-rsa
cd /etc/easy-rsa

export EASYRSA=$(pwd)
easyrsa init-pki
easyrsa build-ca

easyrsa gen-req SERVERNAME nopass
easyrsa sign-req server SERVERNAME

mkdir /etc/easy-rsa/produnis

# diffie hellman für Perfect Forward Secrecy (PFS)
openssl dhparam -out /etc/easy-rsa/produnis/dh.pem 2048

# HMAC key um Man-in-the-Middle-Angriffe zu unterbinden
openvpn --genkey secret /etc/easy-rsa/produnis/ta.key

scp /etc/easy-rsa/pki/private/SERVERNAME.key /etc/easy-rsa/pki/issued/SERVERNAME.crt /etc/easy-rsa/pki/ca.crt /etc/easy-rsa/produnis/dh.pem /etc/easy-rsa/produnis/ta.key user@server:/tmp 

Server einrichten

Verbinde dich auf den Server und erstelle ein Unterverzeichnis in /etc/openvpn/server/, das wie das VPN-Netz heisst. Ich hatte ja produnis als Netznamen gewählt.

ssh user@server
sudo bash
mkdir /etc/openvpn/server/NETZNAME

In diesen Ordner verschiebe ich die kopierten Dateien.

mv /tmp/SERVERNAME.key /tmp/SERVERNAME.crt /tmp/ca.crt /tmp/dh.pem /tmp/ta.key /etc/openvpn/server/NETZNAME/

Im “Hauptordner” /etc/openvpn/server/ erstelle ich die Datei produnis.conf mit folgendem Inhalt:

port 1194
proto udp
dev tun
server 10.5.5.0 255.255.255.0 

# ihr müsst "produnis" durch eure Namen ersetzen
ca /etc/openvpn/server/produnis/ca.crt
cert /etc/openvpn/server/produnis/produnis.crt
key /etc/openvpn/server/produnis/produnis.key  # This file should be kept secret
dh /etc/openvpn/server/produnis/dh.pem
tls-crypt /etc/openvpn/server/produnis/ta.key

client-to-client # damit sich die clients untereinander sehen können
ifconfig-pool-persist /etc/openvpn/server/produnis/ipp.txt
keepalive 10 120
cipher AES-256-CBC
max-clients 5
persist-key
persist-tun
status /etc/openvpn/server/produnis/openvpn-status.log
verb 3
explicit-exit-notify 1

Stelle sicher, dass openVPN auf alle Dateien zugreifen kann:

chown openvpn:network -R /etc/openvpn/server

Starte den Server mittels

openvpn /etc/openvpn/server/produnis.conf

systemctl start openvpn-server@produnis.service
systemctl status openvpn-server@produnis.service

Clients hinzufügen

Auf der Master-CA-Maschine erzeugen wir nun weitere Zertifikate für jeden Client.

sudo bash
cd /etc/easy-rsa
easyrsa gen-req CLIENTNAME nopass
easyrsa sign-req client CLIENTNAME

Wir müssen die Aktion mit yes bestätigen und das oben erzeugte Passwort des Master-CA eingeben.

Jetzt können wieder alle Dateien auf den Client übertragen werden. Benötigt werden

• /etc/easy-rsa/pki/private/CLIENTNAME.key
• /etc/easy-rsa/pki/issued/CLIENTNAME.crt
• /etc/easy-rsa/pki/ca.crt
• /etc/easy-rsa/produnis/ta.key

Ich kopiere diese Dateien zunächst ins /tmp-Verzeichnis auf dem Client:

scp /etc/easy-rsa/pki/issued/CLIENTNAME.crt /etc/easy-rsa/pki/private/CLIENTNAME.key /etc/easy-rsa/pki/ca.crt /etc/easy-rsa/produnis/ta.key user@client:/tmp

ssh user@client
sudo bash
mkdir /etc/openvpn/client/produnis
mv /tmp/ca.crt /tmp/ta.key /tmp/CLIENTNAME.key /tmp/CLIENTNAME.crt /etc/openvpn/client/produnis/

client
dev tun
proto udp

remote mein.server.de 1194  # ersetze mit Adresse des openVPN-Server
ca /etc/openvpn/client/produnis/ca.crt
cert /etc/openvpn/client/produnis/CLIENTNAME.crt
key /etc/openvpn/client/produnis/CLIENTNAME.key
tls-crypt /etc/openvpn/client/produnis/ta.key
cipher AES-256-CBC
resolv-retry infinite
nobind
persist-key
persist-tun
tun-mtu 1350 # Unitymedia/Vodafone
verb 3

chown openvpn:network -R /etc/openvpn/client

openvpn /etc/openvpn/client/produnis.conf

sudo systemctl start openvpn-client@produnis.service
sudo systemctl status openvpn-client@produnis.service

statische IP-Adresse für die Clients festlegen

Dies ist eine Art DHCP-light, wir teilen jedem Client eine feste IP innerhalb des VPN-Netzes zu.

Erstelle auf dem Server ein Unterverzeichnis ccd (client config dir) und lege dort je eine Datei für jeden Client an.

mkdir /etc/openvpn/server/produnis/ccd
cd  /etc/openvpn/server/produnis/ccd
nano CLIENTNAME

CLIENTNAME ist dabei der Name, den du beim Erzeugen der Zertifikate verwendet hast. Anhand des Zertifikats erkennt der Server den Client.

In die Datei schreibst du:

ifconfig-push 10.5.5.x 10.5.5.1

wobei du x durch die gewünschte IP ersetzt. Die zweite IP ist die des VPN-Servers, also immer 10.5.5.1.

Damit der Server über unsere IP-Listen Bescheid weiss, muss /etc/openvpn/server/produnis.conf um folgende Zeile erweitert werden:

client-config-dir /etc/openvpn/server/produnis/ccd

Anschließend muss openVPN neu gestartet werden, z.B. mittels

systemctl restart openvpn-server@produnis.service

Firewall anpassen

Falls ihr eine Firewall benutzt (und ich hoffe doch sehr, dass dies der Fall ist), muss diese für openVPN angepasst werden. Einerseits müssen Ports freigegeben werden (standardmäßig 1194 udp), anderseits müssen wir intern NAT einrichten, wenn der Internetverkehr über den Tunnel geroutet werden soll.

## openvpn general settings für Server und Client
iptables -A INPUT -i tun+ -j ACCEPT
iptables -A FORWARD -i tun+ -j ACCEPT

## nur auf dem Server nächste Zeile ausführen
## Dies setzt das NAT auf, damit Internet durch den Tunnel geroutet wird
#iptables -t nat -A POSTROUTING -s 10.5.5.0/24 -o eth0 -j MASQUERADE 

## auf Server und Client muss Port 1194 fuer openVPN geöffnet werden
iptables -A INPUT -i eth0 -p udp --destination-port 1194 -j ACCEPT

# openVPN
sudo ufw allow 1194
sudo ufw allow out 1194/udp

nano /etc/default/ufw 

DEFAULT_FORWARD_POLICY="ACCEPT"

nano /etc/ufw/before.rules

# NAT-Tabelle hinzufügen
*nat
:POSTROUTING ACCEPT [0:0]
# OpenVPN-Regeln hinzufügen
-A POSTROUTING -s 10.5.5.0/24 -o eth0 -j MASQUERADE
COMMIT

nano /etc/ufw/sysctl.conf

net/ipv4/ip_forward=1
net/ipv6/conf/default/forwarding=1
net/ipv6/conf/all/forwarding=1

Fertig

Jetzt sollten sich alle Clients mit dem Server verbinden und sich untereinander “sehen” können. Da jeder Client von mir eine fest IP-Adresse zugewiesen bekommen hat, kann ich nun easy per ssh von Client zu Client oder auf den Server verbinden. Genau so, wie ich es wollte.

redirect-gateway def1 # leitet gesamten Datenverkehr über das VPN

siehe auch

• Im nächsten Blogpost zeige ich, wie ich Handy und Tablet unter Android dem VPN hinzugefügt und IPv6 aktiviert habe.
• Weil es so schön war, hab ich alles nochmal mit Wireguard nachgebaut.

Weblinks

• https://wiki.archlinux.org/title/OpenVPN
• https://wiki.archlinux.org/index.php/Easy-RSA
• https://www.itsfullofstars.de/2018/09/openvpn-assign-static-ip-to-client/
• https://bbs.archlinux.org/viewtopic.php?id=293930
• https://requestforcomments.de/archives/682

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

Nachbauen

• Um ein seitliches Panel zu erstellen führt ihr in einem leeren Bereich eures Desktops einen Rechtsklick aus und wählt “Kontrolleiste hinzfügen -> leere Kontrollleiste”.
• Dies macht ihr so lange, bis eine seitliche Leiste links oder rechts entsteht (zuerst wird oben eine entstehen, dann links, dann rechts).
• Die nicht benötigten neuen Leisten könnt ihr direkt wieder löschen.
• Mein Panel hat eine Breite von 100

Widgets

Mein Panel besteht aus folgenden Widgets:

Panel	Widgets
	Analoge Uhr Digitale Uhr Systemmonitor-Sensoren Azeige-Stil: Gitter Gitter-Stil: Liniendiagramm Sensoren: Gesamtauslastung Warteauslastung Download-Rate Upload-Rate Abstandhalter (Breite 10) Systemabschnitt der Kontrollleiste Abstandhalter Fensterleiste Anwendungsstarter

Weitere Desktopbilder finden sich bei Mastodon unter dem Hashtag #showyourdesktop. Wie sieht euer Desktop aus?

Weblinks

• https://kde.org

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

Hallenuhr am Schürenkamp (Bodet BT 5010)

Die Bedientafel der Hallenuhr im Schürenkamp ist schon ziemlich abgerockt.

Die Zeit einstellen

Über den Plus-Knopf (Preselection Presetting) oben links kann die gewünschte Länge der Halbzeit eingestellt werden (Abbildung 2).

Mit jedem Tastendruck zählt die Uhr 1 Minute hoch. Eine Handballhalbzeit dauert 30 Minuten, in der Jugend 20 Minunten.

Ist die korrekte Minutenzahl eingestellt, muss die RESET-Taste 5 Sekunden lang gedrückt werden (Abbildung 3).

Die Uhr springt dabei auf 0:00 zurück.

Die Zeit kann jetzt mit dem Start Stop-Knopf gestartet und gestoppt werden.

Tore zählen

Unten rechts (Score) können die Tore für Heim und Gast gezählt werden (Abbildung 5)

Tore zurücknehmen

Soll ein Tor zurückgenommen werden, muss

1. der C-Knopf (Correction) gedrückt werden (Abbildung 6),

2. über die Tore-Knöpfe (Abbildung 5) die Tore heruntergezählt werden,

3. erneut der C-Knopf gedrückt werden.

Zeitstrafen

Zeitstrafen für Heim und Gast können über die Fouls-Knöpfe rechts (über den Tor-Knöpfen) (Abbildung 7) gesetzt werden.

Team-Auszeiten

Team-Auszeiten können über die mittleren Knöpfe (Time Out) (Abbildung 8) für Heim und Gast gesetzt werden.

Jedoch geht dies nicht automatisch. Der Ablauf lautet:

1. Zeit stoppen (Abbildung 4)
2. Hupe betätigen (Abbildung 9)
3. Team-Auszeit setzen (Abbildung 8)

Die Uhr zählt nun unsichtbar 1 Minute herunter. Nach 50 Sekunden ertönt die Hupe kurz, nach 1 Minute lang.

Hupen

Die Hupe befindet sich auf der linken Seite (Abbildung 9).

PDF

Eine PDF-Version dieser Anleitung zum Ausdrucken gibt es hier.

Weblinks

• https://www.youtube.com/watch?v=K0wgcCS5FU4
• https://www.handball.net/hallen/handball4all.westfalen.2191
• https://www.produnis.de/blog/posts/2024-02-10-Hallenuhr-Schuerenkamp/Handball-Uhr-Schuerenkamp.pdf

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

Image auf Stick flashen

• Lade dir ein aktuelles Arch-Image herunter, siehe https://archlinux.org/download/
• Stecke einen USB-Stick in dein Gerät und checke dessen /dev/-Adresse mittels

$ lsblk

Das kann dann z.B. so aussehen:

NAME            MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINTS  
sda             259:0    0 931,5G  0 disk
sdb               8:0    1   7,4G  0 disk 

In diesem Beispiel ist sda die Festplatte, und sdb der USB-Stick. Bei euch kann das durchaus anders aussehen.

• Flashe das Arch-Image auf den Stick, z.B. mittels

$ dd if=archlinux*.iso of=/dev/sdb

wobei sdb bei euch evtl. entsprechend angepasst werden muss.

booten vom Stick

Stecke den Stick in den Laptop, und wähle beim Starten den Stick als Bootquelle aus. Bei mir funktioniert das, indem ich F12 beim Starten gedrückt halte.

Es sollte sich recht bald das Arch-Bootmenu melden

Wähle den ersten Eintrag aus und warte, bis dich die Kommandozeile begrüßt.

Netzwerkverbindung herstellen

Ist Arch gestartet, stellen wir als erstes eine Netzwerkverbindung her. Das Netzwerk brauchen wir, um frische Installationspakete zu holen, aber auch, um uns gleich per SSH auf die neue Kiste einzuloggen.

$ iwctl

$ devices list

$ station wlan0 connect <SSID>

$ exit

SSH

Ich verbinde mich an dieser Stelle gerne mittels SSH auf den Laptop. Stelle sicher, dass sshd läuft,

$ systemctl start sshd

Setze ein temporäres Admin-Passwort mittels

$ passwd

Finde die IP-Adresse des Laptops heraus, zB mittels

$ ip a

Logge dich von einem anderen PC auf die neue Kiste ein mittels

$ ssh root@IP-ADRESSE

Partitionierung der Festplatte

Nun partitionieren wir die Festplatte. Wir wollen 2 Partitionen erstellen,

• eine EFI-Partition zum Booten,
• und eine verschlüsselte root-Partition für das Archsystem.

Zunächst finden wir wieder die /dev/-Bezeichnungen der Laptopfestplatte heraus mittels

$ lsblk

NAME            MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINTS
sda             259:0    0 931,5G  0 disk 
sdb               8:0    1   7,4G  0 disk  
├─sdb1            8:1    1   917M  0 part  
└─sdb2            8:2    1    15M  0 part  

In diesem Beispiel ist sda die Festplatte des Laptops und sdb der Boot-Stick. Wir wollen also /dev/sda partitionieren.

Starte gdisk mittels

$ gdisk /dev/sda

Wir können mit p schauen, welche Partitionen schon auf der Platte sind. Meine Platte ist neu und leer, und daher gibt es nichts zu sehen. Möchtet ihr eine bereits gebrauchte Festplatte benutzen, könnt ihr die vorhandenen Partitionen mittels d löschen.

Wir erstellen eine neue Partition mittels n.

• die erste Partition wird unsere Boot-Partition.
• die voreingestellte Partitionsnummer 1 ist korrekt, so dass wir einfach ENTER drücken können.
• ebenfalls korrekt ist der erste Sektor. Auch diesen können wir mittels ENTER bestätigen.
• beim “letzten Sektor” geben wir +512M ein, damit die Partition 512 MB groß wird.
• der Partitionscode im Hexformat lautet: ef00 (EFI-Partition)

Wir erstellen eine weitere Partition mittels n.

• diese zweite Partition soll die verschlüsselte Systempartition werden.
• die voreingestellte Partitionsnummer 2 ist korrekt, so dass wir einfach ENTER drücken können.
• ebenfalls korrekt ist der erste Sektor. Auch diesen können wir mittels ENTER bestätigen
• und auch der letzte Sektor ist korrekt, weil wir den gesamten Rest der Festplatte verwenden möchten. Wir können also einfach ENTER drücken können.
• der Partitionscode im Hexformat lautet: 8309 (LUKS-Partition)

Wir können mittels p überprüfen, ob alles richtig ist.

Zum Schluss schreiben wir die Partitionstabelle mittels w.

Verschlüsselung

Um sicher zu sein, dass alles klappen wird, laden wir die Encryption-Module

$ modprobe dm-crypt
$ modprobe dm-mod

Nun erstellen wir ein LUKS-LVM auf der root-Partition (/dev/sda2):

$ cryptsetup luksFormat -v -s 512 -h sha512 /dev/sda2

Hier geben wir unser gewünschtes Passwort ein und merken es uns!!!. Wenn ihr das Passwort vergesst, kommt ihr nicht mehr an eure Daten!!!

Jetzt können wir das Laufwerk mounten

$ cryptsetup open /dev/sda2 luks_lvm

(hier muss das Passwort eingegeben werden, welches wir soeben für die Partition erzeugt haben)

$ pvcreate /dev/mapper/luks_lvm
$ vgcreate arch /dev/mapper/luks_lvm

$ lvcreate -n swap -L 10G arch

$ lvcreate -n root -l +100%FREE arch

Filesystems

Nun müssen die Partitionen formatiert werden.

Die EFI-Partition benötigt das Format FAT32:

$ mkfs.fat -F32 /dev/sda1 

Für die verschlüsselte root-Partition können wir z.B. btrfs oder ext4 verwenden. Ich persönlich begnüge mich mit ext4.

$ mkfs.btrfs -L root /dev/mapper/arch-root
# oder
$ mkfs.ext4 -L root /dev/mapper/arch-root

Nun formatieren wir noch unseren Swap:

$ mkswap /dev/mapper/arch-swap

Mounten

Zuerst mounten und aktivieren wir die SWAP-Partition

$ swapon /dev/mapper/arch-swap
$ swapon -a

Anschließend mounten wir die root-Partition nach /mnt:

$ mount /dev/mapper/arch-root /mnt

Unterhalb von /mnt erstellen wir das /boot-Verzeichnis:

mkdir -p /mnt/boot

Hierhin mounten wir die erzeugte boot Partiton (/dev/sda1)

$ mount /dev/sda1 /mnt/boot

Installiere ArchLinux

Nun ist es endlich an der Zeit gekommen, Archlinux zu installieren. Dieser Befehl bringt die essentiellen Pakete auf die neue Platte:

$ pacstrap -K /mnt base base-devel linux linux-firmware nano openssh

Wir erzeugen die fstab-Datei für unser neues System mittels:

$ genfstab -U -p /mnt > /mnt/etc/fstab

$ arch-chroot /mnt /bin/bash

Konfiguration

$ nano /etc/mkinitcpio.conf

HOOKS=(... block encrypt lvm2 filesystems fsck)

$ pacman -S lvm2

$ pacman -S efibootmgr dosfstools gptfdisk

$ bootctl install

$ blkid /dev/sda2

/dev/sda2: UUID="272b13c4-ce78-47de-b04c-66210edb977d" TYPE="crypto_LUKS" PARTLABEL="Linux LUKS" PARTUUID="6b6b86e4-b8fe-4b7d-874d-96c67075b90c"

$ nano /boot/loader/entries/arch-uefi.conf

title    Arch Linux
linux    /vmlinuz-linux
initrd   /initramfs-linux.img
options  root=/dev/mapper/arch-root cryptdevice=UUID=<uuid>:luks_lvm  locale=de_DE.UTF-8

options  root=/dev/mapper/arch-root cryptdevice=UUID=272b13c4-ce78-47de-b04c-66210edb977d:luks_lvm  locale=de_DE.UTF-8

$ nano /boot/loader/loader.conf

default   arch-uefi
timeout   1

$ mkdir /secure

$ dd if=/dev/random of=/secure/root_keyfile.bin bs=512 count=8

$ chmod 000 /secure/*

$ cryptsetup luksAddKey /dev/sda2 /secure/root_keyfile.bin

$ nano /etc/mkinitcpio.conf

FILES=(/secure/root_keyfile.bin)

$ mkinitcpio -p linux

Systemkonfiguration

Zeit für ein paar weitere Systemkonfigurationen.

$ ln -sf /usr/share/zoneinfo/Europe/Berlin /etc/localtime

$ nano /etc/systemd/timesyncd.conf

[Time]
NTP=0.arch.pool.ntp.org 1.arch.pool.ntp.org 2.arch.pool.ntp.org 3.arch.pool.ntp.org 
FallbackNTP=0.pool.ntp.org 1.pool.ntp.org

$ systemctl enable systemd-timesyncd.service

$ nano /etc/locale.gen

#de_CH ISO-8859-1
de_DE.UTF-8 UTF-8
#de_DE ISO-8859-1
#de_DE@euro ISO-8859-15

$ locale-gen

$ nano /etc/locale.conf

LANG=de_DE.UTF-8

$ echo KEYMAP=de-latin1-nodeadkeys > /etc/vconsole.conf
$ localectl --no-convert set-x11-keymap de pc105 deadgraveacute
$ localectl --no-convert set-keymap de-latin1-nodeadkeys

$ localectl status

System Locale: LANG=de_DE.UTF-8
    VC Keymap: de-latin1-nodeadkeys
   X11 Layout: de
    X11 Model: pc105
  X11 Variant: deadgraveacute

$ echo "Norbert" > /etc/hostname

$ useradd -m -G wheel -s /bin/bash produnis

$ passwd produnis

$ EDITOR=nano visudo

%wheel ALL=(ALL:ALL) ALL

Defaults passwd_timeout=0

$ pacman -S networkmanager
$ systemctl enable NetworkManager

$ systemctl enable sshd

# Für AMD
$ pacman -S amd-ucode
# ODER
# Für Intel
$ pacman -S intel-ucode

$ pacman -S plasma-desktop plasma-wayland-session  kde-applications  sddm sddm-kcm plasma-nm

$ systemctl enable sddm

Reboot

Zunächst verlassen wir die chroot-Umgebung und unmounten die Partitionen.

$ exit
$ umount -R /mnt
$ reboot now

Bei mir meldet sich nach dem Start nun das UEFI-Bootmenu, welches nach 2 Sekunden Archlinux bootet. Hier werde ich nach dem Verschlüsslungspasswort gefragt. Anschließend meldet sich der sddm-Loginbildschirm, und ich kann meine Plasmasession starten.

Deutsches Tastaturlayout

Noch ist die KDE-Tastatur nicht auf deutsch eingestellt. Hierfür geht ihr in die Systemeinstellungen, und wählt unter “Tastaur” den Reiter “Belegungen”.

Setzt den Haken bei “Belegungen einrichten” und fügt “Deutsch” hinzu. Sobald ihr unten auf “Anwenden” klickt, ist die Tastatur auf deutsches Layout eingestellt.

…what if?

Falls doch etwas schief laufen sollte, und ihr z.B. nicht ins System booten könnt, stellt ihr wie folgt wieder die chroot-Umgebung her:

• boote vom USB-Stick, so wie oben beschrieben
• cryptsetup open /dev/sda2 luks_lvm
• mount /dev/mapper/arch-root /mnt
• mount /dev/sda1 /mnt/boot
• arch-chroot /mnt /bin/bash

Jetzt liegt es aber an euch, den Fehler zu finden… ;)

Weblinks

• https://wiki.archlinux.de/title/Anleitung_f%C3%BCr_Einsteiger
• https://github.com/dreamsofautonomy/arch-from-scratch
• https://www.youtube.com/watch?v=YC7NMbl4goo

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

Wrapper-Services

Ich erstelle mir zwei Hilfs-Services, die jeweils den BOINC-Client starten und stoppen.

FÜr den Starter-Service:

sudo nano /etc/systemd/system/start-boinc.service

[Unit]
Description=Start boinc service
After=network.target

[Service]
Type=oneshot
ExecStart=/usr/bin/systemctl start boinc-client.service

[Install]
WantedBy=multi-user.target

Für den Stopper-Service:

sudo nano /etc/systemd/system/stop-boinc.service

[Unit]
Description=Stop boinc service
After=network.target

[Service]
Type=oneshot
ExecStart=/usr/bin/systemctl stop boinc-client.service

[Install]
WantedBy=multi-user.target

Timer

Jetzt brauche ich nur noch zwei Timer, die jeweils die Wrapper-Services auslösen.

Für den Starter:

sudo nano /etc/systemd/system/start-boinc.timer

[Unit]
Description=Timer for starting BOINC client

[Timer]
OnCalendar=Mon-Fri *-*-* 17:00:00

[Install]
WantedBy=timers.target

Für den Stopper:

sudo nano /etc/systemd/system/stop-boinc.timer

[Unit]
Description=Timer for stopping BOINC client

[Timer]
OnCalendar=Mon-Fri *-*-* 08:00:00

[Install]
WantedBy=timers.target

Timer aktivieren

Jetzt müssen die neuen Dateien systemd bekannt gemacht werden:

sudo systemctl daemon-reload

Anschließend werden die Timer aktiviert.

sudo systemctl enable --now start-boinc.timer

sudo systemctl enable --now stop-boinc.timer

Wir können noch überprüfen, ob alles bereit ist.

sudo systemctl status start-boinc.timer

sudo systemctl status stop-boinc.timer

Fertig. Mein boinc-client.service wird nun von Montag bis Freitag jeweils um 17:00 Uhr gestartet und um 8:00 Uhr gestoppt.

Weblinks

• https://documentation.suse.com/smart/systems-management/html/systemd-working-with-timers/index.html
• https://boinc.bakerlab.org/

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de

Quarto Letter

Mit dieser Extension könnt ihr Briefe mittels Quarto erstellen. Vorlage dieser Extension war mein Blogeintrag vom 12.09.2022.

Um die Vorlage zu verwenden tippt ihr ins Terminal:

quarto use template produnis/quarto-letter

Quarto Invoice

Diese Extension beruht auf der quarto-letter-Vorlage (s.o.) und erzeugt Rechnungen.

Um die Vorlage zu verwenden tippt ihr ins Terminal:

quarto use template produnis/quarto-invoice

Publikationsliste

Diese Extension erzeugt eine Publikationsliste anhand einer BibTeX-Datei. Vorlage für diese Extension war mein Blogeintrag vom 19.04.2021.

Um die Vorlage zu verwenden tippt ihr ins Terminal:

quarto use template produnis/publicationlist

Quarto CV

Diese Extension ist eine Erweiterung der Publikationsliste. Hierbei wird ein hübsches Lebenslaufdokument erstellt, wobei die Möglichkeit besteht, eine (oder mehrere) Publikationslisten hinzuzufügen.

Um die Vorlage zu verwenden tippt ihr ins Terminal:

quarto use template produnis/quarto-cv

Quarto Timer

Mit dieser Extension lassen sich Countdown-Timer in Folien (oder HTML-Dokumenten) einbauen. Sie beruht auf meinem Blogpost vom 04.01.2024.

Ihr könnt den Timer einbinden über:

quarto add produnis/quarto-timer

HSNR revealjs

Dies ist meine Vorlage für revealjs-Folien im Design meiner Hochschule (HSNR). In dieser Extension ist der “Timer” bereits enthalten.

Ihr könnt die Vorlage benutzen über:

quarto use template produnis/hsnr-revealjs

Quarto cert

Diese Extension erstellt Teilnehmerzertifikate.

Ihr könnt die Vorlage benutzen über:

quarto use template produnis/quarto-cert

Quarto Cheatsheet

Mit dieser Extension könnt ihr “Cheatsheets” (Spickzettel) erstellen, zum Beispiel zur Prüfungsvorbereitung oder, um Tastenkombinationen oder git-Befehle zusammenzustellen.

Ihr könnt die Vorlage benutzen über:

quarto use template produnis/quarto-cheatsheet

Weblinks

• https://github.com/produnis/quarto-letter
• https://github.com/produnis/quarto-invoice
• https://github.com/produnis/publicationlist
• https://github.com/produnis/quarto-cv
• https://github.com/produnis/quarto-timer
• https://github.com/produnis/hsnr-revealjs
• https://github.com/produnis/quarto-cert
• https://github.com/produnis/quarto-cheatsheet

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de