Decode Base64 di C# — Panduan Convert.FromBase64String()

Setiap proyek .NET yang pernah saya kerjakan akhirnya membutuhkan dekode Base64 — mengambil connection string dari Kubernetes secret, membaca payload biner dari webhook, atau memeriksa token JWT saat sesi debugging. Untuk mendekode Base64 di C#, metode utamanya adalah Convert.FromBase64String(), yang mengembalikanbyte[] yang kemudian diteruskan ke Encoding.UTF8.GetString() untuk mendapatkan teks yang dapat dibaca. Untuk pemeriksaan cepat tanpa menulis kode, Base64 decoder ToolDeck menanganinya secara instan di browser. Panduan ini mencakup Convert.FromBase64String(),TryFromBase64String() berbasis span untuk .NET 5+, API System.Buffers.Text.Base64 berperforma tinggi, ekstraksi payload JWT, dekode file dan respons API, streaming dengan CryptoStream, dan empat kesalahan yang paling sering dilakukan developer C#.

Apa Itu Dekode Base64?

Encoding Base64 mengonversi data biner ke alfabet ASCII 64 karakter agar dapat melewati transport teks saja — field JSON, header HTTP, isi email, atribut XML. Setiap 3 byte input menjadi 4 karakter Base64, itulah mengapa output Base64 selalu sekitar 33% lebih besar dari aslinya. Dekode membalikkan transformasi ini. Padding = di akhir memberi tahu decoder berapa byte yang harus dipangkas dari grup terakhir. Satu = berarti blok terakhir punya 2 byte; == berarti punya 1 byte. Base64 bukan enkripsi — siapa pun bisa membalikkannya. Tujuannya adalah transport aman melalui saluran yang merusak biner mentah, bukan kerahasiaan.

cmVkaXM6Ly9jYWNoZS1wcm9kLmludGVybmFsOjYzNzkvc2Vzc2lvbi1zdG9yZQ==

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

Convert.FromBase64String() — Metode Dekode Standar

Metode Convert.FromBase64String() sudah ada di .NET sejak masa Framework 1.1. Tidak perlu paket NuGet, tidak perlu import tambahan selain System — cukup panggil dan dapatkan byte[]. Pipeline dua langkah untuk mendekode Base64 ke string C# selalu sama: Convert.FromBase64String() untuk mendapatkan byte, lalu Encoding.UTF8.GetString() untuk menginterpretasikan byte tersebut sebagai teks. Perlu diingat bahwa metode ini mengembalikan byte mentah, bukan string. Anda perlu memilihEncoding yang tepat untuk mengonversi byte kembali ke teks, dan pilihan ini lebih penting dari yang diperkirakan kebanyakan orang. Encoding yang salah diam-diam menghasilkan mojibake — karakter kacau tanpa exception untuk memperingatkan Anda.

Contoh minimal yang berfungsi

using System;
using System.Text;

// Connection string disimpan sebagai Base64 di Kubernetes secret
string encoded = "cmVkaXM6Ly9jYWNoZS1wcm9kLmludGVybmFsOjYzNzkvc2Vzc2lvbi1zdG9yZQ==";

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

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

Selalu gunakan Encoding.UTF8 kecuali ada alasan spesifik untuk tidak melakukannya. Runtime .NET merepresentasikan string secara internal sebagai UTF-16, tetapi sebagian besar data yang melewati batas sistem (respons API, file config, secret) di-encode sebagai UTF-8. Menggunakan Encoding.ASCII pada data yang mengandung karakter multi-byte diam-diam menggantinya dengan ? — tidak ada exception, hanya output yang rusak.

Verifikasi round-trip

using System;
using System.Text;

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

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

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

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

Memilih Encoding yang tepat

Encoding yang Anda teruskan ke GetString() harus cocok dengan yang digunakan saat data asli di-encode. Pilih yang salah dan Anda mendapatkan karakter sampah tanpa exception — decoder dengan senang hati menghasilkan omong kosong. Berikut penjelasan praktisnya:

