Base64-Dekodierung in Perl: Ein vollständiger Leitfaden

Man hat Ihnen einen String aus Buchstaben und Ziffern überreicht, das eine oder andere + oder / im Gepäck, und tief im Inneren wissen Sie, dass er nicht das ist, was er vorzeigt. Vielleicht ist es ein Token, das in einem Authorization-Header reist, eine .b64-Datei, die aus einem Support-Ticket gegraben wurde, ein Zertifikat, das seinen -----BEGIN-Panzer trägt, oder ein Blob, der sich unauffällig in einer Konfigurationsdatei eingenistet hat. Sie öffnen ein Terminal, Sie tippen perl, und eine einzige Frage übernimmt alles andere: Wie bekomme ich die echten Daten zurück?

Die Antwort ist klein und tröstlich. Perl liefert seit 2002 ein Base64-Modul direkt mit der Sprache selbst aus, und ein einziger Funktionsaufruf, decode_base64, erledigt die ganze Arbeit: nichts zu installieren, nichts zu konfigurieren. Ein kurzer Refresher, während der Kaffee zieht: Base64 schreibt jeweils drei Bytes Daten in vier Zeichen aus einem 64-Zeichen-Alphabet um und füllt das Ende mit ein oder zwei =-Zeichen auf, damit das Ergebnis immer auf ein Vielfaches von vier landet. Deshalb ist die kodierte Form typischerweise etwa 33 Prozent größer als das Ausgangsdatum. Die Startseite dieser Site erklärt das Format in voller Tiefe, also verbringt dieser Leitfaden seine ganze Zeit auf der Perl-Seite des Zauns: die Regeln des Decoders, die Dialekte und die Alltagsformate, die Sie tatsächlich antreffen werden.

Die Werkzeugkiste: Fünf Funktionen, null Installationen

Jeder Aufruf, den Sie brauchen, lebt in MIME::Base64, das seit Perl 5.8 Teil der Kernverteilung von Perl ist, und es ist damit auf jeder ernsthaften Installation vorhanden, von der in Router-Firmware eingebetteten bis zur auf einem Datenbankserver. Die Prüfung ist eine Zeile lang:

perl -MMIME::Base64 -e 'print $MIME::Base64::VERSION, "\n"'
# 3.16_01

Hier ist die Dekodier-Seite des Moduls, komplett:

Die Versionskarte für diese Funktionen, falls Sie eine Flotte alter Maschinen betreuen:

Falls Ihr System-Perl aus irgendeinem Grund das Modul vermisst, und es sollte es nicht, ist die Lösung eine von zwei Zeilen: das Distributionspaket libmime-base64-perl auf Debian und Ubuntu oder cpanm MIME::Base64, um die aktuelle Veröffentlichung von CPAN zu holen, wo das Modul seit seinen Core-Tagen als Dual-Life-Paket lebt. Für den ungewöhnlichen Rechner ohne C-Compiler bietet das reine Perl-Gegenstück MIME::Base64::Perl auf CPAN dieselbe grundlegende Schnittstelle, ein paar Mal langsamer, aber für alles außer Massenarbeit gut genug. Das ist die gesamte Abhängigkeitsgeschichte: nichts anderes.

Ein Decoder, der nie Nein sagt

Der Vertrag ist eine Zeile lang. Geben Sie ihm einen String, und er gibt Ihnen die dekodierten Bytes als ganz normalen Perl-String zurück, der rohe Oktette trägt. Keine Objekte, keine Ausnahmen, keine Flags. Die Dokumentation formuliert die zwei Regeln, die seinen Charakter prägen, in einem einzigen Satz: Jedes Zeichen, das nicht zum 65 Zeichen großen Base64-Subset gehört, wird still ignoriert, und jedes Zeichen, das nach einem =-Paddingzeichen auftaucht, wird nie dekodiert. Diese Höflichkeit ist das Wichtigste in diesem Artikel, also lassen Sie sie einmal für Sie arbeiten:

