Wer schon mal Software auf GitHub heruntergeladen hat, kennt das: Ein paar Klicks, ein schneller Download – und fertig?
Leider nicht.
Zwischen "Datei herunterladen" und "Datei wirklich vertrauen" gibt es einen entscheidenden Schritt, den viele unterschätzen: die Verifizierung der Datei.

Genau dafür gibt es ASC-Signaturen.

Wenn Ihr sicherstellen wollt, dass eine Datei tatsächlich vom Entwickler stammt und unterwegs nicht von irgendwem verändert wurde, führt kein Weg an der ASC-Verifizierung vorbei.
Und das Schöne: Unter Linux ist das gar kein großer Aufwand – und sogar auf Android gibt’s Möglichkeiten, falls man wirklich ganz sicher gehen will.

Im Beitrag "Sicher downloaden auf Github mit ASC Verifizierung" schauen wir uns an:

• Was eine ASC-Datei überhaupt ist,
• warum sie wichtig ist,
• und wie Ihr sie schnell und einfach prüft.

Keine trockene Theorie, sondern praxisnah und direkt anwendbar – damit Ihr beim nächsten Download auf GitHub wirklich auf der sicheren Seite seid.

Was ist eine ASC-Datei überhaupt?

Eine .asc-Datei ist nichts anderes als eine digitale Signaturdatei, die mit GPG (GnuPG, GNU Privacy Guard) erstellt wurde.
Kurz gesagt:

• Der Entwickler erstellt eine Prüfsumme (Hash) der Datei und signiert sie mit seinem privaten Schlüssel.
• Ihr als Nutzer könnt mit dem öffentlichen Schlüssel des Entwicklers verifizieren, ob:
  • Die Datei wirklich vom angegebenen Entwickler stammt.
  • Die Datei seit dem Signieren nicht manipuliert wurde.

Das bedeutet: Mit einer ASC-Signatur stellt Ihr sicher, dass die Datei echt und unverändert ist.
Kein Hacker hat sich dazwischengehängt, keine Malware wurde eingeschleust.

Kurzform:
🔒 ASC = Digitale Echtheits- und Integritätsprüfung für Dateien.

Warum sollte man das tun?

Ganz einfach:

• Schutz vor Man-in-the-Middle-Attacken: Auf dem Weg zwischen GitHub-Server und Eurem Rechner könnten Dateien theoretisch verändert werden.
• Vertrauensprüfung: Ihr prüft, ob die Datei wirklich vom ursprünglichen Entwickler stammt, und nicht etwa von einem Angreifer, der GitHub-Accounts gekapert oder Dateien ausgetauscht hat.
• Integritätsprüfung: Selbst unbeabsichtigte Schäden (z.B. durch fehlerhafte Übertragung) würden erkannt werden.

Gerade bei wichtigen Tools (z.B. Wallets, VPN-Software, Sicherheitsanwendungen, Crypto-Tools) sollte man immer die Signaturen prüfen!

Wie macht man die ASC-Verifizierung auf Linux?

Wir schauen uns 2 Varianten an:

Variante 1: Klassische ASC-Verifizierung (Einzeldownload)

Öffentlichen Schlüssel des Entwicklers holen

• Meist verlinken seriöse Entwickler in ihrem GitHub-Repository ihren öffentlichen GPG-Schlüssel oder laden ihn auf Keyserver hoch.
• Alternativ findet Ihr ihn manchmal direkt im Repository (z.B. publickey.asc oder im Profil verlinkt).

gpg --import publickey.asc

Oder von einem Keyserver:

gpg --keyserver keyserver.ubuntu.com --recv-keys

(Die Schlüssel-ID ist eine lange Hex-Zeichenkette wie 0x1234ABCD5678EF90.)

Die Datei und die ASC-Signatur herunterladen

Nehmen wir an, Ihr wollt programm.tar.gz herunterladen.
Oft gibt es dann zusätzlich programm.tar.gz.asc.

wget https://github.com/benutzer/projekt/releases/download/v1.0.0/programm.tar.gz
wget https://github.com/benutzer/projekt/releases/download/v1.0.0/programm.tar.gz.asc

Verifikation durchführen

Jetzt prüft Ihr die Datei mit:

gpg --verify programm.tar.gz.asc programm.tar.gz

Wenn alles passt, zeigt GPG eine Meldung an wie:

gpg: Signatur vom Fr 26 Apr 2025 14:00:00 CEST
gpg: mittels RSA-Schlüssel 1234ABCD5678EF90
gpg: Gute Signatur von "Entwicklername email@example.com"