• Encoding.UTF8 — default yang aman. Menangani ASCII dan semua Unicode. Gunakan ini kecuali Anda tahu sebaliknya.
• Encoding.ASCII — hanya untuk data ASCII 7-bit murni. Karakter multi-byte menjadi ?.
• Encoding.Unicode — ini adalah UTF-16LE di .NET. Beberapa string internal Windows dan ekspor PowerShell menggunakannya.
• Encoding.Latin1 — encoding Western European lama. Muncul di layanan SOAP lama dan integrasi mainframe.

using System;
using System.Text;

// Byte yang sama, encoding berbeda — hasil berbeda
byte[] decoded = Convert.FromBase64String("w7bDvMOk");

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

Helper decode yang dapat digunakan kembali dengan penanganan error

Karena Convert.FromBase64String() melempar exception pada input buruk dan proses pembersihan spasi sering dilakukan berulang kali, saya menyimpan helper kecil di sebagian besar proyek:

using System;
using System.Text;

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

        // Hapus spasi yang ditolak decoder .NET
        string cleaned = encoded
            .Replace("
", "")
            .Replace("
", "")
            .Replace(" ", "")
            .Trim();

        try
        {
            byte[] bytes = Convert.FromBase64String(cleaned);
            return Encoding.UTF8.GetString(bytes);
        }
        catch (FormatException)
        {
            return null; // atau lempar exception domain-spesifik
        }
    }
}

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

Mendekode Base64 ke Tipe Non-Standar

Decoder selalu memberi Anda byte[]. Apa yang Anda lakukan dengan byte tersebut bergantung pada data aslinya. Kadang berupa GUID yang disimpan sebagai 16 byte mentah, kadang pesan protobuf yang diserialisasi, kadang timestamp dalam format biner. Berikut konversi yang paling sering saya gunakan.

Base64 ke GUID

using System;

// Beberapa API mengirim GUID sebagai Base64 22 karakter, bukan string hex 36 karakter
string compactGuid = "C0HqetxMckKlZw4CssPUeQ==";
byte[] guidBytes = Convert.FromBase64String(compactGuid);
Guid recovered = new Guid(guidBytes);

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

Base64 ke JSON yang dideserialisi dengan System.Text.Json

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

// Payload JSON ter-encode Base64 dari 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}

// Deserialisi ke record
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 ke string hex

using System;

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

Console.WriteLine(hex);
// 9F86D081884C7D659A2FEAA0C55AD015A3BF4F1B2B0B822CD15D6C15B0F00A08

Referensi Metode Dekode Base64

.NET menyediakan beberapa metode dekode di dua namespace. Kelas Convert menangani dekode serba guna, sementara System.Buffers.Text.Base64 menargetkan skenario throughput tinggi di mana Anda sudah bekerja dengan buffer byte UTF-8 mentah.

Convert.TryFromBase64String() — Dekode Tanpa Exception

Pola Try adalah standar di .NET untuk operasi yang mungkin gagal pada input pengguna. Convert.TryFromBase64String(), tersedia sejak .NET 5, mengembalikan bool alih-alih melempar FormatException. Metode ini menulis byte yang didekode ke Span<byte> yang disediakan pemanggil, yang berarti Anda bisa menggunakan memori yang dialokasikan di stack untuk payload kecil dan melewatkan heap sepenuhnya.

using System;
using System.Text;

string userInput = "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=";

// Alokasikan di stack untuk payload kecil (< 1KB adalah aturan praktis yang aman)
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("Input Base64 tidak valid — melewati");
}

Pendekatan ini sangat berguna dalam middleware request atau pipeline validasi di mana input buruk adalah hal yang diharapkan, bukan pengecualian. Melempar dan menangkapFormatException pada setiap request yang salah format menambahkan overhead yang terukur pada skala besar — TryFromBase64String() menghindari hal itu sepenuhnya.

Memvalidasi input Base64 tanpa mendekode

