IT security, FreeBSD, Linux, mail server hardening, post-quantum crypto, DNS, retro computing & hands-on hardware hacks. Privater Tech-Blog seit 2003.

Schlagwort: Python

Postfix ohne Klartext-Fallback: DANE, sonst MTA-STS, sonst ein geprüftes Zertifikat

Schematische Darstellung eines Postfix-Mailservers mit TLS-Absicherung über DANE, MTA-STS und Zertifikatsprüfung. Ein unsicherer Klartext-Fallback durch STARTTLS-Downgrade wird blockiert.

Mein Mailserver hat seit Jahren DANE mit DNSSEC, MTA-STS und seit diesem Jahr auch einen Post-Quantum-Schlüsselaustausch. Trotzdem hat er heute eine Testmail im Klartext ausgeliefert. Das war kein Bug, sondern genau das Verhalten, das in der Postfix-Doku steht. In diesem Beitrag geht es darum, warum Postfix die Policy „DANE wenn vorhanden, sonst ein geprüftes Zertifikat“ nicht von sich aus kann, warum ich dafür unter FreeBSD nichts Fertiges gefunden habe und wie mein kleiner Dienst postfix-dane-policy diese Lücke schließt.

Der Auslöser: ein Downgrade-Test

Der Mail-Server-Test von comcrypto simuliert unter anderem einen STARTTLS-Downgrade, den eigenen Server kannst du dort also selbst prüfen. Man schickt eine Mail an eine Testadresse, und der Empfängerserver lässt den TLS-Handshake absichtlich scheitern. So würde es auch ein aktiver Angreifer zwischen zwei Mailservern machen: STARTTLS stören und schauen, ob der Absender danach ohne Verschlüsselung weitermacht. Mein Postfix hat genau das getan:

postfix/smtp[5497]: 2BD2E39781: to=<xxxx@evaluation.comcrypto.de>, relay=smtp-in-nbg1pr01loearatl.mxg.cloud[37.120.186.126]:25, delay=1.2, tls=may?, dsn=4.7.5, status=deferred (Cannot start TLS: handshake failure)
postfix/smtp[6005]: 2BD2E39781: to=<xxxx@evaluation.comcrypto.de>, relay=smtp-in-nbg1pr01loearatl.mxg.cloud[37.120.186.126]:25, delay=490, tls=may:none, dsn=2.0.0, status=sent (250 2.0.0 Ok: queued as C7DC6E00C5)

Erster Versuch: Handshake scheitert, Mail wird zurückgestellt. Gut acht Minuten später der zweite Versuch, und da steht tls=may:none mit status=sent. Die Mail ist im Klartext beim Empfänger angekommen. Ein Angreifer, der STARTTLS stört, hätte sie also nur ein paar Minuten lang aufhalten müssen.

Das ärgert mich vor allem, weil ich dachte das Thema wäre bei mir erledigt. Ist es aber nur für Empfänger, die selbst DANE oder MTA-STS veröffentlichen. Für alle anderen gilt opportunistisches TLS nach RFC 7435: verschlüsseln, wenn es geht, und wenn nicht, dann eben nicht. Und das ist immer noch ein großer Teil der Mailserver da draußen.

Warum Postfix das allein nicht kann

Die ausgehende TLS-Stufe stellt man in Postfix mit smtp_tls_security_level ein. Die Manpage postconf(5) von Postfix 3.11.7 ist bei den einzelnen Stufen sehr deutlich. Zu may steht dort:

after a failed TLS handshake or TLS session, fall back to plaintext if the message has spent minimal_backoff_time in the mail queue

Genau das zeigt mein Log oben. Bei mir stand allerdings gar nicht may in der main.cf, sondern dane. Dazu sagt die Manpage:

When DNSSEC-validated TLSA records are not found the effective tls security level is „may“.

Mit dane bekommt also jeder Empfänger ohne TLSA-Record wieder may, inklusive Klartext-Fallback. Die naheliegende Idee wäre jetzt, global auf verify oder secure zu gehen. Beide Stufen ignorieren TLSA-Records aber komplett. Das hätte zwei unschöne Folgen:

  • Empfänger mit DANE-EE und einem selbst signierten Zertifikat wären plötzlich nicht mehr erreichbar. Das ist bei kleinen Selbsthostern gar nicht so selten und mit DANE völlig legitim, das Vertrauen kommt dort ja aus dem DNSSEC-gesicherten TLSA-Record und nicht von einer CA.
  • DANE-Empfänger würden nur noch gegen die CA geprüft und nicht mehr gegen ihr TLSA. Damit verschenkt man genau den Schutz, den DANE bietet.

Was ich eigentlich will, ist eine Stufe „DANE, wenn der Empfänger es veröffentlicht, sonst verify“. Die gibt es nicht. Viktor Dukhovni, der DANE in Postfix gebaut hat, schrieb dazu schon 2021 auf der exim-users-Liste: „It isn’t currently possible to do ‚dane‘ else ‚encrypt‘. Need a dane-fallback level“. Auch Postfix 3.11 und die 3.12-Snapshots bis August 2026 haben so etwas nicht.

Gibt es das schon fertig?