Wenn etwas nicht stimmt (z.B. Datei verändert oder falscher Schlüssel), bekommt Ihr eine fette Warnung.

Variante 2: Manifest- und Signatur-Prüfung

Viele Projekte, zum Beispiel LND (Lightning Network Daemon), verifizieren nicht jede Datei einzeln, sondern ein komplettes Manifest.
Das Manifest listet die Dateien und ihre Prüfsummen auf – und dieses Manifest wird signiert.

Schritt-für-Schritt auf Linux:

Öffentlichen Schlüssel importieren:

curl https://raw.githubusercontent.com/lightningnetwork/lnd/master/scripts/keys/roasbeef.asc | gpg --import

Manifest und Manifest-Signatur herunterladen:

Hier ein Beispiel:

• manifest-v0.19.0-beta.rc3.txt (das Manifest)
• manifest-roasbeef-v0.19.0-beta.rc3.sig (die Signatur des Manifests)

wget https://github.com/lightningnetwork/lnd/releases/download/v0.19.0-beta.rc3/manifest-v0.19.0-beta.rc3.txt

wget https://github.com/lightningnetwork/lnd/releases/download/v0.19.0-beta.rc3/manifest-roasbeef-v0.19.0-beta.rc3.sig

Manifest-Signatur verifizieren:

gpg --verify manifest-roasbeef-v0.19.0-beta.rc3.sig manifest-v0.19.0-beta.rc3.txt

Ausgabe prüfen:

Wenn alles passt, seht Ihr:

gpg: Signature made Thu Apr 24 13:37:59 2025 PDT
gpg:                using EDDSA key 296212681AADF05656A2CDEE90525F7DEEE0AD86
gpg: Good signature from "Olaoluwa Osuntokun <laolu32@gmail.com>" [ultimate]

Wichtig:
Damit habt Ihr nicht eine einzelne Datei, sondern gleich alle zugehörigen Dateien indirekt geprüft, weil sie im Manifest aufgelistet sind.

Die Integrität der gesamten Release (Binary, Checksums, Dokumentation) wird so mit einem einzigen Schritt abgesichert.

Was tun bei einer Warnung?

NICHT installieren!
Erst mal prüfen:

• Habt Ihr den richtigen öffentlichen Schlüssel?
• Stimmt die Quelle?
• Hat der Entwickler vielleicht den Schlüssel aktualisiert?
• Ansonsten lieber beim Entwickler oder Projekt nachfragen.

Gibt es ASC-Verifikation auf Android?

Jein.

Android selbst (also das System) bringt keine eingebaute GPG-Unterstützung mit.
Aber es gibt Apps, mit denen ihr GPG verwenden könnt:

Möglichkeiten:

• OpenKeychain (freie App, im F-Droid Store verfügbar)
  → Damit kannst Du Schlüssel verwalten und Signaturen prüfen.
• Termux (Linux-Terminal für Android)
  → Installiere dort gnupg, und Du hast quasi ein Mini-Linux auf dem Handy:

pkg install gnupg

Damit könntest Du dann wie unter Linux vorgehen.
Das wäre der "saubere" Weg.

Praxis-Tipp:
Die meisten normalen Nutzer verifizieren Downloads lieber am PC oder Laptop, weil es komfortabler und sicherer ist.
Aber ja: Mit OpenKeychain oder Termux geht es auch auf Android.

Weitere Sicherheitsprüfung mit Checksummen Überprüfung

Wenn Ihr noch einen Schritt weitergehen wollt und zusätzlich zur Signatur auch die Datei selbst überprüfen möchtet, dann schaut Euch unbedingt diesen Beitrag an.
Darin erkläre wir ganz genau, wie ihr Checksummen überprüft – also MD5, SHA256 und Co. – und warum das eine perfekte Ergänzung zur ASC- oder Manifest-Verifizierung ist.

Fazit

ASC-Verifizierung ist ein einfacher, aber extrem wichtiger Schritt, um Eure Sicherheit beim Download von GitHub oder anderen Quellen massiv zu erhöhen.
Gerade auf Linux ist die Verifikation unkompliziert und sollte wirklich zur Routine gehören – genau wie das Prüfen von https-Zertifikaten beim Surfen.

Auf Android ist es möglich, aber nicht ganz so komfortabel. Hier lohnt sich Termux oder OpenKeychain, wenn man unterwegs ebenfalls auf Nummer sicher gehen will.

Merkt:
"Vertrauen ist gut, Verifizieren ist besser!"

Wir hoffen der Beitrag "Sicher downloaden auf Github mit ASC Verifizierung" hat euch gefallen, und hilft Euch, Eures Arbeiten Im Internet weiter abzusichern.