Base64 Decode C# — Convert.FromBase64String() Guide

In jedem .NET-Projekt, an dem ich gearbeitet habe, muss früher oder später Base64 dekodiert werden — beim Auslesen von Connection Strings aus Kubernetes-Secrets, beim Lesen binärer Payloads aus Webhooks oder beim Untersuchen von JWT-Token während einer Debugging-Session. Zum Dekodieren von Base64 in C# ist Convert.FromBase64String() die primäre Methode, die ein byte[] zurückgibt, das du dann an Encoding.UTF8.GetString() übergibst, um lesbaren Text zu erhalten. Für einen schnellen Check ohne Code zu schreiben erledigt ToolDecks Base64-Dekoder das sofort im Browser. Dieser Guide behandelt Convert.FromBase64String(), das span-basierte TryFromBase64String() für .NET 5+, die hochperformante System.Buffers.Text.Base64-API, JWT-Payload-Extraktion, Datei- und API-Response-Dekodierung, Streaming mit CryptoStream und die vier häufigsten Fehler, über die C#-Entwickler stolpern.

Was ist Base64-Dekodierung?

Base64-Kodierung wandelt Binärdaten in ein 64-Zeichen-ASCII-Alphabet um, damit sie text-only-Transport überstehen — JSON-Felder, HTTP-Header, E-Mail-Bodies, XML-Attribute. Aus jeweils 3 Bytes Eingabe werden 4 Base64-Zeichen, weshalb Base64-Ausgabe immer etwa 33% größer als das Original ist. Dekodierung kehrt diese Transformation um. Das =-Padding am Ende teilt dem Dekoder mit, wie viele Bytes aus der letzten Gruppe zu kürzen sind. Ein einzelnes = bedeutet, der letzte Block hatte 2 Bytes; == bedeutet er hatte 1 Byte. Base64 ist keine Verschlüsselung — jeder kann es rückgängig machen. Der Zweck ist sicherer Transport durch Kanäle, die rohe Binärdaten beschädigen, nicht Vertraulichkeit.

cmVkaXM6Ly9jYWNoZS1wcm9kLmludGVybmFsOjYzNzkvc2Vzc2lvbi1zdG9yZQ==

redis://cache-prod.internal:6379/session-store

Convert.FromBase64String() — Die Standard-Dekodierungsmethode

Die Methode Convert.FromBase64String() ist seit den Tagen von .NET Framework 1.1 im Framework enthalten. Keine NuGet-Pakete, keine zusätzlichen Imports außer System — einfach aufrufen und ein byte[] erhalten. Die Zwei-Schritt-Pipeline zum Dekodieren von Base64 zu einem C#-String ist immer gleich: Convert.FromBase64String() für die Bytes, dann Encoding.UTF8.GetString() zum Interpretieren dieser Bytes als Text. Der Haken: die Methode gibt rohe Bytes zurück, keinen String. Du musst das richtige Encoding wählen, um diese Bytes in Text umzuwandeln, und die Wahl ist wichtiger als die meisten erwarten. Ein falsches Encoding produziert lautlos Mojibake — unleserliche Zeichen ohne jede Exception.

Minimales funktionierendes Beispiel

using System;
using System.Text;

// Connection String als Base64 in einem Kubernetes-Secret gespeichert
string encoded = "cmVkaXM6Ly9jYWNoZS1wcm9kLmludGVybmFsOjYzNzkvc2Vzc2lvbi1zdG9yZQ==";

byte[] decodedBytes = Convert.FromBase64String(encoded);
string connectionString = Encoding.UTF8.GetString(decodedBytes);

Console.WriteLine(connectionString);
// redis://cache-prod.internal:6379/session-store

Verwende immer Encoding.UTF8, außer du hast einen spezifischen Grund dagegen. Die .NET-Runtime repräsentiert Strings intern als UTF-16, aber die meisten Daten, die Systemgrenzen überqueren (API-Responses, Konfigurationsdateien, Secrets), sind als UTF-8 kodiert. Bei Verwendung von Encoding.ASCII auf Daten, die Mehrbyte-Zeichen enthalten, werden diese lautlos durch ? ersetzt — keine Exception, nur korrumpierte Ausgabe.