use MIME::Base64 qw(decode_base64);
print decode_base64("TWFu!"),   "\n";  # Man - das Ausrufezeichen verschwindet spurlos
print decode_base64("TWFu=XX"), "\n";  # Man - alles nach = wird übersprungen
print decode_base64("TQ"),      "\n";  # M - keine Warnung, kein Kommentar
print decode_base64("T"),       "\n";  # der leere String, immer noch keine Beschwerde

Die letzten zwei Zeilen sind die Nachsicht in ihrer Extremform. TQ trägt ein volles Byte plus vier überschüssige Bits, und der Decoder behält einfach das Byte und verwirft den Rest. T trägt nicht einmal ein volles Byte, also ist das Ergebnis leer. Es gibt keinen strengen Modus und keinen Validator im Modul, der den altmodischen Perfektionismus zurückbrächte: Seit Version 3.11 aus 2010 warnt decode_base64 nicht einmal mehr über abgeschnittene Eingabe, und ältere Versionen murrten früher eine Verfrühtes Ende der base64-Daten-Warnung unter -w aus. Wenn der Blob falsch ist, dekodiert er trotzdem, und das macht Sie zum Quality-Gate.

Hier ist die Nachsichtspolitik an einem Ort, damit Sie das Ganze auf einen Blick sehen:

Genau diese letzte Zeile ist die, die man sich merken sollte. Ein base64url-Segment, das dem Standard-Decoder übergeben wird, schlägt nicht fehl: Es dekodiert zu plausibel wirkendem Müll, weil die - und _ Zeichen als fremdes Rauschen behandelt werden, während die übrigen Buchstaben weiterhin gültige Gruppen bilden. Der Decoder ist ein Zeuge, kein Türsteher, also validieren Sie die Eingabe selbst, wenn sie nicht vertrauenswürdig ist. Ein kleiner strenger Check genügt:

sub strict_base64 {
  my ($blob) = @_;
  $blob =~ s/[\r\n]//g;  # der Decoder ignoriert diese, also tun wir es auch
  return 0 unless length($blob) % 4 == 0;
  return $blob =~ /\A[0-9A-Za-z+\/]+(?:={1,2})?\z/ ? 1 : 0;
}
print strict_base64("TWFu"),  "\n";  # 1
print strict_base64("TQ="),   "\n";  # 0 - falsche Padding-Anzahl
print strict_base64("ab-cd"), "\n";  # 0 - URL-sicheres Alphabet

Ein kleiner Hinweis zu dem regulären Ausdruck, aus einer hart erlernten Lektion: Wenn eine Sub mit einem nackten return $x =~ /.../ endet und das fehlgeschlagene Match-Ergebnis direkt in printf gefüttert wird, wirft Perl eine irreführende Fehlendes Argument in printf-Warnung aus, statt einer sauberen Null. Erzwingen Sie vor dem Return die Umwandlung des Matches mit ? 1 : 0, wie die Funktion oben es tut, und der Trick verschwindet ganz.

Erst Bytes, dann Zeichen

Denken Sie daran, was decode_base64 zurückgibt: rohe Bytes, ein gewöhnlicher String ohne gesetztes UTF-8-Flag. Was diese Bytes bedeuten, ist eine Entscheidung, die nur Sie treffen können, und genau hier stolpern die Leute über Unicode. Perl trackt, ob ein String Zeichen oder Bytes trägt, und length(), substr() sowie die meisten regulären Ausdrücke verhalten sich je nach Antwort anders. Die Lösung besteht darin, Ihre Kodierung bewusst zu benennen, mit dem Encode-Modul, das mit jeder Perl-Installation ausgeliefert wird:

use MIME::Base64 qw(decode_base64);
use Encode qw(decode);
my $raw  = decode_base64("SMOrbGxvIFdvcmxkIQ==");
my $text = decode("UTF-8", $raw);
print $text, "\n";            # Hëllo World!
print length($text), " chars\n";  # 12
print length($raw),  " bytes\n";  # 13