Pola umum di API controller: periksa apakah input adalah Base64 yang valid sebelum meneruskannya ke hilir. Anda bisa menggunakan TryFromBase64String() sebagai validator dengan mengalokasikan buffer yang dibuang:

using System;

static bool IsValidBase64(string input)
{
    // Hitung ukuran dekode maksimum
    Span<byte> buffer = stackalloc byte[((input.Length + 3) / 4) * 3];
    return Convert.TryFromBase64String(input, buffer, out _);
}

// Penggunaan di API controller
Console.WriteLine(IsValidBase64("eyJob3N0IjoiMTAuMC4xLjUwIn0=")); // True
Console.WriteLine(IsValidBase64("not!!valid!!base64"));              // False
Console.WriteLine(IsValidBase64(""));                                // True (kosong adalah valid)

Dekode Base64 dari File dan Respons API

Membaca file ter-encode Base64 dari disk

Sertifikat, blob terenkripsi, dan file ekspor data kadang dikirimkan sebagai teks Base64. Pola umum: baca file sebagai string, hapus spasi atau line break yang akan menyebabkanFormatException, dekode ke byte, dan tulis output biner. Perhatikan penanganan error — error I/O file dan error format Base64 harus ditangkap secara terpisah.

using System;
using System.IO;

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

try
{
    string encoded = File.ReadAllText(inputPath).Trim();
    // Hapus line break — decoder .NET menolaknya
    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}");
}

Mendekode field Base64 dari respons API HTTP

API cloud (Azure Key Vault, AWS Secrets Manager, GitHub Contents API) sering mengembalikan data biner sebagai string Base64 yang disematkan di dalam JSON. Alurnya selalu sama: buat HTTP request, parse respons JSON, ekstrak field Base64, dan dekode. Contoh di bawah menggunakan HttpClient dan System.Text.Json — keduanya sudah ada di .NET 6+.

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 mengembalikan: {"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}");
}

Dekode Base64 dari Command Line

Anda tidak selalu membutuhkan project yang dikompilasi. Tool dotnet-scriptdan PowerShell keduanya menangani dekode Base64 dengan one-liner. Untuk pemeriksaan cepat saat debugging, ini lebih cepat dari membuat console app.

# PowerShell (bawaan Windows, tersedia di Linux/macOS)
[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String("eyJob3N0IjoiMTAuMC4xLjUwIn0="))
# {"host":"10.0.1.50"}

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

# macOS menggunakan -D sebagai pengganti --decode
echo "eyJob3N0IjoiMTAuMC4xLjUwIn0=" | base64 -D

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

# Dekode dan pretty-print JSON dengan jq
echo "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=" | base64 --decode | jq .

Untuk menempelkan string ter-encode langsung ke browser, Base64 decoder ToolDeck menangani varian standar dan URL-safe tanpa setup apa pun.

Alternatif Berperforma Tinggi: System.Buffers.Text.Base64

Kelas System.Buffers.Text.Base64, tersedia sejak .NET Core 2.1, beroperasi pada span byte UTF-8 mentah alih-alih string .NET. Ini melewati overhead konversi string-ke-byte sepenuhnya — tidak ada alokasi string perantara, tidak ada langkah encoding UTF-16. Saya menggunakannya di middleware ASP.NET Core di mana data masuk sudah berupa ReadOnlySpan<byte> dari body request. Membuat string hanya untuk diteruskan ke Convert.FromBase64String() menggandakan alokasi tanpa alasan. Dalam pengujian BenchmarkDotNet pada .NET 8, jalur berbasis span sekitar 2-3x lebih cepat untuk payload di bawah 1 KB dan selisihnya semakin besar dengan input yang lebih besar karena tekanan GC tetap konstan.

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

// Simulasi byte UTF-8 mentah dari body HTTP request
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}");
    // Kemungkinan: InvalidData, DestinationTooSmall, NeedMoreData
}