Round-Trip-Überprüfung

using System;
using System.Text;

string original = "postgres://db-admin:Kx8!mQ@db-prod.us-east-1.internal:5432/orders";

// Kodieren
string encoded = Convert.ToBase64String(Encoding.UTF8.GetBytes(original));
Console.WriteLine(encoded);
// cG9zdGdyZXM6Ly9kYi1hZG1pbjpLeDghbVFAZGItcHJvZC51cy1lYXN0LTEuaW50ZXJuYWw6NTQzMi9vcmRlcnM=

// Dekodieren
byte[] decoded = Convert.FromBase64String(encoded);
string recovered = Encoding.UTF8.GetString(decoded);

Console.WriteLine(recovered == original); // True

Das richtige Encoding wählen

Das Encoding, das du an GetString() übergibst, muss mit dem übereinstimmen, das bei der ursprünglichen Kodierung der Daten verwendet wurde. Wählst du das falsche, erhältst du Zeichensalat ohne Exception — der Dekoder produziert fröhlich Unsinn. Hier ist die praktische Übersicht:

• Encoding.UTF8 — sicherer Standard. Verarbeitet ASCII und vollständiges Unicode. Verwende dies, außer du weißt es besser.
• Encoding.ASCII — nur für reine 7-Bit-ASCII-Daten. Mehrbyte-Zeichen werden zu ?.
• Encoding.Unicode — das ist UTF-16LE in .NET. Einige Windows-interne Strings und PowerShell-Exporte verwenden dies.
• Encoding.Latin1 — veraltete westeuropäische Kodierung. Taucht in alten SOAP-Services und Mainframe-Integrationen auf.

using System;
using System.Text;

// Gleiche Bytes, verschiedene Encodings — verschiedene Ergebnisse
byte[] decoded = Convert.FromBase64String("w7bDvMOk");

Console.WriteLine(Encoding.UTF8.GetString(decoded));    // oua  (korrekt)
Console.WriteLine(Encoding.ASCII.GetString(decoded));   // ??????  (verloren)
Console.WriteLine(Encoding.Latin1.GetString(decoded));  // öüä  (mojibake)

Ein wiederverwendbarer Decode-Helper mit Fehlerbehandlung

Da Convert.FromBase64String() bei fehlerhafter Eingabe wirft und das Entfernen von Leerzeichen ständig vorkommt, halte ich in den meisten Projekten einen kleinen Helper bereit:

using System;
using System.Text;