Dieses Zahlenpaar ist die gesamte Lektion. Der Blob hat 13 Bytes, aber nur 12 Zeichen, denn der accentierte Buchstabe belegt in UTF-8 zwei Bytes. Überspringen Sie den Zeichensatz-Schritt, und die Bytes werden trotzdem ordentlich in ein UTF-8-Terminal gedruckt, genau deshalb bleibt der Fehler unsichtbar, bis eine Zeichenkettenfunktion sie zählt, oder die Bytes durch eine Pipeline wandern, die Zeichen erwartet. Im Zweifel dekodieren Sie mit einem strengen Zeichensatz und lassen Sie die Ausnahme die Wahrheit über die Bytes sagen: Geben Sie Encode::FB_CROAK an, und decode() stirbt an ungültigen Folgen, anstatt die stillschweigende U+FFFD-Ersatzmethode des Standards zu nehmen, was ein Feature ist.

Die kurze Liste der Zeichensätze, die Sie tatsächlich zu Gesicht bekommen:

Und hier ist die Falle, vor der der Zeichensatz-Schritt Sie schützt. Wenn die dekodierten Bytes bereits UTF-8 sind und Sie sie beim Ausgang noch einmal durch encode("UTF-8", ...) jagen, bekommen Sie keine Kopie: Sie bekommen eine doppelte Kodierung, bei der jeder accentierte Buchstabe zu zwei eigenen Zeichen aufbläht. Das klassische Symptom ist Text, der früher Hëllo las und jetzt Hëllo liest, und der Empfänger auf der anderen Seite der Leitung wird das getreu dekodieren. Bytes rein, Bytes raus, eine benannte Umwandlung dazwischen.

base64url: Das Alphabet für URLs und Tokens

Die Hälfte des Base64, das das moderne Internet durchquert, ist gar nicht das Standardalphabet. Das + Zeichen ist die Art, wie ein Browser ein Leerzeichen in einem Query-String kodiert, und / ist ein Pfadtrenner, also sind die Standardbuchstaben in URLs ein Desaster. RFC 4648, Abschnitt 5, definiert die Lösung: ein zweites Alphabet, das + und / durch - und _ ersetzt, und das per Konvention auch das =-Padding und die Zeilenumbrüche weglässt. Der RFC stellt explizit klar, dass diese Kodierung nicht als dasselbe wie die base64-Kodierung betrachtet werden sollte, und Perl hat dafür seit Version 3.11 aus 2010 ein dediziertes Paar:

use MIME::Base64 qw(decode_base64url);
my $raw = decode_base64url("c3Vuc2V0LTQy");
print $raw, "\n";  # sunset-42

Zwei Dinge zu wissen. Erstens ist decode_base64url mit Eingabe ohne Padding zufrieden, und genau diese Form finden Sie in der Wildnis tatsächlich, also gilt das Ritual, zuerst das Padding wiederherzustellen, das andere Sprachen verlangen, hier nicht; gepaddete Eingabe funktioniert auch. Zweitens ist der Standard-Decoder ein anderes Tier: Füttern Sie ihm ein base64url-Segment, und Sie bekommen still und leise falsche Bytes, denn die - und _ Zeichen werden als Rauschen verworfen, und der Rest dekodiert trotzdem. Verwenden Sie den richtigen Decoder, oder normalisieren Sie von Hand, wenn Sie auf einem Legacy-Code-Pfad hängen:

my $seg = "ab-cd_efgh";
$seg =~ tr{-_}{+/};                    # die URL-sicheren Zeichen, nach Hause übersetzt
$seg .= "=" x (-length($seg) % 4);     # Padding für den Standard-Decoder wiederhergestellt
my $raw = decode_base64($seg);
print unpack("H*", $raw), "\n";  # 69bf9c77f79f82 - sieben Bytes, zurück im Standardalphabet