Tipe kembaliannya adalah OperationStatus — enum dengan empat nilai: Done, InvalidData, DestinationTooSmall, dan NeedMoreData. Yang terakhir berguna untuk dekode parsial dari data streaming. Untuk nol alokasi mutlak, pasangkan ini dengan ArrayPool<byte>.Shared.Rent() alih-alih new byte[].

DecodeFromUtf8InPlace — timpa buffer input

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

// Buffer input ditimpa dengan byte yang didekode
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
}

Satu hal yang perlu diperhatikan: System.Buffers.Text.Base64 tidak menangani Base64 URL-safe secara langsung. Jika input menggunakan karakter - dan _ (token JWT, misalnya), Anda tetap perlu menggantinya dengan + dan / sebelum memanggil metode ini. API berbasis span menggunakan alfabet standar RFC 4648 secara ketat. Tidak ada varian DecodeFromUtf8Url — celah yang mengejutkan mengingat betapa umumnya Base64url di API modern.

Output Terminal dengan Syntax Highlighting

Library Spectre.Console memberikan output terminal yang kaya termasuk JSON highlighting — berguna saat membangun CLI tool yang mendekode Base64 dan menampilkan hasilnya. Instal dengan 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);

// Pretty-print dengan syntax highlighting di terminal
AnsiConsole.Write(new JsonText(json));
// Output JSON berwarna:
// {
//   "host": "10.0.1.50",
//   "port": 8443,
//   "maxConn": 100
// }

Ini sangat berguna untuk CLI tool yang mengambil dan mendekode konfigurasi dari layanan jarak jauh. Dekode konfigurasi Base64, deserialisi ke JSON, dan cetak output yang di-highlight — semua dalam beberapa baris. Spectre.Console juga memiliki rendering tabel, progress bar, dan tree view jika Anda perlu menampilkan struktur data yang didekode lebih kompleks di terminal.

Streaming File Base64 Besar dengan CryptoStream

Memuat file Base64 500 MB dengan File.ReadAllText() lalu memanggil Convert.FromBase64String() mengalokasikan sekitar 700 MB heap: string itu sendiri (UTF-16, jadi dua kali ukuran file) ditambah byte array yang didekode. Kombinasi CryptoStream + FromBase64Transform mendekode dalam potongan, menjaga penggunaan memori tetap konstan.

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}");

Flag FromBase64TransformMode.IgnoreWhiteSpaces menangani Base64 yang dibungkus baris (file PEM, ekspor email) tanpa pembersihan manual. Tanpa flag ini, line break dalam input menyebabkan FormatException. Ini adalah padanan .NET yang paling dekat dengan getMimeDecoder() Java — diam-diam melewati karakter spasi saat mendekode.

Nama CryptoStream menyesatkan — tidak ada yang kriptografis tentang Base64. Microsoft menempatkan FromBase64Transform di namespace System.Security.Cryptography karena mengimplementasikan ICryptoTransform, antarmuka yang sama yang digunakan untuk AES dan transform cipher lainnya. Stream itu sendiri hanya menyalurkan data melalui transform apa pun dalam potongan. Anggap saja sebagai pipeline transform streaming serba guna yang kebetulan berada di namespace yang salah.

Streaming async untuk skenario ASP.NET Core

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);
}

// Penggunaan di endpoint:
// await DecodeStreamAsync(Request.Body, "uploaded-file.bin");

Cara Mendekode Payload Token JWT Base64 di C#

JWT memiliki tiga segmen ter-encode Base64url yang dipisahkan oleh titik. Segmen tengah adalah payload. Anda bisa mendekodenya tanpa menggunakan library JWT — pisahkan berdasarkan ., normalisasi karakter Base64url, perbaiki padding, dan panggil Convert.FromBase64String(). Ini mengecoh hampir semua orang pertama kali karena JWT menggunakan - dan _ sebagai pengganti+ dan /, dan menghilangkan padding =.

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}");

    // Ambil payload (segmen kedua)
    string payload = parts[1];

    // Ganti karakter URL-safe dengan Base64 standar
    payload = payload.Replace('-', '+').Replace('_', '/');

    // Tambahkan padding kelipatan 4
    switch (payload.Length % 4)
    {
        case 2: payload += "=="; break;
        case 3: payload += "=";  break;
    }

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