static class Base64Helper
{
    public static string? DecodeToString(string encoded)
    {
        if (string.IsNullOrWhiteSpace(encoded))
            return null;

        // Leerzeichen entfernen, die .NETs Dekoder ablehnt
        string cleaned = encoded
            .Replace("
", "")
            .Replace("
", "")
            .Replace(" ", "")
            .Trim();

        try
        {
            byte[] bytes = Convert.FromBase64String(cleaned);
            return Encoding.UTF8.GetString(bytes);
        }
        catch (FormatException)
        {
            return null; // oder eine domänenspezifische Exception werfen
        }
    }
}

// Verwendung
string? decoded = Base64Helper.DecodeToString("  cmVkaXM6Ly9jYWNoZQ==  \n");
Console.WriteLine(decoded); // redis://cache

Base64 in Nicht-Standard-Typen dekodieren

Der Dekoder gibt immer byte[] zurück. Was du mit diesen Bytes machst, hängt von den ursprünglichen Daten ab. Manchmal ist es eine GUID als 16 rohe Bytes gespeichert, manchmal eine serialisierte Protobuf-Nachricht, manchmal ein Zeitstempel im Binärformat. Hier sind die Konvertierungen, auf die ich am häufigsten zurückgreife.

Base64 zu GUID

using System;

// Einige APIs senden GUIDs als 22-stelliges Base64 statt 36-stellige Hex-Strings
string compactGuid = "C0HqetxMckKlZw4CssPUeQ==";
byte[] guidBytes = Convert.FromBase64String(compactGuid);
Guid recovered = new Guid(guidBytes);

Console.WriteLine(recovered);
// 7aea41c0-4cdc-4272-a567-0e02b2c3d479

Base64 zu deserialisiertem JSON mit System.Text.Json

using System;
using System.Text;
using System.Text.Json;

// Base64-kodierter JSON-Payload aus einer Message Queue
string encoded = "eyJzZXJ2aWNlIjoicGF5bWVudC1nYXRld2F5IiwicmVnaW9uIjoiZXUtd2VzdC0xIiwicmVwbGljYXMiOjR9";

byte[] jsonBytes = Convert.FromBase64String(encoded);
string json = Encoding.UTF8.GetString(jsonBytes);
Console.WriteLine(json);
// {"service":"payment-gateway","region":"eu-west-1","replicas":4}

// In einen Record deserialisieren
var deployEvent = JsonSerializer.Deserialize<DeployEvent>(jsonBytes);
Console.WriteLine($"{deployEvent!.Service} in {deployEvent.Region}");
// payment-gateway in eu-west-1

record DeployEvent(string Service, string Region, int Replicas);

Base64 zu Hex-String

using System;

// SHA-256-Hash als Base64 gespeichert
string hashBase64 = "n4bQgYhMfWWaL+qgxVrQFaO/TxsrC4Is0V1sFbDwCgg=";
byte[] hashBytes = Convert.FromBase64String(hashBase64);
string hex = Convert.ToHexString(hashBytes);

Console.WriteLine(hex);
// 9F86D081884C7D659A2FEAA0C55AD015A3BF4F1B2B0B822CD15D6C15B0F00A08

Referenz: Base64-Dekodierungsmethoden

.NET bietet mehrere Dekodierungsmethoden in zwei Namespaces. Die Convert-Klasse behandelt allgemeine Dekodierung, während System.Buffers.Text.Base64 auf Hochdurchsatz-Szenarien abzielt, bei denen du bereits mit rohen UTF-8-Byte-Puffern arbeitest.

Convert.TryFromBase64String() — Exception-freies Dekodieren

Das Try-Muster ist in .NET Standard für Operationen, die bei Benutzereingabe fehlschlagen können. Convert.TryFromBase64String(), verfügbar seit .NET 5, gibt einen bool zurück statt eine FormatException zu werfen. Es schreibt die dekodierten Bytes in einen vom Aufrufer bereitgestellten Span<byte>, was bedeutet, dass du für kleine Payloads stack-allokierten Speicher nutzen und den Heap vollständig umgehen kannst.

using System;
using System.Text;

string userInput = "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=";

// Stack-Allokation für kleine Payloads (< 1KB ist eine sichere Faustregel)
Span<byte> buffer = stackalloc byte[256];

if (Convert.TryFromBase64String(userInput, buffer, out int bytesWritten))
{
    string result = Encoding.UTF8.GetString(buffer[..bytesWritten]);
    Console.WriteLine(result);
    // {"host":"10.0.1.50","port":8443}
}
else
{
    Console.WriteLine("Invalid Base64 input — skipping");
}

Dieser Ansatz glänzt in Request-Middleware oder Validierungs-Pipelines, wo fehlerhafte Eingabe erwartet wird, nicht außergewöhnlich ist. Das Werfen und Fangen einer FormatException bei jeder fehlerhaften Anfrage addiert messbaren Overhead bei Skalierung — TryFromBase64String() vermeidet das vollständig.

Base64-Eingabe ohne Dekodierung validieren

Ein verbreitetes Muster in API-Controllern: prüfen, ob die Eingabe gültiges Base64 ist, bevor sie weitergeleitet wird. Du kannst TryFromBase64String() als Validator einsetzen, indem du einen Wegwerf-Puffer allokierst:

using System;

static bool IsValidBase64(string input)
{
    // Maximale dekodierte Größe berechnen
    Span<byte> buffer = stackalloc byte[((input.Length + 3) / 4) * 3];
    return Convert.TryFromBase64String(input, buffer, out _);
}

// Verwendung in einem API-Controller
Console.WriteLine(IsValidBase64("eyJob3N0IjoiMTAuMC4xLjUwIn0=")); // True
Console.WriteLine(IsValidBase64("not!!valid!!base64"));              // False
Console.WriteLine(IsValidBase64(""));                                // True (leer ist gültig)

Base64 aus einer Datei und API-Response dekodieren

Eine Base64-kodierte Datei von der Festplatte lesen

Zertifikate, verschlüsselte Blobs und Datenexportdateien werden manchmal als Base64-Text geliefert. Das typische Muster: Datei als String einlesen, Leerzeichen oder Zeilenumbrüche entfernen, die eine FormatException verursachen würden, zu Bytes dekodieren und die binäre Ausgabe schreiben. Achte auf die Fehlerbehandlung — Datei-I/O-Fehler und Base64-Formatfehler sollten getrennt abgefangen werden.

using System;
using System.IO;

string inputPath = "tls-cert.pem.b64";
string outputPath = "tls-cert.pem";

try
{
    string encoded = File.ReadAllText(inputPath).Trim();
    // Zeilenumbrüche entfernen — .NETs Dekoder lehnt sie ab
    encoded = encoded.Replace("
", "").Replace("
", "");

    byte[] decoded = Convert.FromBase64String(encoded);
    File.WriteAllBytes(outputPath, decoded);

    Console.WriteLine($"Decoded {decoded.Length} bytes -> {outputPath}");
}
catch (IOException ex)
{
    Console.Error.WriteLine($"File error: {ex.Message}");
}
catch (FormatException ex)
{
    Console.Error.WriteLine($"Invalid Base64: {ex.Message}");
}

Ein Base64-Feld aus einer HTTP-API-Response dekodieren

Cloud-APIs (Azure Key Vault, AWS Secrets Manager, GitHub Contents API) geben binäre Daten häufig als Base64-Strings in JSON zurück. Der Ablauf ist immer gleich: HTTP-Request durchführen, JSON-Response parsen, das Base64-Feld extrahieren und dekodieren. Das folgende Beispiel verwendetHttpClient und System.Text.Json — beide in .NET 6+ eingebaut.

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer sk-prod-9f8e7d6c");

try
{
    var response = await client.GetAsync("https://api.example.com/secrets/db-password");
    response.EnsureSuccessStatusCode();

    string body = await response.Content.ReadAsStringAsync();

    // API gibt zurück: {"name":"db-password","value":"cG9zdGdyZXM6eGs5bVAycVI=","version":3}
    using var doc = JsonDocument.Parse(body);
    string encodedValue = doc.RootElement.GetProperty("value").GetString()!;

    byte[] decoded = Convert.FromBase64String(encodedValue);
    string secret = Encoding.UTF8.GetString(decoded);

    Console.WriteLine($"Secret: {secret}");
    // Secret: postgres:xk9mP2qR
}
catch (HttpRequestException ex)
{
    Console.Error.WriteLine($"HTTP error: {ex.Message}");
}
catch (FormatException ex)
{
    Console.Error.WriteLine($"Base64 decode failed: {ex.Message}");
}

Base64-Dekodierung über die Kommandozeile

Du brauchst nicht immer ein kompiliertes Projekt. Das dotnet-script-Tool und PowerShell erledigen Base64-Dekodierung mit Einzeilern. Für schnelle Inspektion beim Debugging sind diese schneller als das Erstellen einer Konsolen-App.

# PowerShell (in Windows eingebaut, auch für Linux/macOS verfügbar)
[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String("eyJob3N0IjoiMTAuMC4xLjUwIn0="))
# {"host":"10.0.1.50"}

# Linux / macOS nativer base64-Befehl
echo "eyJob3N0IjoiMTAuMC4xLjUwIn0=" | base64 --decode
# {"host":"10.0.1.50"}

# macOS verwendet -D statt --decode
echo "eyJob3N0IjoiMTAuMC4xLjUwIn0=" | base64 -D

# dotnet-script (installieren: dotnet tool install -g dotnet-script)
echo 'Console.WriteLine(System.Text.Encoding.UTF8.GetString(Convert.FromBase64String("eyJob3N0IjoiMTAuMC4xLjUwIn0=")));' | dotnet-script eval

# Dekodieren und JSON mit jq ausgeben
echo "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=" | base64 --decode | jq .

Zum direkten Einfügen kodierter Strings in einen Browser verarbeitet ToolDecks Base64-Dekoder sowohl Standard- als auch URL-sichere Varianten ohne jegliche Einrichtung.

Hochperformante Alternative: System.Buffers.Text.Base64

Die System.Buffers.Text.Base64-Klasse, verfügbar seit .NET Core 2.1, arbeitet auf rohen UTF-8-Byte-Spans statt .NET-Strings. Das umgeht den Konvertierungsaufwand von String zu Bytes vollständig — keine intermediäre String-Allokation, kein UTF-16-Kodierungsschritt. Ich greife darauf in ASP.NET Core-Middleware zurück, wo die eingehenden Daten bereits als ReadOnlySpan<byte> aus dem Request-Body vorliegen. Einen string zu erstellen, nur um ihn an Convert.FromBase64String() zu übergeben, verdoppelt die Allokationen ohne Grund. In BenchmarkDotNet-Tests auf .NET 8 ist der span-basierte Pfad für Payloads unter 1 KB ungefähr 2-3x schneller, und der Abstand wächst bei größeren Eingaben, weil der GC-Druck konstant bleibt.

using System;
using System.Buffers.Text;
using System.Text;

// Rohe UTF-8-Bytes aus einem HTTP-Request-Body simulieren
byte[] utf8Input = Encoding.UTF8.GetBytes("eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=");

byte[] output = new byte[Base64.GetMaxDecodedFromUtf8Length(utf8Input.Length)];

OperationStatus status = Base64.DecodeFromUtf8(
    utf8Input, output, out int bytesConsumed, out int bytesWritten);

if (status == OperationStatus.Done)
{
    string result = Encoding.UTF8.GetString(output.AsSpan(0, bytesWritten));
    Console.WriteLine(result);
    // {"host":"10.0.1.50","port":8443}
    Console.WriteLine($"Consumed: {bytesConsumed}, Written: {bytesWritten}");
    // Consumed: 44, Written: 31
}
else
{
    Console.WriteLine($"Decode failed: {status}");
    // Möglich: InvalidData, DestinationTooSmall, NeedMoreData
}

Der Rückgabetyp ist OperationStatus — ein Enum mit vier Werten: Done, InvalidData, DestinationTooSmallund NeedMoreData. Der letzte ist nützlich für die partielle Dekodierung von Streaming-Daten. Für absolute Null-Allokation kombiniere dies mit ArrayPool<byte>.Shared.Rent() statt new byte[].

DecodeFromUtf8InPlace — Eingabepuffer überschreiben

using System;
using System.Buffers.Text;
using System.Text;

// Der Eingabepuffer wird mit den dekodierten Bytes überschrieben
byte[] data = Encoding.UTF8.GetBytes("c2VydmVyLWNvbmZpZw==");

OperationStatus status = Base64.DecodeFromUtf8InPlace(data, out int bytesWritten);

if (status == OperationStatus.Done)
{
    Console.WriteLine(Encoding.UTF8.GetString(data.AsSpan(0, bytesWritten)));
    // server-config
}

Ein Punkt zu beachten: System.Buffers.Text.Base64 verarbeitet URL-sicheres Base64 nicht direkt. Wenn die Eingabe - und _ enthält (JWT-Token beispielsweise), musst du diese trotzdem durch + und / ersetzen, bevor du diese Methoden aufrufst. Die span-basierten APIs sind strikt nach RFC 4648-Standardalphabet. Es gibt keine DecodeFromUtf8Url-Variante — eine überraschende Lücke, wenn man bedenkt, wie verbreitet Base64url in modernen APIs ist.

Terminal-Ausgabe mit Syntax-Highlighting

Die Spectre.Console-Bibliothek bietet umfangreiche Terminal-Ausgabe einschließlich JSON-Highlighting — nützlich beim Erstellen von CLI-Tools, die Base64 dekodieren und das Ergebnis anzeigen. Installiere sie mit dotnet add package Spectre.Console.

using System;
using System.Text;
using Spectre.Console;
using Spectre.Console.Json;

string encoded = "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0MywibWF4Q29ubiI6MTAwfQ==";
byte[] decoded = Convert.FromBase64String(encoded);
string json = Encoding.UTF8.GetString(decoded);

// Im Terminal farbig formatiert ausgeben
AnsiConsole.Write(new JsonText(json));
// Gibt farbiges JSON aus:
// {
//   "host": "10.0.1.50",
//   "port": 8443,
//   "maxConn": 100
// }

Das ist besonders praktisch für CLI-Tools, die Konfigurationen von Remote-Services abrufen und dekodieren. Base64-Konfiguration dekodieren, zu JSON deserialisieren und die hervorgehobene Ausgabe drucken — alles in wenigen Zeilen. Spectre.Console hat auch Tabellenrendering, Fortschrittsbalken und Baumansichten, falls du komplexere dekodierte Datenstrukturen im Terminal anzeigen musst.

Große Base64-Dateien mit CryptoStream streamen

Das Laden einer 500-MB-Base64-Datei mit File.ReadAllText() und dann Aufruf von Convert.FromBase64String() allokiert ca. 700 MB Heap: den String selbst (UTF-16, also doppelte Dateigröße) plus das dekodierte Byte-Array. Die Kombination CryptoStream + FromBase64Transform dekodiert in Blöcken und hält den Speicherverbrauch konstant.

using System.IO;
using System.Security.Cryptography;

string inputPath = "database-export.sql.b64";
string outputPath = "database-export.sql";

using var inputStream = new FileStream(inputPath, FileMode.Open, FileAccess.Read);
using var transform = new FromBase64Transform(FromBase64TransformMode.IgnoreWhiteSpaces);
using var base64Stream = new CryptoStream(inputStream, transform, CryptoStreamMode.Read);
using var outputStream = new FileStream(outputPath, FileMode.Create, FileAccess.Write);

base64Stream.CopyTo(outputStream);

Console.WriteLine($"Decoded {new FileInfo(outputPath).Length} bytes -> {outputPath}");

Das Flag FromBase64TransformMode.IgnoreWhiteSpaces verarbeitet zeilenumbrochenes Base64 (PEM-Dateien, E-Mail-Exporte) ohne manuelle Bereinigung. Ohne dieses Flag verursachen Zeilenumbrüche in der Eingabe eine FormatException. Das ist .NETs nächste Entsprechung zu Javas getMimeDecoder() — es überspringt Leerzeichen beim Dekodieren lautlos.

Der Name CryptoStream ist irreführend — Base64 hat nichts Kryptographisches. Microsoft hat FromBase64Transform in den System.Security.Cryptography-Namespace gelegt, weil es ICryptoTransform implementiert, dasselbe Interface wie AES und andere Cipher-Transforms. Der Stream selbst leitet nur Daten in Blöcken durch jede Transformation. Stell dir das als eine universelle Streaming-Transform-Pipeline vor, die zufällig im falschen Namespace landet.

Asynchrones Streaming für ASP.NET Core-Szenarien

using System.IO;
using System.Security.Cryptography;

async Task DecodeStreamAsync(Stream inputStream, string outputPath)
{
    using var transform = new FromBase64Transform(FromBase64TransformMode.IgnoreWhiteSpaces);
    using var base64Stream = new CryptoStream(inputStream, transform, CryptoStreamMode.Read);
    await using var outputStream = new FileStream(
        outputPath, FileMode.Create, FileAccess.Write, FileShare.None,
        bufferSize: 81920, useAsync: true);

    await base64Stream.CopyToAsync(outputStream);
}

// Verwendung in einem Endpoint:
// await DecodeStreamAsync(Request.Body, "uploaded-file.bin");

Einen Base64-JWT-Token-Payload in C# dekodieren

Ein JWT besteht aus drei Base64url-kodierten Segmenten, getrennt durch Punkte. Das mittlere Segment ist der Payload. Du kannst ihn dekodieren, ohne eine JWT-Bibliothek einzubinden — am Punkt aufteilen, Base64url-Zeichen normalisieren, Padding korrigieren und Convert.FromBase64String() aufrufen. Das stolpert fast jeden beim ersten Mal, weil JWT - und _ statt+ und / verwendet und das =-Padding weglässt.

using System;
using System.Text;

static string DecodeJwtPayload(string token)
{
    string[] parts = token.Split('.');
    if (parts.Length != 3)
        throw new ArgumentException($"Invalid JWT: expected 3 segments, got {parts.Length}");

    // Payload nehmen (zweites Segment)
    string payload = parts[1];

    // URL-sichere Zeichen durch Standard-Base64 ersetzen
    payload = payload.Replace('-', '+').Replace('_', '/');

    // Auf Vielfaches von 4 auffüllen
    switch (payload.Length % 4)
    {
        case 2: payload += "=="; break;
        case 3: payload += "=";  break;
    }

    byte[] bytes = Convert.FromBase64String(payload);
    return Encoding.UTF8.GetString(bytes);
}

// Mit einem real geformten Token testen
string token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9"
    + ".eyJzdWIiOiJ1c3ItNjcyIiwiaXNzIjoiYXV0aC5leGFtcGxlLmNvbSIsImV4cCI6MTc0MTk1NjgwMCwicm9sZXMiOlsiYWRtaW4iLCJiaWxsaW5nIl19"
    + ".SIGNATURE_PLACEHOLDER";

Console.WriteLine(DecodeJwtPayload(token));
// {"sub":"usr-672","iss":"auth.example.com","exp":1741956800,"roles":["admin","billing"]}

Kurzer Hinweis: Dies liest nur den Payload. Es verifiziert nicht die Signatur. Für die Auth-Validierung im Produktionsbetrieb verwende eine richtige Bibliothek wie Microsoft.IdentityModel.JsonWebTokens. Aber für Debugging, Logging und Test-Assertions reicht dieser manuelle Ansatz vollständig.

Den dekodierten JWT-Payload in ein typisiertes Objekt parsen

Sobald du den JSON-String hast, deserialisiere ihn mit System.Text.Json um auf einzelne Claims zuzugreifen, ohne String-Manipulation:

using System;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;

record JwtPayload(
    [property: JsonPropertyName("sub")] string Subject,
    [property: JsonPropertyName("iss")] string Issuer,
    [property: JsonPropertyName("exp")] long Expiration,
    [property: JsonPropertyName("roles")] string[] Roles
);

// Nach DecodeJwtPayload() von oben
string json = DecodeJwtPayload(token);
var claims = JsonSerializer.Deserialize<JwtPayload>(json)!;

Console.WriteLine($"User: {claims.Subject}");
Console.WriteLine($"Issuer: {claims.Issuer}");
Console.WriteLine($"Expires: {DateTimeOffset.FromUnixTimeSeconds(claims.Expiration):u}");
Console.WriteLine($"Roles: {string.Join(", ", claims.Roles)}");
// User: usr-672
// Issuer: auth.example.com
// Expires: 2025-03-14 12:00:00Z
// Roles: admin, billing

Häufige Fehler

Ich bin in produktiven C#-Services über jeden dieser Fehler gestolpert. Die ersten beiden verursachen den Großteil der Base64-bezogenen Bugs, die ich in Code-Reviews sehe. Jeder Fehler erscheint in Isolation offensichtlich, aber sie sind leicht zu übersehen, wenn man tief in einem größeren Feature steckt und Base64-Dekodierung nur ein Schritt in der Pipeline ist.

// Umgebungsvariable hat einen abschließenden Zeilenumbruch
string encoded = Environment.GetEnvironmentVariable("DB_PASS_B64")!;
byte[] decoded = Convert.FromBase64String(encoded);
// FormatException: The input is not a valid Base-64 string

string encoded = Environment.GetEnvironmentVariable("DB_PASS_B64")!;
string cleaned = encoded.Replace("\n", "").Replace("\r", "").Trim();
byte[] decoded = Convert.FromBase64String(cleaned);
Console.WriteLine(Encoding.UTF8.GetString(decoded));

// JWT-Payload — verwendet URL-sicheres Base64
string payload = "eyJzdWIiOiJ1c3ItNjcyIn0";
byte[] decoded = Convert.FromBase64String(payload);
// FormatException

string payload = "eyJzdWIiOiJ1c3ItNjcyIn0";
payload = payload.Replace('-', '+').Replace('_', '/');
switch (payload.Length % 4)
{
    case 2: payload += "=="; break;
    case 3: payload += "="; break;
}
byte[] decoded = Convert.FromBase64String(payload);
Console.WriteLine(Encoding.UTF8.GetString(decoded));
// {"sub":"usr-672"}

byte[] decoded = Convert.FromBase64String(pngBase64);
string imageStr = Encoding.UTF8.GetString(decoded); // korrumpiert Binärdaten
File.WriteAllText("image.png", imageStr); // kaputte Datei

byte[] decoded = Convert.FromBase64String(pngBase64);
// Bytes direkt schreiben — keine String-Konvertierung
File.WriteAllBytes("image.png", decoded);

byte[] decoded = Convert.FromBase64String(encoded);
// Encoding.Default variiert je nach Plattform
string result = Encoding.Default.GetString(decoded);

byte[] decoded = Convert.FromBase64String(encoded);
string result = Encoding.UTF8.GetString(decoded);
// konsistent unter Windows, Linux, macOS

Methodenvergleich

.NET bietet mehr Base64-Dekodierungsmethoden als die meisten Entwickler wissen. Die Tabelle unten umfasst alle eingebauten Optionen plus die zwei häufigsten Drittanbieter-Alternativen. Die Spalte "Allokation" ist am wichtigsten in hochdurchsatz-Diensten — eine Methode, die bei jedem Aufruf ein neues byte[] allokiert, erhöht den GC-Druck in engen Schleifen.

Für die tägliche Arbeit: Convert.FromBase64String(). Für Hot-Paths, wo du Benutzereingabe validierst: TryFromBase64String(). Für ASP.NET Core-Middleware, die auf rohen Request-Bytes arbeitet: Base64.DecodeFromUtf8(). Für große Dateien: CryptoStream + FromBase64Transform. BouncyCastle macht nur Sinn, wenn es bereits in deinem Dependency-Tree für andere kryptographische Operationen vorhanden ist.

Für schnelle Verifikation ohne etwas zu kompilieren ist der Online-Base64-Dekoder schneller als das Schreiben einer Einmal-Konsolen-App.

Häufig gestellte Fragen

using System;
using System.Text;

string encoded = "cG9zdGdyZXM6eGs5bVAycVI=";
byte[] bytes = Convert.FromBase64String(encoded);
string result = Encoding.UTF8.GetString(bytes);
Console.WriteLine(result);
// postgres:xk9mP2qR

using System;

string input = "maybe-not-valid-base64!!";
Span<byte> buffer = stackalloc byte[256];

if (Convert.TryFromBase64String(input, buffer, out int written))
    Console.WriteLine($"Decoded {written} bytes");
else
    Console.WriteLine("Invalid Base64 input");

string token = "eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJ1c3ItNjcyIn0.SIG";
string payload = token.Split('.')[1];
payload = payload.Replace('-', '+').Replace('_', '/');
switch (payload.Length % 4)
{
    case 2: payload += "=="; break;
    case 3: payload += "="; break;
}
byte[] bytes = Convert.FromBase64String(payload);
Console.WriteLine(Encoding.UTF8.GetString(bytes));
// {"sub":"usr-672"}

// Leerzeichen entfernen
string cleaned = rawInput.Replace("\n", "").Replace("\r", "").Trim();
byte[] decoded = Convert.FromBase64String(cleaned);

using System.IO;
using System.Security.Cryptography;

using var input = File.OpenRead("payload.b64");
using var transform = new FromBase64Transform();
using var cryptoStream = new CryptoStream(input, transform, CryptoStreamMode.Read);
using var output = File.Create("payload.bin");
cryptoStream.CopyTo(output);

Verwandte Tools

• Base64 Encoder — Text oder Binärdaten im Browser zu Base64 kodieren, nützlich zum Generieren von Test-Fixtures zum Einfügen in C#-Unit-Tests.
• JWT Decoder — alle drei JWT-Segmente auf einmal dekodieren und inspizieren, mit feldweiser Payload-Inspektion — schneller als ein C#-Helper, wenn du einfach nur einen Token lesen musst.
• URL Decoder — Percent-kodierte URL-Strings dekodieren, nützlich wenn API-Responses Base64url-Daten mit percent-kodierten Query-Parametern mischen.
• JSON Formatter — nach dem Dekodieren eines Base64-JWT-Payloads oder einer API-Konfiguration das JSON hier einfügen, um es formatiert und validiert darzustellen.