Sie werden base64url sofort in JWTs treffen, den Tokens, die jede moderne API herausgibt, und in jeder undurchsichtigen ID, die in einer URL lebt: elf Zeichen lange Video-IDs, UUIDs, die im URL-sicheren Alphabet gespeichert sind (CPAN hat dafür genau Data::UUID::Base64URLSafe), und Datenbank-Schlüssel, die eine Adressleiste überleben müssen. Und wenn Sie ein altes Perl nutzen, das vor den Core-Funktionen liegt, liefert das eigenständige MIME::Base64::URLSafe-Modul aus 2006, ein Port von Pythons urlsafe-Codec, urlsafe_b64encode und urlsafe_b64decode; auf allem ab 3.11 sind die eingebauten Funktionen die bessere Wahl.

JWTs: Den Header und den Payload lesen

Ein JSON Web Token ist strukturell zwei JSON-Teile in Verkleidung plus ein kryptografischer Beleg. Die kompakte Form aus RFC 7515 sind drei base64url-Segmente, verbunden durch Punkte: der geschützte Header, der Payload und die Signatur. Eines zu splitten und zu lesen sind drei Zeilen:

use MIME::Base64 qw(decode_base64url);
use JSON::PP;
my $jwt = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJob21lciJ9.uzM6l0c4...";
my ($head_b64, $claims_b64, $sig_b64) = split /\./, $jwt, 3;
my $head   = decode_json(decode_base64url($head_b64));
my $claims = decode_json(decode_base64url($claims_b64));
print $claims->{sub}, " (", $head->{alg}, ")\n";  # homer (HS256)

Beachten Sie die Arbeitsteilung: decode_base64url wandelt jedes Segment in Bytes um, und decode_json aus dem Core-Modul JSON::PP, vorhanden seit Perl 5.14, wandelt die Header- und Payload-Bytes in Perl-Datenstrukturen um. Das Signaturen-Segment ist ebenfalls base64url, aber es ist ein kryptografischer Digest, also dekodieren Sie immer nur die ersten beiden Segmente und überlassen Sie das dritte einer richtigen Bibliothek.

Die Falle ist die, die jeder vergisst: Lesbar heißt nicht gültig. Der Header und der Payload sind aus Design-Gründen lesbar, was auch bedeutet, dass jeder sie umschreiben kann; die Signatur ist der einzige Beweis. Für alles Echte: verifizieren, nicht nur dekodieren. Das CPAN-Modul Crypt::JWT, das auf CryptX aufbaut, erledigt die ganze Arbeit:

use Crypt::JWT qw(decode_jwt);
my $claims = decode_jwt(
  token        => $jwt,
  key          => $secret,
  accepted_alg => "HS256",
);

Bei einer schlechten Signatur croakt es, und das Festnageln von accepted_alg schließt das Loch der Algorithmusverwechslung, bei dem ein Angreifer den Token auf eine schwächere Variante umschaltet. Ein Workflow aus Dekodieren und Ausgeben ist für die Inspektion eines Tokens während eines Support-Anrufs gut; er ist keine Authentifizierung.

Dateien: Vom .b64 zurück zum Original

Dateien sind der Ort, an dem Perls Einzeiler-Kultur wirklich glänzt, und die ganze Arbeit passt in ein einzelnes Kommando. Das -0777-Flag ist die geheime Zutat, denn es slurpt die gesamte Datei in einen einzigen String, statt dem Decoder sie zeilenweise zu füttern:

perl -MMIME::Base64 -0777 -ne 'print decode_base64($_)' < in.b64 > out

Die zeilenweise Form ist sicher für eine bestimmte Datei-Klasse: jene, bei denen jede Zeile ein Vielfaches von vier Base64-Zeichen enthält, was bei jedem ordnungsgemäß MIME-umbrochenen Body zutrifft, da 76 ein Vielfaches von 4 ist. Im Moment, in dem die Umbruchpunkte unregelmäßig werden - und in von Hand umgebrochenen Dateien tun sie das normalerweise - beginnt das zeilenweise Dekodieren, Padding in der Mitte der Daten zu produzieren. Der Slurp-Modus hat keine solche Bedingung, deshalb ist er die Standardwahl:

perl -MMIME::Base64 -ne 'print decode_base64($_)' < in.b64 > out