Postfix kann die Entscheidung aber pro Ziel treffen lassen. Über smtp_tls_policy_maps fragt Postfix vor jeder Zustellung eine Tabelle, welche TLS-Stufe für die Zieldomain gelten soll. Diese Tabelle darf auch ein Dienst sein, der live im DNS nachschaut. Bevor ich selbst etwas baue, habe ich also gesucht:

  • postfix-mta-sts-resolver von Snawoot kann nur MTA-STS, DANE ist dort bewusst außen vor (Issue #67). Den nutze ich seit 2019, damals habe ich das Logfile und ein rc.d-Skript für FreeBSD beigesteuert. Inzwischen gibt es ihn als FreeBSD-Port und er bleibt bei mir im Einsatz, jetzt als zweite Map.
  • postfix-tlspol von Zuplu kommt am nächsten: DANE und MTA-STS in einem Go-Daemon. Ein gutes Projekt, nur eben nicht für FreeBSD gedacht. Es gibt keinen Port, Release-Binaries habe ich nur für Linux gefunden, der Build braucht ein sehr aktuelles Go, und die Installationswege sind auf systemd oder Docker ausgelegt. Dazu liefert tlspol bei gemischten MX-Sets nach meinem Stand dane statt dane-only, womit dort wieder may möglich ist.
  • Mailu nutzt intern eine ähnliche Kette, setzt global aber dane, ohne DANE oder MTA-STS landet man also wieder bei may. Und es ist Docker. Bei mailcow, docker-mailserver, Mail-in-a-Box, iRedMail und Modoboa habe ich nichts Vergleichbares gefunden.
  • Im FreeBSD-Paket-Repository steckt DANE natürlich in Postfix selbst, dazu gibt es Werkzeuge wie letsdns. Das verwaltet aber die eigenen TLSA-Records, kümmert sich also um die andere Seite.

Für Postfix unter FreeBSD habe ich Stand jetzt also nichts Fertiges gefunden. Dann eben selbst bauen.

postfix-dane-policy

postfix-dane-policy ist ein kleiner Python-Dienst (Python 3.10 oder neuer, dazu dnspython). Er spricht das socketmap-Protokoll von Postfix, das sind simple Netstrings über einen Unix-Socket, und wird in smtp_tls_policy_maps eingehängt. Er beantwortet genau eine Frage: Hat diese Zieldomain nutzbares DANE? Alles andere bleibt bei Postfix und beim MTA-STS-Resolver.

Für jede Next-Hop-Domain holt der Dienst den MX-RRset und für jeden MX-Host den TLSA-RRset unter _25._tcp. Ist ein MX-Host ein per DNSSEC validierter CNAME, macht er es wie Postfix und RFC 7672: Er sucht zuerst am Zielnamen, dann am ursprünglichen Namen, der erste gesicherte TLSA-RRset entscheidet, und ein Fehler beim Lookup bricht die Suche ab. Gezählt werden nur brauchbare Records, also Usage 2 oder 3, Selector 0 oder 1 und Matching-Type 0, 1 oder 2 mit passender Länge. Dann entscheidet er so:

SituationAntwortWirkung in Postfix
MX per DNSSEC validiert und mindestens ein MX-Host hat einen validierten TLSA-RRset mit brauchbaren RecordsOK dane-onlyDANE ist Pflicht, kein Fallback
MX nicht validiert, kein TLSA, nur unbrauchbare TLSA-Records, Null-MX, Domain existiert nichtNOTFOUNDnächste Map (MTA-STS) oder die globale Stufe
SERVFAIL, bogus DNSSEC oder Timeout beim MX-Lookup, oder beim TLSA-Lookup, wenn kein anderer MX brauchbares TLSA hatTEMPZustellung wird zurückgestellt, nie herabgestuft
Elterndomain (.example.com) oder [host]:port als Next-HopNOTFOUND

Die eigentliche Logik steckt in einer einzigen Funktion. Gekürzt sieht decide() aus policy.py so aus:

def decide(domain, backend, deadline=None):
    """Return (result, ttl, reason) for a normalized next-hop domain."""
    mx = query(domain, "MX")
    if mx.status == "fail":
        return RESULT_TEMP, 0, "MX lookup failed"
    if mx.status == "nxdomain":
        return RESULT_NONE, NEGATIVE_TTL, "domain does not exist"
    if not mx.secure:
        return RESULT_NONE, NEGATIVE_TTL, "MX not DNSSEC-validated"

    # ... null MX, implicit MX (no MX record = domain itself) ...

    tlsa_hosts = []
    failed_hosts = []
    for host in hosts:
        # follows a secure CNAME, counts only usable TLSA records
        found, failed, ttl = _tlsa_for_host(host, query)
        if found:
            tlsa_hosts.append(host)
            ttls.append(ttl)
        elif failed:
            failed_hosts.append(host)

    if tlsa_hosts:
        ttl = max(POSITIVE_TTL_MIN, min([POSITIVE_TTL_MAX] + ttls))
        return RESULT_DANE, ttl, "secure TLSA on " + ",".join(tlsa_hosts)
    if failed_hosts:
        return RESULT_TEMP, 0, "TLSA lookup failed for " + ",".join(failed_hosts)
    return RESULT_NONE, NEGATIVE_TTL, "no secure TLSA"

Ein paar Entscheidungen dahinter sind mir wichtig:

  • Der Dienst validiert DNSSEC nicht selbst. Er vertraut dem AD-Bit eines lokalen, validierenden Resolvers. Unter FreeBSD ist das typischerweise local_unbound aus dem Basissystem, das lauscht schon auf 127.0.0.1 und passt damit zu den Standardwerten des Dienstes.
  • Gemischte MX-Sets bekommen trotzdem dane-only. Haben nur manche MX-Hosts einen TLSA-Record, stellt Postfix dann nur an die Hosts zu, die es per DANE authentifizieren kann, und überspringt die anderen. Bei dane würde es auf ungeprüftes TLS zurückfallen. Das ist der bewusste Unterschied zu tlspol.
  • Fehler führen zu „später nochmal“. Ein SERVFAIL oder bogus DNSSEC ist genau das, was ein Angreifer am DNS provozieren würde. Darauf antwortet der Dienst mit TEMP, und Postfix stellt die Mail zurück. Fällt nur der TLSA-Lookup bei einem MX aus, während ein anderer MX brauchbares TLSA hat, antwortet er dane-only. Postfix prüft dann jeden Host selbst. Ist der Dienst weg, kann Postfix die Map nicht abfragen und stellt ebenfalls zurück. Setzt der Resolver beim regelmäßigen Selbsttest gegen die signierte Root-Zone kein AD-Bit, antwortet der Dienst grundsätzlich mit TEMP. In keinem Fall wird herabgestuft.
  • Cache im Speicher. Positive Antworten leben so lange wie die TTL der Records, mindestens 60 Sekunden und höchstens eine Stunde. Negative Antworten werden 5 Minuten gehalten, TEMP nie. Jede Entscheidung landet per syslog im maillog.
  • Nur Postfix darf fragen. Der Dienst läuft als eigener User danepolicy, den der Port anlegt. Der Socket liegt in einem Verzeichnis, das danepolicy:postfix gehört und Modus 0750 hat. Andere lokale Prozesse kommen nicht dran, und es gibt Limits für gleichzeitige Verbindungen und die Dauer der Lookups.

So sieht das im maillog aus:

postfix-dane-policy[13399]: domain=posteo.de result=dane reason=secure TLSA on mx01.posteo.de,mx02.posteo.de,mx03.posteo.de,mx04.posteo.de
postfix-dane-policy[13399]: domain=gmail.com result=none reason=MX not DNSSEC-validated
postfix-dane-policy[13399]: domain=evaluation.comcrypto.de result=none reason=no secure TLSA

Das Zusammenspiel in der main.cf

Der eigentliche Trick ist die Kombination aus Policy-Maps und globaler Stufe:

smtp_tls_security_level = verify
smtp_dns_support_level = dnssec
smtp_tls_policy_maps =
    socketmap:unix:/var/run/postfix_dane_policy/policy.sock:dane,
    socketmap:inet:127.0.0.1:8461:mta-sts
smtp_tls_CAfile = /usr/local/share/certs/ca-root-nss.crt
smtp_tls_mandatory_protocols = >=TLSv1.2
tls_required_enable = no
delay_warning_time = 4h

Postfix fragt die Maps der Reihe nach, der erste Treffer gewinnt. Zuerst kommt postfix-dane-policy. Hat der Empfänger DANE, gilt dane-only. Sonst fragt Postfix den MTA-STS-Resolver, und veröffentlicht der Empfänger eine MTA-STS-Policy im Modus enforce, gilt secure gegen die Hostnamen aus der Policy. Liefert keine der beiden Maps etwas, greift die globale Stufe verify: Das Zertifikat muss von einer vertrauenswürdigen CA stammen und zum MX-Hostnamen passen. DANE vor MTA-STS ist dabei keine Geschmacksfrage, so will es auch RFC 8461.

Das Ergebnis ist die Kette, die ich haben wollte: DANE, wenn veröffentlicht, sonst MTA-STS, sonst ein CA-geprüftes Zertifikat und niemals Klartext. smtp_dns_support_level = dnssec braucht Postfix, damit es selbst die AD-Bits auswertet und dane-only überhaupt umsetzen kann. Mit delay_warning_time erfährt ein Absender nach vier Stunden, dass seine Mail hängt, statt erst Tage später einen Bounce zu bekommen.

Drei Zeilen sehen unscheinbar aus, sind aber wichtig. smtp_tls_CAfile braucht verify und MTA-STS, sonst gibt es nichts, wogegen Postfix ein Zertifikat prüfen könnte. Unter FreeBSD kommt das Bundle aus dem Paket ca_root_nss. Die TLS-Mindestversion steht bewusst in smtp_tls_mandatory_protocols und nicht in smtp_tls_protocols. Letzteres gilt nur für opportunistisches TLS, bei verify, secure und dane-only zieht die mandatory-Variante, und deren Default erlaubt noch TLS 1.0. Die Manpage rät bei DANE übrigens davon ab, TLS 1.0 abzuschalten, weil ein paar DANE-Server nichts anderes können. Ich nehme das in Kauf.

Und tls_required_enable = no hat mich selbst überrascht. Seit Postfix 3.10 darf ein Absender per Header TLS-Required: no (RFC 8689) darum bitten, die TLS-Policy für seine Mail zu ignorieren. Postfix fragt dann keine Policy-Maps mehr und stellt mit may zu, also notfalls im Klartext. Das ist standardmäßig eingeschaltet. Ohne diese Zeile wäre „niemals Klartext“ also gelogen.

Vorher und nachher

Zum Prüfen eignet sich sendmail -bv sehr gut. Damit macht der Postfix-Client einen echten SMTP-Durchlauf zum Empfänger, inklusive TLS-Policy, stellt aber nichts zu. Das Ergebnis kommt als Bericht an den Absender und steht im maillog. Das sind die Werte von meinem Server vor und nach der Umstellung:

Zielvorherjetzt
posteo.dedane, Verifiedtls=dane-only, Verified
mailbox.orgdanetls=dane-only, Verified, sogar per Raw Public Key (RFC 7250)
gmail.comsecure (MTA-STS)tls=secure, Verified, Schlüsselaustausch X25519MLKEM768
Microsoft 365 (Kundendomain)may, nur „Trusted“tls=verify, Verified
verifier.port25.commay, „Untrusted“, trotzdem zugestellttls=!verify, 4.7.5, Zertifikat abgelaufen
comcrypto Downgrade-TestKlartext zugestellt (tls=may:none)Handshake-Fehler, 4.7.5, kein Klartext-Fallback

Die mailbox.org-Zeile finde ich schön, weil sie zeigt, was DANE kann und eine CA-Prüfung nicht. mailbox.org legt dort gar kein klassisches Zertifikat vor, sondern nur den nackten öffentlichen Schlüssel. Geprüft wird er gegen den TLSA-Record:

postfix/smtp[11293]: Verified TLS connection established to mx2.mailbox.org[2001:67c:2050:104:0:2:25:1]:25: TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519MLKEM768 server-signature RSA-PSS (4096 bit raw public key) server-digest SHA512
postfix/smtp[11293]: 1A23038B9A: to=<postmaster@mailbox.org>, relay=mx2.mailbox.org[2001:67c:2050:104:0:2:25:1]:25, delay=0.6, tls=dane-only, dsn=2.1.5, status=deliverable (250 2.1.5 Ok)

Die port25-Zeile ist meine Lieblingspointe. verifier.port25.com ist ein bekannter Dienst, um SPF, DKIM und DMARC zu testen, und ich schicke da seit Jahren Testmails hin. Erst heute ist aufgefallen, dass deren Zertifikat abgelaufen ist. Vorher war das meinem Postfix schlicht egal:

postfix/smtp[11301]: 2336538BA5: to=<check-auth@verifier.port25.com>, relay=verifier.port25.com[2600:1f14:a73:9b01:d769:5be1:de28:5251]:25, delay=1.8, tls=!verify, dsn=4.7.5, status=undeliverable (Server certificate not verified)

Und dann natürlich der eigentliche Gegenbeweis. Nach der Umstellung habe ich den comcrypto-Test mit einer neuen Testmail wiederholt. Statt im Klartext zugestellt zu werden, liegt sie jetzt in der Queue:

-Queue ID-  --Size-- ----Arrival Time---- -Sender/Recipient-------
DA4C538AD7     9844 Fri Nov 13 15:04:25  xxxx@kernel-error.com
                                         (Cannot start TLS: handshake failure)
                                         xxxx@evaluation.comcrypto.de

-- 9 Kbytes in 1 Request.

Im maillog steht bei jedem neuen Versuch tls=verify? und status=deferred, auch beim Wechsel auf die IPv6-Adresse des Empfängers. Nach vier Stunden bekommt der Absender eine Verzögerungswarnung, nach maximal_queue_lifetime einen Bounce. Das ist genau das Verhalten, das ich haben will: Lieber kommt eine Mail gar nicht an als unbemerkt im Klartext.

Probes sind das eine, echte Zustellungen das andere. Kurz nach der Umstellung habe ich deshalb noch Testmails an ein paar öffentliche Prüfdienste geschickt. Das maillog sagt dazu:

ZielAntwort des DienstesPostfixErgebnis
mecsa.dcslab.eu (MECSA, Mail-Security-Checker der EU-Kommission)danetls=dane-onlyzugestellt, per DANE verifiziert
mail.binsec.servicesnonetls=verifyzugestellt, Verified
mailsrv1.captaindns.comnonetls=verifyzugestellt, Verified
verifier.port25.comnonetls=!verifyzurückgehalten, Zertifikat abgelaufen
ein Wegwerf-Mail-Dienstnoneerst „TLS is required, but was not offered by host“, später tls=!verifyzurückgehalten, kein bzw. kein gültiges TLS

Über den ganzen Testzeitraum stehen im Log null Klartext-Zustellungen, kein fatal oder panic, kein einziger Socketmap-Fehler auf Postfix-Seite, und der Dienst lief durchgehend mit derselben PID. Die Prüfdienste, die selbst sauberes TLS oder DANE machen, bekommen ihre Mail ohne Probleme. Zurückgehalten wird nur, was die Anforderungen wirklich nicht erfüllt.

Nachbauen auf FreeBSD

Die Referenz ist das README im Repository, aktuell ist Version 0.3.1. Der Port liegt im Repository, die Einreichung in den offiziellen Ports-Tree folgt noch. Ein pkg install gibt es also noch nicht.

Zuerst braucht es einen validierenden Resolver. Der aus dem Basissystem reicht völlig:

sysrc local_unbound_enable=YES
service local_unbound start
drill -D posteo.de MX @127.0.0.1 | grep flags   # muss "ad" zeigen

Dann den Port aus dem Repository bauen, solange er nicht im Ports-Tree ist, und den Dienst starten. Der Port legt dabei den User danepolicy an und bringt dessen Definition selbst mit, solange der User im Ports-Tree noch nicht registriert ist:

git clone https://github.com/Kernel-Error/postfix-dane-policy
cp -R postfix-dane-policy/freebsd/mail/py-postfix-dane-policy /usr/ports/mail/
cd /usr/ports/mail/py-postfix-dane-policy && make install clean

sysrc postfix_dane_policy_enable=YES
service postfix_dane_policy start

Standardmäßig lauscht der Dienst auf dem Unix-Socket /var/run/postfix_dane_policy/policy.sock und fragt den Resolver auf 127.0.0.1, das passt zu local_unbound. Läuft Unbound woanders, etwa in einer Jail, setzt du die Adresse mit --dns über postfix_dane_policy_args in der rc.conf. TCP geht auch noch, ist aber nicht empfohlen, weil sich während eines Neustarts ein anderer lokaler Prozess den Port schnappen könnte. Ein kurzer Test von Hand:

postmap -q posteo.de socketmap:unix:/var/run/postfix_dane_policy/policy.sock:dane
# dane-only
postmap -q gmail.com socketmap:unix:/var/run/postfix_dane_policy/policy.sock:dane
# (leer, also NOTFOUND)

Für MTA-STS als zweite Map gibt es den Port mail/py-postfix-mta-sts-resolver, der lauscht standardmäßig auf Port 8461. Fehlt noch das CA-Bundle, kommt es mit pkg install ca_root_nss. Danach die main.cf wie oben anpassen, postfix reload, und mit sendmail -bv postmaster@posteo.de prüfen. Im maillog sollte dann je nach Ziel tls=dane-only, tls=secure oder tls=verify auftauchen.

Was du vorher wissen musst

Global verify hat Folgen, und die sollte man vorher kennen:

  • Empfänger ohne STARTTLS oder mit ungültigem Zertifikat sind nicht mehr erreichbar. Selbst signiert ohne DANE, abgelaufen oder falscher Name: Die Mail bleibt in der Queue, der Absender bekommt eine Warnung und später einen Bounce. Einen ersten Überblick gibt dein maillog: grep postfix/smtp /var/log/maillog | grep -E "(Untrusted|Anonymous) TLS connection|tls=[a-z]*:none". Das ist aber nur eine Vorauswahl. Auch eine Verbindung, die bisher als „Trusted“ geloggt wurde, kann an der Namensprüfung von verify scheitern. Den echten Test machst du mit sendmail -bv an die Ziele, die dir wichtig sind.
  • Bei mir hat es eine Weiterleitung erwischt. Meine Spamtraps haben ihre Mails bisher an einen externen Server ohne STARTTLS weitergereicht, rund 180 Mails pro Woche im Klartext. Die Weiterleitung habe ich abgeschaltet. Die Traps nehmen weiter an, rspamd lernt daraus, und danach wird lokal per discard: verworfen.
  • Wegwerf-Adressen und kleine Testdienste merken es zuerst. Solche Dienste haben oft gar kein oder kein gültiges TLS. Die Mail bleibt dann in der Queue, mailq zeigt dir den Grund, und nach delay_warning_time kommt die Warnung an den Absender.
  • verify hat eine eingebaute Grenze. Geprüft wird gegen den MX-Hostnamen. Ist der MX-Lookup des Empfängers nicht per DNSSEC gesichert, kann ein aktiver Angreifer die MX-Antwort fälschen und die Mail auf seinen eigenen Server umleiten, der ein gültiges Zertifikat für seinen eigenen Namen vorlegt. Diese Lücke schließen DANE und MTA-STS, oder fest eingetragene Identitäten pro Ziel. verify ist trotzdem deutlich besser als Klartext: STARTTLS zu stören reicht nicht mehr, der Angreifer muss DNS fälschen und einen eigenen Server mit passendem Zertifikat betreiben.
  • Der Dienst glaubt dem AD-Bit. Betreib ihn deshalb nur mit einem lokalen, validierenden Resolver und nicht mit einem entfernten über ein Netz, dem du nicht traust. Der Selbsttest fängt einen Resolver ab, der gar nicht validiert, aber keinen, der lügt.

Mein Fazit

Vor über zehn Jahren habe ich hier im Blog noch beschrieben, wie man Postfix ausgehend mit smtp_tls_security_level=may zum Verschlüsseln bringt. Damals war das ein Fortschritt. Heute ist es die letzte Downgrade-Lücke für ausgehende Mail, und die ist jetzt bei mir zu. DANE-Empfänger mit selbst signierten Zertifikaten bleiben erreichbar, DNS-Probleme oder ein ausgefallener Dienst führen zu „später nochmal“ und nie zu Klartext. Der Dienst ist klein, die Logik steckt in einer Datei, er ist MIT-lizenziert und lässt sich mit dem vorhandenen MTA-STS-Resolver kombinieren.

Wenn du Postfix unter FreeBSD betreibst, probier es gern aus. Issues und Pull-Requests auf GitHub sind willkommen, gerade Rückmeldungen von anderen Setups helfen mir, bevor der Port in den offiziellen Tree geht. Und falls ich irgendwo falsch liege, korrigiert mich bitte.

Quellen: RFC 7672 (SMTP Security via Opportunistic DANE TLS), RFC 8461 (MTA-STS), RFC 7435 (Opportunistic Security), Postfix TLS_README und postconf(5) zu smtp_tls_security_level.

Siehe auch: Postfix mit DANE und DNSSEC absichern, MTA-STS einrichten, Postfix: Eingehende E-Mails ohne TLS ablehnen, Post-Quantum TLS für E-Mail und Postfix 3.11.1 mit OpenSSL 3.5.

Fragen? Dann einfach fragen.

Voltcraft CM 2016: Endlich eine Linux-GUI für das Ladegerät

Seit bestimmt zehn Jahren steht hier ein Voltcraft Charge Manager CM 2016 auf dem Schreibtisch. Irgendwann bei Conrad gekauft, als die tatsächlich noch Geschäfte in der Innenstadt hatten. Damals mit zwei kleinen Kindern war der Akkuverbrauch enorm. Spielzeugautos, Taschenlampen, Fernbedienungen, irgendwas war immer leer. Einwegbatterien waren teurer als heute (zumindest in meiner Erinnerung), und so wurde das Ladegerät schnell zum wichtigsten Gerät im Haushalt.

Das CM 2016 hat sechs unabhängige Ladeschächte (vier für AA/AAA, zwei für 9V-Blöcke) und kann deutlich mehr als nur Laden. Es misst Kapazitäten, erkennt defekte Akkus, kann Lade-/Entladezyklen fahren und hält Akkus per Trickle-Charge am Leben. Wer seine Akkus ernsthaft pflegen will, braucht so ein Gerät. Damit halten die Zellen länger, man kann sie wiederaufbereiten und erkennt rechtzeitig, wann einer reif für die Tonne ist.

Voltcraft Charge Manager CM 2016 Frontansicht mit Display und eingelegtem Akku
Der Voltcraft Charge Manager CM 2016 mit eingelegtem Akku

In den letzten Jahren wurde es zugegebenermaßen weniger eingesetzt. Trotzdem laufen noch immer diverse Smarthome-Geräte und Notfall-Taschenlampen mit Akkus, und da ist ein ordentliches Ladegerät einfach Pflicht.

Das Problem: kein Linux, kein gar nichts

Das CM 2016 kommt mit einer Windows-Software. CM2016 Logger V2.10, eine .NET-Anwendung von 2013. Unter Linux funktioniert die selbstverständlich nicht. Es gibt ein paar Projekte, die das Gerät auf der Kommandozeile auslesen können, ein Java-Tool hier, ein Python-Script dort. Eine echte GUI für Linux oder FreeBSD? Fehlanzeige. Selbst als ich vor ein paar Tagen noch einmal gesucht habe: nichts. Eine kommerzielle Java-GUI existiert zwar, aber nur als 30-Tage-Trial.

Also habe ich mich selbst daran gesetzt.

Das Ergebnis: eine native GTK4-Anwendung

Das Ergebnis ist eine vollständige Desktop-Anwendung in Python mit GTK4 und libadwaita. Quelloffen, MIT-lizenziert, auf GitHub:

https://github.com/Kernel-Error/voltcraft-cm2016

Voltcraft CM 2016 GUI: Hauptfenster mit Datentabelle und Live-Aufzeichnung
Hauptfenster mit Datentabelle während einer Live-Aufzeichnung

Die App erkennt das CM 2016 automatisch per USB (Silicon Labs CP210x Chip) und zeigt alle sechs Schächte in Echtzeit an. Alle zwei Sekunden kommen neue Messdaten rein: Spannung, Strom, Kapazität, Laufzeit, Programmstatus.

Was die App kann

  • Echtzeit-Überwachung aller 6 Ladeschächte mit Autoscroll und Slot-Filterung
  • Spannungs- und Strom-Diagramme als Linien- oder Balkendiagramm mit Zeitfenster-Steuerung
  • Chart-Zoom per Maus-Drag, Scrollrad oder Tastatur, dazu Daten-Tooltips
  • Export als CSV oder Spreadsheet (.xlsx mit eingebetteten Diagrammen)
  • Druckfunktion für Messprotokolle im DIN A4 Querformat
  • Speichern und Laden von Aufzeichnungen (.cm2016 Dateien), inklusive Crash-Recovery über Temp-Dateien
  • Sleep-Inhibit: das System schläft nicht ein, solange aufgezeichnet wird
  • 7 Sprachen: Deutsch, Englisch, Französisch, Niederländisch, Italienisch, Spanisch, Polnisch
Voltcraft CM 2016 GUI: Spannungs- und Strom-Diagramme
Liniendiagramme für Spannung und Strom über die Zeit
Voltcraft CM 2016 GUI: Balkendiagramm
Balkendiagramm-Ansicht
Voltcraft CM 2016 GUI: Port-Auswahl Dialog
Port-Auswahl mit automatischer Geräteerkennung

Das Protokoll: nicht ganz so dokumentiert wie gedacht

Das CM 2016 sendet alle zwei Sekunden einen 127-Byte-Frame über die serielle Schnittstelle (19200 Baud, 8N1). Die ersten sieben Bytes sind immer CM2016 , dann folgen zehn Bytes Header und je 18 Bytes pro Ladeschacht.

Klingt einfach. Ist es auch, bis man die existierende Dokumentation mit echten Messdaten vergleicht. Dabei sind mir ein paar Dinge aufgefallen, die so nirgendwo korrekt dokumentiert waren:

  • Kapazitätsfelder sind 32-Bit Little-Endian, nicht 24-Bit wie es in mehreren Quellen steht. Charge-Capacity und Discharge-Capacity belegen jeweils vier Bytes.
  • Der dokumentierte Byte-Swap für Discharge-Capacity war falsch. Mehrere Referenzprojekte haben die Bytes in der falschen Reihenfolge gelesen, was zu absurden Kapazitätswerten geführt hat.
  • Die Header-Bytes 7-16 waren bisher größtenteils undokumentiert. Tatsächlich stecken da die Firmware-Version, die eingestellte Akku-Chemie (NiMH/NiZn), Temperaturdaten und ein Action-Counter drin. Alles Big-Endian, im Gegensatz zu den Slot-Daten, die Little-Endian sind.
  • Die Kapazitätsskalierung hängt vom Slot-Typ ab: Slots 1-4 (AA/AAA) teilen durch 100, die beiden 9V-Slots teilen durch 1000. Gleiches gilt für den Strom: AA/AAA-Slots durch 1000, 9V-Slots durch 10000.

Das alles musste mit dem echten Gerät verifiziert werden. Akku rein, verschiedene Programme durchlaufen lassen, Rohwerte mit dem Display vergleichen. Klassisches Reverse Engineering, nur eben mit Ladeströmen statt mit Netzwerkpaketen.

Technik unter der Haube

Die Anwendung nutzt GTK4 mit libadwaita für eine zeitgemäße GNOME-Oberfläche. Dark Mode funktioniert automatisch. Die Diagramme werden mit Cairo gerendert, Benachrichtigungen laufen über den libadwaita ToastOverlay. Für den seriellen Zugriff kommt pyserial zum Einsatz, die CP210x-Erkennung läuft über die USB Vendor/Product ID von Silicon Labs.

Der Spreadsheet-Export erzeugt .xlsx-Dateien mit eingebetteten Diagrammen über openpyxl. Die Druckfunktion generiert DIN A4 Querformat mit allen Slots und Diagrammen. Sessions lassen sich als .cm2016-Dateien speichern und wieder laden, und falls die Anwendung während einer Aufzeichnung abstürzt, gibt es eine automatische Recovery über Temp-Dateien.

Insgesamt 135 Unit-Tests decken Parser, Protokoll und die Export-Funktionen ab.

Installation

Die App braucht GTK 4.14+ und libadwaita 1.5+. Unter Debian/Ubuntu/Mint:

sudo apt install python3-gi python3-gi-cairo gir1.2-gtk-4.0 gir1.2-adw-1
git clone https://github.com/Kernel-Error/voltcraft-cm2016.git
cd voltcraft-cm2016
python3 -m venv --system-site-packages .venv
source .venv/bin/activate
pip install -e .

Unter Fedora:

sudo dnf install python3-gobject gtk4 libadwaita

Unter Arch:

sudo pacman -S python-gobject gtk4 libadwaita

Dann einfach cm2016 starten, USB-Kabel anschließen, fertig.

Ein .deb-Paket gibt es auf der GitHub Releases Seite. Ein Flatpak-Manifest liegt im Repository, die Einreichung bei Flathub ist eingereicht.

Falls jemand das gleiche Gerät hat und Fragen zur App oder zum Protokoll hat, einfach fragen.

Siehe auch: NB-2033-U: Reverse Engineering eines Fingerabdrucklesers für Linux

Quantis USB – Alter Quantenzufall aus der Schublade

Ich hatte noch einen Quantis USB in der Schublade liegen. Einen Hardware-Quantenzufallsgenerator von ID Quantique aus Genf. Ein Gerät, das echten Zufall erzeugt. Nicht pseudo, nicht algorithmisch, nicht „irgendwie aus Interrupts zusammengewürfelt“, sondern auf Basis von Quantenphysik. Fundamental unvorhersagbar.

Image of quantis usb

Nachdem ich in den letzten Beiträgen OpenSSH und Postfix/Dovecot mit Post-Quantum-Kryptografie abgesichert habe, fiel mir wieder ein: PQC schützt die Algorithmen vor Quantencomputern. Schön und gut. Aber was ist eigentlich mit der Zufallsquelle, die diese Algorithmen füttert? Zeit, das Teil mal wieder anzuschließen und zu schauen, was es taugt.

Was steckt in dem Gerät?

Der Quantis USB von ID Quantique ist ein sogenannter Quantum Random Number Generator, kurz QRNG. Das Prinzip dahinter: Ein Photonendetektor misst quantenoptisches Vakuumrauschen. Das sind Fluktuationen im elektromagnetischen Feld, die nach den Gesetzen der Quantenmechanik fundamental zufällig sind. Nicht „fast zufällig“ oder „praktisch zufällig“, sondern physikalisch beweisbar unvorhersagbar. Das ist ein wichtiger Unterschied zu allem, was ein Algorithmus je leisten kann. Dazu gleich mehr.

Das Gerät selbst ist fast schon enttäuschend simpel. USB 2.0 High-Speed, ein einziger Bulk-IN-Endpoint (0x86), 512 Bytes pro Read, rund 4 Mbit/s Durchsatz. Flashbare Firmware gibt es nicht. Die „Intelligenz“ steckt in der Optik und einem FPGA, nicht in Software. Das Ding macht genau eine Sache, und die macht es gut.

Mein Testgerät hat die Seriennummer 132244A410. Der Quantis USB ist inzwischen ein Legacy-Produkt, ID Quantique hat einen Nachfolger mit höherem Durchsatz im Programm. Einen öffentlichen Preis hatte das Gerät nie. „Request a Quote“, wie das bei Nischenprodukten mit Zertifizierungsanforderungen so üblich ist. Das Gerät ist METAS-zertifiziert und war für Kunden gedacht, die Common-Criteria-Anforderungen erfüllen müssen. Vergleichbare QRNGs bewegen sich im Bereich von 900 bis 2.000 Euro. Nicht gerade ein Impulskauf.

Einrichten unter Linux

Angeschlossen an mein Linux Mint 22.3 (Ubuntu 24.04 Basis) meldet sich das Gerät sofort im Kernel-Log:

$ dmesg | tail
usb 1-1: New USB device found, idVendor=0aba, idProduct=0102
usb 1-1: Product: Quantis USB
usb 1-1: Manufacturer: id Quantique
usb 1-1: SerialNumber: 132244A410

Kein spezieller Treiber nötig. Das ist ein generisches USB-Bulk-Device, der Kernel erkennt es und das war’s. Die proprietäre libquantis von ID Quantique kann man sich komplett sparen. Man kann direkt mit pyusb auf den Endpoint zugreifen. So mag ich das.

Damit das auch ohne Root funktioniert, legt man eine udev-Regel an:

# /etc/udev/rules.d/99-quantis.rules
SUBSYSTEM=="usb", ATTR{idVendor}=="0aba", ATTR{idProduct}=="0102", MODE="0666", GROUP="plugdev", TAG+="uaccess"

Danach:

$ sudo udevadm control --reload-rules && sudo udevadm trigger

Gerät abstecken, wieder anstecken, fertig. Ab jetzt kann jeder Benutzer in der Gruppe plugdev auf das Gerät zugreifen.

Daten lesen mit Python

Zum Auslesen reicht das Paket python3-usb (pyusb). Installieren via apt install python3-usb, falls nicht vorhanden. Dann braucht man erstaunlich wenig Code:

import usb.core, usb.util

dev = usb.core.find(idVendor=0x0ABA, idProduct=0x0102)
dev.set_configuration()

cfg = dev.get_active_configuration()
intf = cfg[(0, 0)]
ep = usb.util.find_descriptor(
    intf,
    custom_match=lambda e:
        usb.util.endpoint_direction(e.bEndpointAddress) == usb.util.ENDPOINT_IN
)

data = ep.read(512, timeout=5000)
print(f"{len(data)} Bytes Quantenzufall gelesen")

Das ist alles. USB öffnen, Configuration setzen, den einen IN-Endpoint finden, 512 Bytes lesen. Fertig. Kein SDK, keine Bibliothek, kein Account, kein Cloud-Dienst. USB rein, Bytes raus.

Wichtig: Immer volle 512-Byte-Blöcke lesen (wMaxPacketSize). Wer weniger anfordert, bekommt USB-Overflow-Fehler. Das Gerät kennt keine halben Sachen. Es produziert kontinuierlich Zufallsdaten und schiebt sie in den USB-Puffer. Die müssen abgeholt werden, so wie sie kommen.

Für den Test habe ich das Ganze in eine Schleife gepackt und 100.000 Bytes gesammelt. Parallel dazu 100.000 Bytes aus /dev/urandom. Beide Datensätze dann durch dieselben statistischen Tests gejagt.

Der Test: Quantis vs. /dev/urandom

Jetzt wird’s spannend. Wie gut ist echter Quantenzufall im Vergleich zum Software-PRNG des Linux-Kernels?

Spoiler: Statistisch seht ihr keinen Unterschied. Und genau das ist der Punkt.

MetrikQuantis USB/dev/urandom
Shannon-Entropie7,998513 Bits/Byte7,998077 Bits/Byte
Maximum (theoretisch)8,0000008,000000
Effizienz99,9814 %99,9760 %
Chi² (Byte-Verteilung)205,8267,3
Erwartet (Chi²)~255 ± 23~255 ± 23
Bit-Balance (Anteil Einsen)49,975 %50,018 %
Serielle Korrelation+0,001230+0,003801
Längster Bit-Run (10 kB)15 Bits21 Bits
Erwarteter Run~16~16

Die Shannon-Entropie liegt bei beiden Quellen über 99,97 % des theoretischen Maximums von 8 Bit pro Byte. Das ist hervorragend. Die Chi²-Werte zeigen eine gleichmäßige Byte-Verteilung, beide liegen im erwarteten Bereich um 255. Die Bit-Balance ist nahezu perfekt bei 50/50, die serielle Korrelation praktisch null.

In den einfachen Tests schneidet der Quantis sogar minimal besser ab: niedrigere Korrelation, gleichmäßigere Verteilung, kürzerer maximaler Bit-Run. Aber ehrlich gesagt liegt das im statistischen Rauschen. Bei 100.000 Bytes Sample-Größe kann man keine belastbare Aussage über die Überlegenheit einer Quelle treffen. Man müsste Millionen oder Milliarden Bytes testen und Testsuiten wie die NIST SP 800-22 oder Dieharder durchlaufen lassen, um wirklich statistisch signifikante Unterschiede zu finden.

Heißt das, der Quantis ist überflüssig? Nein. Denn der Unterschied liegt nicht in der Statistik.

Wo liegt dann der echte Unterschied?

Die spannende Frage ist nicht, ob die Zahlen „zufälliger“ sind, sondern warum sie es sind.

/dev/urandom verwendet intern ChaCha20, einen deterministischen CSPRNG (Cryptographically Secure Pseudo-Random Number Generator). Der initiale Seed kommt aus der Kernel-Entropie: Hardware-Interrupts, Timing-Jitter, Geräte-Events, und seit einigen Jahren auch RDRAND/RDSEED aus der CPU, falls vorhanden. Das funktioniert in der Praxis hervorragend und ist extrem gut untersucht.

Aber es bleibt ein Algorithmus mit einem internen State. Wer diesen State kennt (und sei es nur theoretisch), kann alle zukünftigen Outputs berechnen. Das ist kein realistisches Angriffsszenario für euren Laptop. Aber es ist eine fundamentale Eigenschaft: Die Sicherheit von /dev/urandom basiert auf Berechnungsannahmen. Man nimmt an, dass ChaCha20 nicht effizient invertierbar ist. Stand heute stimmt das. Aber es ist eine Annahme, kein Beweis.

Der Quantis hingegen erzeugt Zufall aus Quantenvakuum-Fluktuationen. Da gibt es keinen Algorithmus, keinen State, keinen Seed. Die Unvorhersagbarkeit ist nicht durch die Komplexität eines Algorithmus geschützt, sondern durch die Gesetze der Quantenmechanik. Kein Angreifer, egal mit welcher Rechenleistung und egal mit wie viel Zeit, kann die nächsten Bits vorhersagen. Auch kein Quantencomputer. Das ist nicht berechnungstheoretisch sicher, sondern informationstheoretisch sicher. Die höchste Sicherheitskategorie, die es gibt.

Klingt akademisch? Zum Teil. Für den Alltag auf eurem Desktop oder Server reicht /dev/urandom völlig aus. Es gibt keinen bekannten praktischen Angriff darauf, und Linux‘ CSPRNG ist schnell, überall verfügbar und gut gewartet.

Aber es gibt Szenarien, in denen der Unterschied real zählt:

  • Erzeugung kryptografischer Schlüssel mit höchsten Sicherheitsanforderungen
  • Seeding von HSMs (Hardware Security Modules), die selbst keine eigene Entropiequelle haben
  • Regulatorische und Zertifizierungsanforderungen, also Common Criteria, FIPS-Validierung, BSI-Vorgaben
  • Wissenschaftliche Experimente, die physikalisch echten Zufall benötigen (z. B. Quantenoptik, Monte-Carlo-Simulationen)
  • Quantenschlüsselaustausch (QKD), ein Bereich in dem ID Quantique ebenfalls aktiv ist

Das größere Bild: QRNG und PQC

Post-Quantum Cryptography schützt kryptografische Algorithmen davor, von Quantencomputern gebrochen zu werden. ML-KEM für den Schlüsselaustausch, ML-DSA für Signaturen. Das ist die eine Seite der Medaille.

Die andere Seite ist die Zufallsquelle. Ein kryptografischer Algorithmus kann noch so quantensicher sein. Wenn der Zufall, mit dem Schlüssel erzeugt werden, vorhersagbar oder manipulierbar ist, hilft das alles nichts. Der Zufall ist das Fundament, auf dem alles andere aufbaut.

Ein QRNG schützt genau diesen Angriffsvektor. Beides zusammen, PQC-Algorithmen und eine quantenphysikalische Zufallsquelle, ergibt ein quantum-safe Gesamtsystem. Das ist heute für die meisten von uns Overkill. Aber die Bausteine existieren, sie sind verfügbar, und es schadet nicht zu wissen, wie sie funktionieren.

Übrigens: Wer jetzt denkt „dann stecke ich den Quantis in meinen Server und bin sicher“, der macht es sich zu einfach. Die Vertrauensfrage verschiebt sich nur. Woher weiß ich, dass das Gerät tatsächlich Quantenzufall liefert und nicht einfach einen internen PRNG hat? Bei einem zertifizierten Gerät wie dem Quantis gibt es dafür Prüfberichte. Aber Vertrauen in Hardware bleibt immer ein Thema. Das ist bei Intel RDRAND nicht anders.

Einbindung ins System

Für die Vollständigkeit: Der Quantis USB lässt sich über rng-tools (rngd) als zusätzliche Entropiequelle in den Kernel-Entropiepool einbinden. Für Server mit hohem Entropie-Bedarf, also TLS-Terminierung unter Last, Massenerzeugung von Schlüsseln oder VPN-Gateways, kann das sinnvoll sein.

Ich habe das auf meinem Desktop nicht gemacht. Brauche ich dort nicht. Aber die Möglichkeit steht im Raum, falls jemand von euch einen Quantis oder ein vergleichbares Gerät an einen Server hängen möchte.

Fazit

Ein alter Hardware-QRNG, ein USB-Port, ein paar Zeilen Python, und man hat echten Quantenzufall auf dem Tisch. Statistisch nicht unterscheidbar von /dev/urandom, aber fundamental anders in der Entstehung. Die Sicherheit kommt nicht aus einem Algorithmus, sondern aus der Physik. Informationstheoretisch statt berechnungstheoretisch. Ein Unterschied, der in den allermeisten Fällen keine praktische Rolle spielt. Aber ein verdammt eleganter.

Für euren Desktop braucht ihr das nicht. Aber verstehen, warum es existiert und wie es sich einordnet, gerade im Kontext von Post-Quantum-Kryptografie, das lohnt sich. Warum denke ich jetzt an CIA und MAD? ;-D

Wie haltet ihr es mit euren Zufallsquellen? Vertraut ihr blind auf /dev/urandom, oder habt ihr euch schon mal Gedanken über die Entropiequelle dahinter gemacht?

S/MIME-Zertifikat per DNS veröffentlichen – SMIMEA

SMIMEA — S/MIME-Zertifikat per DNS veröffentlichen

Siehe auch: Volksverschlüsselung wird eingestellt, OPENPGPKEY: GPG-Schlüssel direkt im DNS veröffentlichen, Kleiner Nachtrag zum GlobalSign S/MIME Zertifikat…

Mal wieder soweit: Mein aktuelles S/MIME-Zertifikat zum Signieren von E-Mails läuft aus. Also habe ich mir ein neues besorgt. Da GlobalSign keine Class-2-Zertifikate mehr für Privatpersonen anbietet, musste ich die CA wechseln. Durch Zufall bin ich auf SSLplus gestoßen – die haben echt gute Angebote für alle möglichen Zertifikate. Aber darum soll es in diesem Beitrag nicht gehen.

Wie immer will ich mein Zertifikat öffentlich zugänglich machen, sonst müsste jeder erst eine von mir signierte E-Mail erhalten, bevor er mein Zertifikat hat. Erst dann könnten Absender mir verschlüsselte E-Mails schicken.

Dafür gibt es ein experimentelles RFC 8162, das beschreibt, wie sich ein solches Zertifikat in einer DNSSEC-geschützten Zone veröffentlichen lässt. Natürlich gibt es im Internet wieder zig verschiedene Anleitungen und Wege, um das zu realisieren. Aber nichts wirklich Zuverlässiges, was ich finden konnte. Den DNS-Record für meine Bind9-Zone wieder manuell zu erstellen, hatte ich jedenfalls keine Lust.

Also habe ich zwei kleine Python3-Skripte geschrieben:

smimea_generate_record.py

Erstellt einen kopierbaren RR für die DNS-Zone. Kann interaktiv genutzt werden: Fragt nach E-Mail-Adresse und PEM-Zertifikat. Oder direkt mit Parametern aufgerufen werden. Prüft, ob E-Mail-Adresse und Zertifikat zusammenpassen, und gibt den fertigen Record aus.

./smimea_generate_record.py
Enter the email address: kernel-error@kernel-error.com
Enter the path to the PEM certificate: mail.pem
✅ Email 'kernel-error@kernel-error.com' matches the certificate!

🔹 **Generated BIND9 DNS Record:**

70e1c7d87e825b3aba45e2a478025ea0d91d298038436abde5a4c2d0._smimecert.kernel-error.com. 3600 IN SMIMEA 3 0 0 (
   30820714308204FCA003020102021073C13C478DA7B114B871F00737F1B0FB30
   0D06092A864886F70D01010B0500304E310B300906035504061302504C312130
   1F060355040A0C1841737365636F20446174612053797374656D7320532E412E
   [... komplettes Zertifikat in Hex ...]
   7573CA35477D59B98DE4852065F58FB60E0E620D3E2F5CAD
   )

smimea_lookup.py

Fragt den SMIMEA-Record im DNS ab, lädt das Zertifikat herunter und prüft es mit OpenSSL auf Gültigkeit. Funktioniert interaktiv oder mit übergebenen Werten.

./smimea_lookup.py
Enter the email address: kernel-error@kernel-error.com

Querying DNS for SMIMEA record:
  70e1c7d87e825b3aba45e2a478025ea0d91d298038436abde5a4c2d0._smimecert.kernel-error.com

Certificate saved as smimea_cert.der
Certificate successfully retrieved and verified:

Certificate:
    Data:
        Version: 3 (0x2)
        Signature Algorithm: sha256WithRSAEncryption
        Issuer: C = PL, O = Asseco Data Systems S.A., CN = Certum SMIME RSA CA
        Validity
            Not Before: Mar 13 13:41:55 2025 GMT
            Not After : Mar 13 13:41:54 2027 GMT
        Subject: SN = van de Meer, GN = Sebastian, CN = Sebastian van de Meer,
                 emailAddress = kernel-error@kernel-error.com
        Subject Public Key Info:
            Public Key Algorithm: rsaEncryption
                Public-Key: (4096 bit)
        X509v3 Extended Key Usage:
            E-mail Protection, TLS Web Client Authentication
        X509v3 Key Usage: critical
            Digital Signature, Non Repudiation, Key Encipherment, Data Encipherment
        X509v3 Subject Alternative Name:
            email:kernel-error@kernel-error.com

Beide Skripte findet ihr auf GitHub, damit ihr sie nutzen oder verbessern könnt.

Warum viele Anleitungen falsch sind

Warum habe ich geschrieben, dass ich nichts Zuverlässiges finden konnte? Nun, oft stoße ich auf Anleitungen, die noch auf TYPE53 basieren. Das ist nötig, wenn Bind9 den eigentlichen RR-Type noch nicht kennt – also ein klares Zeichen dafür, dass es sich um eine sehr frühe Implementierung handelt.

Ein weiteres häufiges Problem: Der Hash des Local-Parts wird einfach weggelassen. Stattdessen erfolgen die Abfragen direkt auf _smimecert., was aber falsch ist. Ohne den SHA256-Hash des Local-Parts gibt es keine eindeutige Zuordnung zur jeweiligen E-Mail-Adresse.

Aufbau des SMIMEA-DNS-Records

Der erste Teil — der SHA256-Hash — sorgt dafür, dass nicht einfach jeder direkt aus der DNS-Zone die E-Mail-Adressen auslesen kann. Statt die E-Mail-Adresse im Klartext zu speichern, wird nur der SHA256-Hash des Local-Parts (also der Teil vor dem @) genutzt. Wer die genaue E-Mail-Adresse kennt, kann den passenden DNS-Eintrag finden — aber jemand, der blind durch die Zone scannt, sieht nur Hashes.

Der _smimecert-Prefix zeigt an, dass es sich um einen SMIMEA-Record handelt, ähnlich wie bei ._tcp. für SRV-Records oder _acme-challenge. für Let’s Encrypt. Und schließlich kommt die Domain, zu der die E-Mail-Adresse gehört.

Manuelle Abfrage mit dig

Möchte man die Abfrage manuell durchführen, muss man zuerst den Local-Part der E-Mail-Adresse mit SHA256 hashen. Laut RFC 8162, Abschnitt 3.1 wird der Hash auf die ersten 28 Bytes (56 Hex-Zeichen) gekürzt, um die DNS-Label-Längenbeschränkung von 63 Zeichen (RFC 1035, Abschnitt 2.3.4) einzuhalten:

echo -n "kernel-error" | sha256sum | awk '{print $1}' | cut -c1-56
70e1c7d87e825b3aba45e2a478025ea0d91d298038436abde5a4c2d0

Anschließend die dig-Abfrage:

dig +dnssec +short 70e1c7d87e825b3aba45e2a478025ea0d91d298038436abde5a4c2d0._smimecert.kernel-error.com. SMIMEA
3 0 0 30820714308204FCA003020102021073C13C478DA7B114B871F00737
F1B0FB300D06092A864886F70D01010B0500304E310B30090603550406
[... Zertifikat in Hex ...]

Was bedeuten die Felder?

  • 3 — Usage: End-Entity-Zertifikat (DANE-EE), also für die tatsächliche E-Mail-Verschlüsselung und Signatur
  • 0 — Selector: Das komplette Zertifikat wird gespeichert (alternativ: 1 für nur den Public Key)
  • 0 — Matching Type: Keine Hash-Funktion, das Zertifikat liegt im Klartext vor (alternativ: 1 für SHA-256, 2 für SHA-512)
  • Hex-Werte — Der eigentliche Zertifikatsinhalt in hexadezimaler Darstellung

Manuelle Prüfung auf der Konsole

Den kompletten DNS-Record abrufen, die SMIMEA-Parameter (3 0 0) entfernen und als Hex-Datei speichern:

dig +short 70e1c7d87e825b3aba45e2a478025ea0d91d298038436abde5a4c2d0._smimecert.kernel-error.com SMIMEA | sed 's/^3 0 0 //' | tr -d '[:space:]' > dns_cert.hex

Hex in eine binäre DER-Datei umwandeln und mit OpenSSL anzeigen:

# Hex → DER
xxd -r -p dns_cert.hex dns_cert.der

# Zertifikat anzeigen
openssl x509 -inform DER -in dns_cert.der -text -noout

Verbreitung und Ausblick

SMIMEA ist leider noch immer nicht besonders weit verbreitet. Das liegt daran, dass das RFC noch immer experimental ist, aber auch daran, dass es auf weiteren Techniken aufbaut, die ebenfalls eher selten genutzt werden. Man braucht SMIMEA nur, wenn man überhaupt ein S/MIME-Zertifikat zur Signatur und Verschlüsselung von E-Mails verwendet. Zusätzlich muss die Domain per DNSSEC geschützt sein — und dann muss auch noch der zusätzliche Mehrwert von SMIMEA verstanden werden.

Denn SMIMEA verteilt nicht nur die Zertifikate, sondern macht einen direkt initial verschlüsselt erreichbar. Wenn man der Empfänger einer solchen signierten Nachricht ist, kann man das Zertifikat zudem gegen eine vertrauenswürdige DNS-Zone halten und sich so vergewissern, dass es wirklich die Signatur des Absenders ist — ähnlich wie bei TLSA/DANE.

Die Implementierung ist aktuell sehr überschaubar. Es gibt Milter für beispielsweise Postfix oder Plugins für Thunderbird, aber vor allem im Enterprise-Umfeld ist mir momentan keine funktionierende Lösung bekannt.

Eigentlich wollte ich doch nur schnell schreiben, dass ich da zwei Python-Skripte zusammengebastelt habe — und am Ende ist es doch wieder so ein riesiges Ding geworden. Aber ich denke, vor allem der Teil mit dem gekürzten Hash des Local-Parts ist wichtig zu erklären. Das ist echt eine verrückte Konstruktion. Klar, das hat seinen Sinn, aber zumindest ich bin damals genau an diesem Punkt hängen geblieben.


Das einzig korrekt funktionierende Online-Tool, das ich finden konnte: co.tt/smimea.cgi. Alle anderen sind nicht erreichbar, halten sich nicht ans RFC oder ich war zu blöde, sie zu bedienen. Fragen? Einfach melden.

Temperatur und Luftfeuchtigkeit mit DHT22 am Raspberry Pi messen

Meine Wetterstation hatte aufgegeben. Wirklich interessiert haben mich aber eh nur Temperatur und Luftfeuchtigkeit draußen. Das sollte ein Raspberry Pi mit einem DHT22 für zwei Euro hinbekommen — und die Daten landen direkt in meinem Cacti.

Update März 2026 — Dieser Beitrag ist von 2014 und einer meiner ältesten hier im Blog. Die Grundidee — DHT22 an den GPIO, Werte per Cron einsammeln, per SNMP an Cacti liefern — funktioniert unverändert. Ich habe den Beitrag komplett überarbeitet und den Software-Teil auf Python aktualisiert. Die ursprünglich verwendete C-Bibliothek wiringPi wurde 2019 vom Autor offline genommen und lol_dht22 wird nicht mehr gepflegt. Der Ansatz selbst ist zeitlos.

Was du brauchst

  • Einen Raspberry Pi — egal welches Modell, solange GPIO-Pins vorhanden sind
  • Einen DHT22 / AM2302 Sensor (2–5 €)
  • Einen 4,7 kΩ Widerstand als Pull-up
  • Drei Kabel

Die Verkabelung ist simpel: VCC an 3,3 V (Pin 1), Data an GPIO 4 (Pin 7), GND an GND (Pin 6). Der 4,7 kΩ Widerstand kommt zwischen VCC und Data. Den handgezeichneten Schaltplan habe ich unten in der Bildergalerie.

Sensor auslesen — Python

Auf einem aktuellen Raspberry Pi OS brauchen wir die Adafruit CircuitPython DHT Bibliothek und libgpiod:

sudo apt install python3-pip libgpiod2
pip3 install adafruit-circuitpython-dht

Dann ein kleines Script /usr/local/bin/read_dht22.py:

#!/usr/bin/env python3
import adafruit_dht
import board
import sys

sensor = adafruit_dht.DHT22(board.D4)
try:
    print(f"{sensor.humidity:.1f}")
    print(f"{sensor.temperature:.1f}")
except RuntimeError:
    sys.exit(1)
finally:
    sensor.exit()

Ausführbar machen und testen:

chmod +x /usr/local/bin/read_dht22.py
/usr/local/bin/read_dht22.py
73.9
9.3

Erste Zeile Luftfeuchtigkeit, zweite Zeile Temperatur. Der DHT22 liefert nicht bei jedem Aufruf saubere Daten — manchmal kommt ein RuntimeError. Das ist normal bei diesem Sensor, deswegen der try/except und der Exit-Code. board.D4 entspricht GPIO 4, also Pin 7 auf dem Board.

Werte per Cron einsammeln

Per Cron-Job jede Minute:

* * * * * /var/scripts/getsensor.sh

Das Script /var/scripts/getsensor.sh:

#!/bin/bash
/usr/local/bin/read_dht22.py > /home/pi/both.txt 2>/dev/null

while [ ! -s "/home/pi/both.txt" ]; do
    sleep 5
    /usr/local/bin/read_dht22.py > /home/pi/both.txt 2>/dev/null
done

sed '2d' /home/pi/both.txt > /home/pi/humid.txt
sed '1d' /home/pi/both.txt > /home/pi/temp.txt

Wenn der Sensor beim ersten Versuch keine Daten liefert, probiert das Script alle fünf Sekunden erneut. Am Ende liegen Luftfeuchtigkeit und Temperatur in separaten Textdateien unter /home/pi/.

Ab in den Cacti — SNMP

Damit Cacti die Werte abfragen kann, brauchen wir SNMP auf dem Pi:

sudo apt install snmpd snmp

In der /etc/snmp/snmpd.conf zwei Pass-through OIDs anlegen. Wird eine dieser OIDs per SNMP abgefragt, führt der snmpd das zugehörige Script aus und liefert dessen Ausgabe als Antwort:

pass .1.3.6.1.2.1.25.1.8.1  /bin/sh  /usr/local/bin/humid
pass .1.3.6.1.2.1.25.1.8.2  /bin/sh  /usr/local/bin/temp

Die beiden Scripts müssen drei Zeilen ausgeben — die OID, den Datentyp und den Wert:

/usr/local/bin/temp:

#!/bin/bash
echo .1.3.6.1.2.1.25.1.8.2
echo gauge
cat /home/pi/temp.txt

/usr/local/bin/humid:

#!/bin/bash
echo .1.3.6.1.2.1.25.1.8.1
echo gauge
cat /home/pi/humid.txt

Test:

snmpget -v2c -c public localhost .1.3.6.1.2.1.25.1.8.1
iso.3.6.1.2.1.25.1.8.1 = Gauge32: 76

snmpget -v2c -c public localhost .1.3.6.1.2.1.25.1.8.2
iso.3.6.1.2.1.25.1.8.2 = Gauge32: 9

Damit lässt sich im Cacti ein Graph anlegen. Etwas von hinten durch die Brust ins Auge — aber es funktioniert seit über elf Jahren zuverlässig. Die Template-Exports für Cacti gibt es hier: cacti-temp.tar.gz


Hinweise

SNMP-Sicherheit — Im Beispiel steht public als Community-String und SNMPv2c. Für ein Heimnetz reicht das. In einem produktiven Umfeld sollte man SNMPv3 mit Authentifizierung verwenden und den Zugriff per Firewall auf den Cacti-Server beschränken.

Alternative zu Cacti — Wer kein Cacti hat: Grafana mit InfluxDB oder Prometheus wäre die modernere Alternative. Der SNMP-Weg funktioniert dort genauso, alternativ kann man die Werte auch direkt per Telegraf oder einen kleinen Python-Exporter einliefern.

Warum kein wiringPi mehr? — Gordon Henderson hat das wiringPi-Repository 2019 offline genommen. Es gibt Forks auf GitHub, die auf neueren Pi-Modellen funktionieren, aber offiziell wird die Bibliothek nicht mehr gepflegt. Für neue Projekte ist Python mit der Adafruit-Bibliothek der bessere Weg — weniger Kompilieraufwand, bessere Fehlerbehandlung und aktive Wartung.


Der Sensor da draußen

Der Sensor muss nach draußen, vor Wasser geschützt sein, aber nicht hermetisch versiegelt — sonst kann er keine Luftfeuchtigkeit messen.

Meine Lösung: Ein PVC-Rohr, den Sensor dort mit etwas Silikon eingeklebt, eine Seite mit Deckel verschlossen. So kann kein Wasser an den Sensor laufen, Luft kommt aber noch ran. Angebracht am Pfosten der Satellitenschüssel — dort oben steht die Luft selten, es kommt niemand ran und es fällt nicht auf.

Das Ding hängt dort seit 2014. Funktioniert.


Siehe auch: Raspberry Pi als Konsolenserver, Stromverbrauch messen mit Raspberry Pi, Eltako DSZ12E und Cacti

Fragen? Einfach melden.

Stromverbrauch messen mit Raspberry Pi, Eltako DSZ12E und Cacti

Im Keller hing ein alter Ferraris-Zähler mit Drehscheibe. Zählt brav für den Energieversorger, liefert aber keine Daten. Ich wollte den Stromverbrauch im Haus grafisch auswerten, am besten mit Cacti. Dafür braucht man einen Zähler mit S0-Schnittstelle.

Der Zähler

Mein Energieversorger wollte für einen digitalen Zähler Fantasiepreise. Also selbst kaufen. Die Wahl fiel auf den Eltako DSZ12E-3x80A, einen Drehstromzähler mit S0-Ausgang. 3 × 80 A reicht für den normalen Hausgebrauch locker. Kostenpunkt damals rund 75 Euro.

Wichtig: Dieser Zähler ersetzt nicht den offiziellen Zähler des Versorgers. Er wird dahinter eingebaut. Das darf nicht jeder machen. Wer nicht weiß ob er es darf, darf es nicht. Ein Elektriker braucht dafür eine halbe bis eine Stunde, mit Anfahrt kommt man auf 100 bis 150 Euro.

Zur Deutlichkeit: Bei 3×80 A reden wir über 400 V Drehstrom. Ein Fehlkontakt ist lebensgefährlich. Selbst einbauen ist keine Option, auch wenn es auf YouTube einfach aussieht. Wer ohne Elektrikerschein bastelt, riskiert nicht nur sich selbst, sondern auch den Versicherungsschutz im Haus. Nebenbei: Für die eigene Auswertung ist der Zähler prima, für Abrechnungszwecke wie WG oder Mieter gelten eichrechtliche Anforderungen, die man vorher klären sollte.

S0-Schnittstelle und Raspberry Pi

Die S0-Schnittstelle ist ein potentialfreier Impulskontakt. Pro verbrauchter Kilowattstunde gibt der Zähler eine bestimmte Anzahl Impulse aus, beim DSZ12E sind es 2000 Impulse pro kWh. Der Raspberry Pi zählt diese Impulse über einen GPIO-Pin.

Die Verkabelung ist simpel: S0-Ausgang des Zählers an einen GPIO-Pin und GND des Raspberry Pi. Ein Pullup-Widerstand sorgt dafür, dass der Pin sauber zwischen High und Low wechselt. Bei jedem Impuls wird ein Zähler hochgezählt und der aktuelle Verbrauch berechnet.

Sauberer: Optokoppler statt direkter GPIO-Anschluss

In der Praxis funktioniert der direkte Anschluss meistens, spezifikationsgerecht ist er aber nicht. Die S0-Schnittstelle ist in DIN 43864 für 27 V DC Nennspannung und 10 bis 27 mA Schleifenstrom definiert. Wer es sauber haben will, baut einen Optokoppler dazwischen, zum Beispiel einen PC817. Die S0-Leitung versorgt man mit 5 oder 12 V über einen Vorwiderstand, der Ausgang des Optokopplers schaltet galvanisch getrennt den GPIO-Pin. Vorteil: kein Potentialproblem, keine Spec-Verletzung, und die Flanken sind sauber genug, dass man auf Software-Entprellung verzichten kann.

Die Auswertung habe ich nach dieser Anleitung aufgebaut: Stromzähler mit S0-Schnittstelle vom Raspberry Pi auswerten (Johannes Weber). Ein Python-Script zählt die Impulse und stellt die Werte per SNMP bereit.

Cacti-Graphen

Cacti fragt den Raspberry Pi per SNMP ab und zeichnet die Graphen. Neben dem aktuellen Verbrauch in Watt lassen sich mit zusätzlichen SNMP-Abfragen auch Tagesverbrauch, Wochenverbrauch und Monatsverbrauch darstellen. Die Berechnung macht das Script auf dem Pi, Cacti muss nur die fertigen Werte abgreifen und zeichnen.

Das Ergebnis: Auf einen Blick sieht man wann die Waschmaschine lief, wann der Herd an war und wie hoch die Grundlast nachts ist. Verbrauchsspitzen fallen sofort auf.

Update 2026: was heute anders wäre

Der Beitrag ist von 2014, und zwölf Jahre sind in der Energiemesstechnik eine halbe Ewigkeit. Inzwischen läuft in Deutschland der Pflichtrollout für intelligente Messsysteme (iMSys) nach dem Messstellenbetriebsgesetz. Wer ein Smart-Meter-Gateway (SMGW) hat, bekommt die Daten ohnehin digital, und über die HAN-Schnittstelle (Controllable Local Systems) lassen sich Verbräuche direkt abholen. Ist der alte Ferraris-Zähler hingegen noch drin, ist ein IR-Lesekopf auf der D0-Schnittstelle (SML-Protokoll) der Weg der Wahl, gut gepflegt im Volkszähler-Projekt oder in Kombination mit Tasmota. Fertige WLAN-Messmodule wie das Shelly 3EM oder Pro 3EM liefern Drehstrommessung direkt per MQTT, ganz ohne GPIO-Basteln. Als Backend wäre heute eher Home Assistant mit dem Energy-Dashboard oder Grafana plus InfluxDB gesetzt, Cacti hat seinen Charme, aber die Zeit der Graphen mit RRDtool ist in der HomeLab-Ecke vorbei.

Siehe auch: Temperatur und Luftfeuchtigkeit mit DHT22 am Raspberry Pi messen

Fragen zum Aufbau? Einfach melden.

Parallel SSH: Kommandos auf vielen Servern gleichzeitig ausführen

Auf fünf Servern den Besitzer einer Datei ändern geht schnell. Bei 21 wird es zäh. Puppet oder Chef für einen Einzeiler hochzufahren ist Kanonen auf Spatzen. Ich nutze dafür seit Jahren pssh (Parallel SSH). Perfekt für Bash-Einzeiler, die auf vielen Systemen gleichzeitig laufen müssen.

Installation

pssh braucht Python. Die Installation geht über pip:

pip install parallel-ssh

Voraussetzung ist ein funktionierender SSH-Agent mit geladenem Key:

ssh-agent && ssh-add

Server gruppieren

Ich lege im Home einen Ordner pssh/ an und sortiere die Server in Textdateien nach Gruppen: alle Webserver, alle Mailserver, alle Server an einem Standort. Wenn ich dann ein Kommando auf einer bestimmten Gruppe ausführen will, muss ich nicht mehr nachdenken.

$ cat ~/pssh/srv.aps.ber.txt
srv.aps01.ber
srv.aps02.ber
srv.aps03.ber
[...]
srv.aps21.ber

Kommando absetzen

Das Beispiel: Auf allen 21 Applikationsservern in Berlin den Besitzer eines Scripts ändern und das Ergebnis prüfen.

$ pssh -h srv.aps.ber.txt -l root \
    -o ~/pssh/out-$(date +"%m-%d-%y_%H:%M:%S") \
    "chown aglp02:aglp02 /home/aglp02/del_import_sync.sh; \
     ls -la /home/aglp02/del_import_sync.sh;"
[1] 10:17:35 [SUCCESS] srv.aps17.ber 22
[2] 10:17:35 [SUCCESS] srv.aps03.ber 22
[3] 10:17:35 [SUCCESS] srv.aps01.ber 22
[...]
[21] 10:17:37 [SUCCESS] srv.aps18.ber 22

Die Server werden nicht nacheinander abgearbeitet, sondern gleichzeitig. 21 Server in zwei Sekunden.

Die Parameter

-h — Datei mit der Hostliste.
-l — Benutzername für den SSH-Login.
-o — Verzeichnis für die Ausgabe jedes Servers. Ich lasse mir mit date automatisch einen Unterordner mit Zeitstempel erstellen, damit die Ergebnisse zugeordnet bleiben.
Am Ende steht das Kommando in Anführungszeichen.

Ausgabe kontrollieren

Im Output-Verzeichnis liegt pro Server eine Datei mit der Bash-Ausgabe:

$ cat ~/pssh/out-09-22-14_10:17:35/srv.aps01.ber
-rwxr-xr-x 1 aglp02 aglp02 1801 Jan 21 2009 /home/aglp02/del_import_sync.sh

So lässt sich kontrollieren, ob alles sauber gelaufen ist oder ob auf einzelnen Servern nachgearbeitet werden muss.

Einmal vorbereitet, lässt sich pssh schnell in den Arbeitsalltag integrieren. Für alles, was über Einzeiler hinausgeht, greift man dann zu Ansible oder Puppet. Für den schnellen Handgriff auf 20+ Servern ist pssh genau richtig.

Siehe auch: Z Shell als bessere Shell

Fragen? Einfach melden.

Solaris gpodder

Veraltet: OpenIndiana und Solaris werden kaum noch produktiv eingesetzt. gpodder läuft problemlos unter Linux und FreeBSD.

gPodder Solaris Openindiana Opensolaris MTPDer OpenSolaris fork Openindiana und gPodder

Ich nutze zur Verwaltung meiner abonnierten Podcasts schon seit langer Zeit gPodder. Es ist schlank klein, schnell und tut nur das was ich möchte Das soll unter Openindiana nun auch so sein. Zusätzlich möchte ich auch gerne die Podcasts auf meinen Creative ZEN mozaic per MTP schieben. Hier gibt es zwar ein kleines Problem, dieses konnte ich aber für mich mit einem (ganz ganz ganz ganz bösen) Workaround lösen, davon später mehr.

Um gpodder auf mein System zu bekommen sind zusätzlich noch folgende Python Erweiterungen nötig:

– feedparser (http://code.google.com/p/feedparser/downloads/list)
– mygpoclient (http://thp.io/2010/mygpoclient/)

Einfach herunterladen, auspacken:

$ gzcat feedparser-5.0.1.tar.gz | tar xvf -
$ gzcat mygpoclient-1.6.tar.gz | tar xvf -

Und dann ganz schnell als root installieren:

$ cd feedparser
$ python setup.py build
$ python setup.py install
$ cd ..
$ cd mygpoclien
$ python setup.py build
$ python setup.py install

Man man man…. Das ging ja noch. Jetzt also gpodder (http://gpodder.org/downloads.html). Nach dem Download entpacken und dann…

$ gzcat gpodder-2.19.tar.gz | tar xvf -
$ cd gpodder
$ python setup.py build

Immer wenn ich nun ein python setup.py install gestartet habe blieb er mit folgender Meldung hängen:

error: can't copy 'data/org.gpodder.service': doesn't exist or not a regular file

Ganz braun hat mir hie folgendes geholfen:

$ cd data
$ cp org.gpodder.service.in org.gpodder.service
$ cd ..
$ org.gpodder.service

Damit lässt sich gpodder auch schon starten und benutzen. Mir fehlt nur noch die Unterstützung von MTP (http://libmtp.sourceforge.net/) nach Download und Auspacken kommt der bekannte Dreisatz zum Tragen:

$ ./configure
$ make
$ make install

Fertig…

Fertig? Na ja fast!

$ mtp-detect

erkennt meinen Player. mtp-files listet die auf dem Player befindlichen Files auf und ein mtp-sendfile schiebt eine mp3 Datei sauber und abspielbar auf den MP3-Player. Wenn ich nun im gpodder unter: Preferences ==> Devices ==> Device type: MTP einstelle. Kann ich mit der rechten Maustaste Podcasts an meinen MP3-Player senden. Diese kommen dort wirklich an und sind in der Liste auswählbar. Ich bekomme nur im MP3-Player die Meldung: „Problem bei der Audiowiedergabe“ das File wieder übersprungen und Ende. So habe ich mir das nicht vorgestellt :-/ Vor allem lassen sich Dateien abspielen, welche ich von Hand auf der Konsole per mtp-sendfile herüberschiebe. Daher müsste es doch auch über den gpodder funktionieren, oder?

Beim Auflisten der Files vom MP3-Player ist mir aber etwas spannendes aufgefallen:

$ mtp-files

File ID: 18655
Filename: 1LIVE - Comedy_ Dennis ruft an_ ANUGA (10.10.2011).mp3
File size 964156 (0x00000000000EB63C) bytes
Parent ID: 96
Storage ID: 0x00010001
Filetype: RIFF WAVE file

File ID: 8214
Filename: pofacs#093 - Commodores Homecomputer.mp3
File size 98408576 (0x0000000005DD9880) bytes
Parent ID: 96
Storage ID: 0x00010001
Filetype: ISO MPEG-1 Audio Layer 3

AHA… Der funktionsfähige, von Hand angeschobene, Podcast hat den Filetype: ISO MPEG-1 Audio Layer 3

Dieses ist für ein MP3-File auffallend korrekt. Der vom gpodder hochgeschobene Podcast hat den Filetype: RIFF WAVE file. Das kann ja nicht klappen.

Ich tippe nun mal dass es irgendwo im gpodder auf meiner Solaris Kiste ein Problem damit gibt den Filetype richtig zu erkennen oder zu setzten (Vermutung halt)… Ich habe den Quelltext nun einmal hoch und runter gescrollt aber nichts gefunden (ich bin halt kein Programmierer)…. Ich habe nur eine Liste von Filetypen gefunden mit dem Hinweiss das diese immer syncron mit den Einträgen aus der libmtp.h sein müssen.

Daher habe ich mir mal die libtmp.h.in angeschaut. Hier finden sich diese Filetypen wieder. Was soll ich sagen? An erster Stelle steht jeweils WAV… Nun zu meinem bösen Versuch (bitte nicht schimpfen) ich habe einfach den ersten Eintrag:

LIBMTP_FILETYPE_WAV,

ausgetauscht gegen:

LIBMTP_FILETYPE_MP3,

Weiter unten habe ich dann MP3 gegen WAV getauscht. Nun einfach libmtp neu übersetzen und, ja es funktioniert. Zumindest mit MP3 Files.

Bei Zeiten müsste ich mich hier wohl mal eingehender beschäftigen oder mal einen Bug aufmachen, das Problem könnte auch hausgemacht sein. Bei Zeiten…..

© 2026 -=Kernel-Error=-

Theme von Anders Norén — Hoch ↑