// Uji dengan token berbentuk nyata
string token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9"
    + ".eyJzdWIiOiJ1c3ItNjcyIiwiaXNzIjoiYXV0aC5leGFtcGxlLmNvbSIsImV4cCI6MTc0MTk1NjgwMCwicm9sZXMiOlsiYWRtaW4iLCJiaWxsaW5nIl19"
    + ".SIGNATURE_PLACEHOLDER";

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

Catatan singkat: ini hanya membaca payload. Ini tidak memverifikasi tanda tangan. Untuk validasi auth produksi, gunakan library yang tepat seperti Microsoft.IdentityModel.JsonWebTokens. Namun untuk debugging, logging, dan assertion pengujian, pendekatan manual ini sudah cukup.

Mem-parse payload JWT yang didekode ke objek bertipe

Setelah Anda mendapatkan string JSON, deserialisi dengan System.Text.Json untuk mengakses klaim individual tanpa manipulasi string:

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
);

// Setelah DecodeJwtPayload() dari atas
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

Kesalahan Umum

Saya pernah mengalami semua kesalahan ini di layanan C# produksi. Dua yang pertama bertanggung jawab atas sebagian besar bug terkait Base64 yang saya temukan dalam review kode. Setiap kesalahan terlihat jelas secara terpisah, tetapi mudah terlewat saat Anda sedang mengerjakan fitur yang lebih besar dan dekode Base64 hanyalah satu langkah dalam pipeline.

// Variabel environment memiliki newline di akhir
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));

// Payload JWT — menggunakan Base64 URL-safe
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); // merusak biner
File.WriteAllText("image.png", imageStr); // file rusak

byte[] decoded = Convert.FromBase64String(pngBase64);
// Tulis byte langsung — tanpa konversi string
File.WriteAllBytes("image.png", decoded);

byte[] decoded = Convert.FromBase64String(encoded);
// Encoding.Default bervariasi antar platform
string result = Encoding.Default.GetString(decoded);

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

Perbandingan Metode

.NET menawarkan lebih banyak metode dekode Base64 daripada yang disadari kebanyakan developer. Tabel di bawah mencakup setiap opsi bawaan ditambah dua alternatif pihak ketiga yang paling umum. Kolom "Alokasi" paling penting dalam layanan throughput tinggi — metode yang mengalokasikan byte[] baru pada setiap panggilan memberikan tekanan pada GC dalam loop ketat.

Untuk pekerjaan sehari-hari: Convert.FromBase64String(). Untuk hot path di mana Anda memvalidasi input pengguna: TryFromBase64String(). Untuk middleware ASP.NET Core yang beroperasi pada byte request mentah: Base64.DecodeFromUtf8(). Untuk file besar: CryptoStream + FromBase64Transform. BouncyCastle hanya masuk akal jika sudah ada di dependency tree Anda untuk operasi kriptografi lainnya.

Untuk verifikasi cepat tanpa mengkompilasi apa pun, decoder Base64 online lebih cepat dari menulis console app sekali pakai.

Pertanyaan yang Sering Diajukan

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"}

// Perbaiki spasi
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);

Alat Terkait

• Base64 Encoder — encode teks atau data biner ke Base64 di browser, berguna untuk membuat test fixture yang bisa ditempelkan ke unit test C# Anda.
• JWT Decoder — dekode dan periksa ketiga segmen JWT sekaligus, dengan inspeksi payload field per field — lebih cepat dari menulis helper C# saat Anda hanya perlu membaca token.
• URL Decoder — percent-decode string ter-encode URL, berguna saat respons API mencampur data Base64url dengan parameter query yang di-encode persen.
• JSON Formatter — setelah mendekode payload JWT Base64 atau config API, tempelkan JSON di sini untuk pretty-print dan validasi strukturnya.