In einem Skript ist das Muster der Standard-Perl-Dateitanz, mit einem stillen, aber wichtigen Detail: den :raw-Layer auf beiden Handles, damit Perl nie versucht, die Bytes beim Hinein- oder Herausgehen als Plattformtext zu interpretieren:

use MIME::Base64 qw(decode_base64);
use Digest::SHA qw(sha256_hex);
open my $in, "<:raw", $ARGV[0] or die $!;
local $/;
my $blob = <$in>;
close $in;
my $decoded = decode_base64($blob);
print sha256_hex($decoded), "\n";  # Vergleich mit der Prüfsumme des Senders
open my $out, ">:raw", $ARGV[1] or die $!;
print {$out} $decoded;
close $out;

Die Hash-Zeile ist mehr als nur Show. Weil der Decoder fast alles akzeptiert, ist eine übereinstimmende Prüfsumme mit dem, was der Sender veröffentlicht hat, der einzige Beweis, dass die Reise bytegenau war. Für wirklich riesige Dateien ist die zeilenweise Schleife die Low-Memory-Alternative, vorausgesetzt, die Umbrüche liegen auf Vier-Zeichen-Grenzen, und MIME::Base64::decoded_base64_length sagt Ihnen, wie groß die Ausgabe sein wird, bevor Sie sich auf einen Puffer festlegen.

PEM-Panzerung: Den Mantel ab, das DER behalten

Die .pem-Dateien in jedem Security-Stack sind dasselbe Base64 in Panzerung: eine Header-Zeile, eine Footer-Zeile und ein Body, der nach der alten Privacy Enhanced Mail-Konvention bei 64 Zeichen umgebrochen ist. Die Hülle ist der einzige interessante Teil, denn der Decoder des Moduls kümmert sich überhaupt nicht um Zeilenlängen:

use MIME::Base64 qw(decode_base64);
open my $fh, "<:raw", "cert.pem" or die $!;
local $/;
my $blob = <$fh>;
close $fh;
my @body = grep { !/^-----/ && /\S/ } split /\n/, $blob;
my $der = decode_base64(join "", @body);
print length($der), " bytes of DER\n";

Die BEGIN- und END-Zeilen werden gestrippt, der Rest zu einem einzigen String verbunden, und jeder Zeilenumbruch wird dabei ignoriert. Für alltägliche Zertifikatsarbeit erledigt das OpenSSL-Tooling das bereits für Sie; die acht Zeilen oben sind das Muster, das man sich merken sollte, wenn man die rohen DER-Bytes selbst braucht, für einen Hash, einen Fingerprint oder einen Vergleich.

Data-URIs: Bilder, die ihre eigene Adresse mit sich tragen

Das data:-Schema aus RFC 2397 inline einen Payload direkt in eine URL: data:, ein optionaler Medientyp, ein optionales ;base64-Flag, ein Komma und die Daten. Binäre Medien wie Bilder verwenden das Flag, also ist der Payload das Standardalphabet mit Padding, und der gewöhnliche Decoder bearbeitet ihn nach einem kleinen Schnitt:

use MIME::Base64 qw(decode_base64);
my $uri = "data:image/png;base64,iVBORw0KGgo...";
$uri =~ s/^data:[^,]+,// or die "not a data URI";
my $raw = decode_base64($uri);
print unpack("H8", $raw), "\n";  # 89504e47: die magischen Bytes der PNG

Das Prüfen der magischen Bytes ist der Schachzug. Wenn diese ersten acht Hex-Zeichen nicht 89504e47 sind, ist das Bild kein PNG, egal was der Medientyp behauptet, und ein Decoder, der sich nie beschwert, macht genau diese Art stille Lüge möglich.

Verwandte und Fossilien: uuencode und die anderen Alphabete

Bevor Base64 siegte, war der klassische UNIX-Weg, eine Binärdatei zu verschicken, uuencode, und Sie werden es immer noch in alten Mailinglisten und alten Tools treffen. Die gute Nachricht: Perl hat einen eingebauten Decoder dafür, kein Modul nötig, dank der u-Vorlage in pack und unpack:

my $uu   = pack("u", "Hello, World!");
print $uu, "\n";  # -2&5L;&\L(%=O<FQD(0`` plus ein Zeilenumbruch
my $back = unpack("u", $uu);
print $back, "\n";  # Hello, World!

Die zwei Aufrufe sind exakte Inversen, und das ist die ganze Geschichte, die Sie brauchen, und das klassische uuencode-Kommando aus der UNIX-Toolchain wickelt die nackten Zeilen einfach in einen begin-Header und einen end-Footer ein, also ist der Payload, den Sie dekodieren, der Teil dazwischen.

Base64 hat auch Dialekt-Verwandte, und zu wissen, welcher Decoder welchen frisst, spart Ihnen eine Debugging-Sitzung:

Die Kernbotschaft: Für jede Standardalphabet-Variante, die sich nur anders umbricht, deckt ein nachsichtiger Decoder alle ab. Erst wenn sich das Alphabet selbst ändert, müssen Sie die Zeichen zuerst übersetzen.

Konfiguration, Datenbanken und Umgebungsvariablen

Container-Plattformen, Cloud-Konsolen und eine überraschende Anzahl von Konfigurationsdateien speichern Zugangsdaten und kleine Dokumente als undurchsichtige Base64-Strings, denn ein Blob aus Buchstaben und Ziffern sieht weniger gefährlich aus als das Passwort, das es ist. Das Dekodieren sind immer dieselben zwei Schritte: decode_base64 plus eine Zeichensatz-Entscheidung:

use MIME::Base64 qw(decode_base64);
use Encode qw(decode);
my $secret = decode("UTF-8", decode_base64($config->{api_key}));

Der Grund, warum das Format an dieser Stelle so beliebt ist, ist genau der, vor dem RFC 4648 warnt: Menschen hören auf, zu bemerken, dass die Daten lesbar sind. Behandeln Sie die dekodierten Ausgabe also ab dem Moment, in dem sie zurückkommt, als vertraulich, und halten Sie sowohl den Blob als auch sein Ergebnis aus Logdateien, Alerten und Debug-Dumps heraus.

Dieselbe Form taucht in Datenbanken auf, wo Binärdaten oft in einer TEXT-Spalte als Base64 reisen, weil die Spalte nicht zusichern kann, beliebige Bytes unverändert durchzulassen:

use MIME::Base64 qw(decode_base64);
my $icon = decode_base64($row->{icon_data});
open my $fh, ">:raw", "icon.png" or die $!;
print {$fh} $icon;
close $fh;

E-Mail: MIME-Teile und Anhänge

E-Mail ist der Ort, an dem Base64 seinen Namen bekommen hat, und die Nachsicht des Moduls ist genau für diesen Verkehr gebaut. Ein MIME-Teil mit Content-Transfer-Encoding: base64 trifft als 76-Zeichen-Zeilen von CRLF-beendetem Text ein, und der Decoder frisst die ganze Hülle so, wie sie ist, Zeilenumbrüche inklusive:

use MIME::Base64 qw(decode_base64);
my $part_body = "SGVsbG8sIHF1ZXJ5IQpUaGlzIE1JTUUgcGFydCB0cmF2ZWxsZWQgYXMgYmFzZTY0LCB3cmFwcGVk";
$part_body .= "\r\nIGF0IDc2IGNoYXJhY3RlcnMsIENSTEYgYmV0d2VlbiBsaW5lcy4=";
my $text = decode_base64($part_body);
print $text;  # der ursprüngliche zweizeilige Nachrichtenbody

Wenn Sie E-Mail mit einem Framework bauen oder parsen, tun Sie nichts davon von Hand: MIME::Lite base64-kodiert einen Anhang für Sie, wenn Sie Encoding => "base64" an attach übergeben, und Email::MIME macht dasselbe automatisch. Die von Hand gerollte Version oben ist für die E-Mail, die als roher Text in einem Log, einem Ticket oder einer weitergeleiteten Nachricht ankommt, und das ist in der Praxis ein großer Teil davon.

Fallen, gesammelt und gerankt

Das Modul ist klein genug, um es zu memorieren, also hier die komplette Fallenliste an einem Ort, grob sortiert nach der Häufigkeit, mit der sie beißt:

Gute Gewohnheiten

Die Gewohnheiten, die Base64 davon abhalten, Ihren Skripten je überlegen zu sein:

• Bytes erwarten, immer. Schreiben Sie Code, der weiß, dass decode_base64 rohe Oktette zurückgibt, und ketten Sie den Zeichensatz-decode explizit an, anstatt zu hoffen, dass das Terminal das Richtige tut.
• Nennen Sie Ihren Zeichensatz. Standardmäßig UTF-8, und wechseln Sie nur, wenn die Daten etwas anderes sagen. Der strenge Fehlschlag von decode("UTF-8", ..., Encode::FB_CROAK) ist ein Feature: Er sagt Ihnen, dass die Bytes nicht das sind, was Sie angenommen haben.
• Passen Sie das Alphabet an die Quelle an. decode_base64url für URLs, Tokens und IDs; decode_base64 für alles andere. Die beiden Alphabete sind nicht austauschbar, und der Decoder wird Ihnen nicht sagen, wenn Sie falsch wählen.
• Validieren Sie, bevor Sie dekodieren. Es gibt kein Strict-Mode-Flag in diesem Modul, also ist ein kleiner Check der Türsteher.
• Dateien standardmäßig slurpen. -0777 oder local $/ = undef entfernt eine ganze Klasse von Umbruchpunkt-Bugs, und der Speicheraufwand ist bei den Dateien, die Sie tatsächlich dekodieren, kein Thema.
• :raw auf jedem Datei-Handle verwenden. Binär rein, binär raus. Text-Layer sind für Menschen, nicht für Bytes.
• Verifizieren Sie mit einem Hash. Wenn das Original verfügbar ist, ist eine übereinstimmende Prüfsumme der einzige Beweis für ein bytegenaues Dekodieren.
• Loggen Sie nie, was Sie dekodieren. Das Format versteckt nichts.

Eine kurze Geschichte, erzählt vom Changelog

Das Format ist alt, und Perls Verhältnis zu ihm ist älter, als es aussieht. Ein paar geprüfte Daten, in der Reihenfolge:

• Der C-Code ist älter als Perl 5. Der schnelle Decoder im Modul stammt ab von Code in metamail, dem Mail-Programm von Bellcore, urheberrechtlich geschützt 1991, drei Jahre vor der ersten Perl-5-Veröffentlichung. Wenn Sie heute decode_base64 aufrufen, leistet ein Stück der Neunziger die Arbeit.
• Geboren in den Web-Tools. Das Modul begann als LWP::Base64 in libwww-perl Mitte der Neunziger, geschrieben von Martijn Koster und Joerg Reichelt, und es promovierte zu seiner eigenen CPAN-Verteilung, MIME::Base64, im April 1997, Version 2.00, mit dem Changelog-Eintrag basiert auf libwww-perl-5.08.
• Die Warnungsära. Ab 2.03 aus 1997 produzierte abgeschnittene Eingabe eine Verfrühtes Ende der base64-Daten-Warnung unter -w statt eines Croaks, und 2.11 aus 1999 behob die Builds, die über unversehrte Daten warnten. Es war ein nervöseres Jahrzehnt für Decoder.
• Im Core seit 2002. Perl 5.8 zog das Modul in die Core-Verteilung, und die 2.13-Synchronisierung mit dem Core im selben Dezember brachte EBCDIC-Unterstützung mit, deshalb funktionieren Encoder und Decoder immer noch auf Mainframes.
• Der URL-sichere Dialekt kam 2010 in den Perl-Core. Version 3.11 fügte decode_base64url und seinen Bruder hinzu, vier Jahre nachdem das eigenständige MIME::Base64::URLSafe-Modul 2006 auf CPAN gelandet war, im selben Jahr, in dem RFC 4648 den Dialekt kodifizierte.
• Das Verstummen. Dasselbe 3.11-Release entfernte sogar die alte Abschneidewarnung, falls die verdächtige Eingabe absichtlich war - und jedes Release seither, einschließlich der aktuellen 3.16er-Linie aus 2020, hat den Decoder höflich und still gehalten.

Fun Facts, speziell Perl

Zum Abschluss der Tour die Trivia, die diese Geschichte zu einer guten machen:

• Dekodieren Sie den Namen des Formats selbst. decode_base64("YmFzZTY0") liefert base64. Das war seit 1997 wahr und wird es für immer sein.
• Der Decoder ist ein höflicher Geist. In seiner 3.x-Geschichte hat er nie eine Ausnahme bei schlechter Eingabe geworfen. Beschädigt, abgeschnitten, falsches Alphabet: Er dekodiert alles und beschwert sich über nichts, ein Verhalten, das das Changelog 2010 absichtlich zementierte.
• Der MIME-Umbruch ist absichtlich ein Vielfaches von vier. Die 76-Zeichen-Grenze ist neunzehn Dreibyter-Gruppen, 57 Bytes insgesamt, mal vier Zeichen, deshalb ist ein zeilenweises Dekodieren bei jedem ordnungsgemäß umgebrochenen MIME-Body sicher und bei allem anderen unsicher.
• uuencode druckt nie einen Kleinbuchstaben. Sein Alphabet endet beim Unterstrich, deshalb sehen alte uuencoded-Dateien aus, als wären sie von einer Großbuchstaben-Maschine getippt worden, und deshalb trägt Perl immer noch einen eingebauten Decoder für ein Format, das älter ist als das Internet.
• Perl lieferte einmal sein eigenes decode-base64-Kommando aus. Veröffentlichungen von 2.14 aus 2003 bis 3.05 aus 2004 bündelten encode-base64, decode-base64 und ihre quoted-printable-Zwillinge als Skripte; 3.06 aus 2005 verlegte sie in die eigene MIME-Base64-Scripts-Verteilung. Wenn Sie eine alte Installation mit diesem Kommando im PATH finden, wissen Sie jetzt, woher es kommt.
• YouTube-Video-IDs sind base64url in Verkleidung. Die elf Zeichen lange ID in Ihrer Adressleiste ist eine 64-Bit-Zahl im URL-sicheren Alphabet mit gestrichenem Padding, also hat jedes Video, das Sie je gesehen haben, einen Base64-String in seiner URL, und decode_base64url kann einen lesen.
• Die Nachsicht ist ein Standard, kein Bug. Die MIME-Regel, bei dem, was man akzeptiert, liberal zu sein, ist der Grund, warum dieser Decoder drei Jahrzehnte voller unordentlicher Daten überlebt, und der Grund, warum RFC 4648 warnt, dass dieselbe Nachsicht in einen verdeckten Kanal verwandelt werden kann, wenn man nicht vertrauenswürdiger Eingabe vertraut.

Wenn also das nächste Mal ein String aus Buchstaben, Ziffern, Plus und Slash in Ihrem Terminal landet, kennen Sie die ganze Geschichte. Ein Funktionsaufruf erledigt die Arbeit, der Decoder ist ein höflicher Geist, der Ihnen nie die Hand verweigert, base64url hat seinen eigenen Decoder, der Zeichensatz ist eine Entscheidung, die Sie bewusst treffen, Dateien kommen roh rein und gehen roh raus, und ein Hash ist der einzige Beweis, der zählt. Und wenn Sie eines Tages die Reise in die andere Richtung machen müssen, Ihre eigenen rohen Daten in einen Text-Umschlag wickeln und sie in die Welt schicken, deckt der verwandte Artikel über Base64-Kodierung in Perl, verlinkt unten, dieses Ritual in derselben Tiefe ab.

Zuletzt aktualisiert: 2026-09-08

Verwandter Artikel: Base64-Kodierung in Perl: Ein vollständiger Leitfaden