C#'ta Base64 Decode — Convert.FromBase64String() Rehberi

Üzerinde çalıştığım her .NET projesinde er ya da geç Base64 çözme ihtiyacı doğuyor — Kubernetes secret'larından bağlantı dizelerini okumak, webhook'lardan gelen binary payload'ları işlemek veya debug sırasında JWT token'larını incelemek gibi. C#'ta Base64 çözmek için birincil metot Convert.FromBase64String()'dir; bu metot bir byte[]döndürür ve ardından okunabilir metin elde etmek için dönen byte'ları Encoding.UTF8.GetString()'e geçirirsiniz. Kod yazmadan hızlı bir kontrol için ToolDeck'in Base64 çözücüsü tarayıcıda anında sonuç verir. Bu rehber Convert.FromBase64String()'i, .NET 5+ için span tabanlı TryFromBase64String()'i, yüksek performanslı System.Buffers.Text.Base64API'sini, JWT payload çıkarımını, dosya ve API yanıtı çözmeyi, CryptoStream ile akış desteğini ve C# geliştiricilerini en çok yanıltan dört hatayı kapsamaktadır.

Base64 Çözme Nedir?

Base64 kodlama, binary veriyi yalnızca metin geçirebilen kanallardan geçebilmesi için 64 karakterlik ASCII alfabesine dönüştürür — JSON alanları, HTTP başlıkları, e-posta gövdeleri, XML öznitelikleri. Her 3 byte girdi 4 Base64 karakterine dönüşür; bu yüzden Base64 çıktısı her zaman orijinalden yaklaşık %33 daha büyüktür. Çözme bu dönüşümü tersine çevirir. Sondaki = padding, çözücüye son gruptan kaç byte çıkarılacağını söyler. Tek =, son bloğun 2 byte içerdiği anlamına gelir;== ise 1 byte içerdiğini gösterir. Base64 şifreleme değildir — herkes tersine çevirebilir. Amacı ham binary veriyi bozan kanallardan güvenli geçiş sağlamaktır, gizlilik değil.

cmVkaXM6Ly9jYWNoZS1wcm9kLmludGVybmFsOjYzNzkvc2Vzc2lvbi1zdG9yZQ==

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

Convert.FromBase64String() — Standart Çözme Metodu

Convert.FromBase64String()metodu .NET Framework 1.1'den bu yana mevcuttur. NuGet paketi yok, System'in ötesinde ekstra import yok — sadece çağırın ve byte[]alın. Base64 metni C# string'ine çözmenin iki adımlı işlem hattı her zaman aynıdır: byte almak için Convert.FromBase64String(), ardından byte'ları metne yorumlamak için Encoding.UTF8.GetString(). Dikkat edilmesi gereken nokta, metodun string değil ham byte döndürmesidir. Byte'ları metne geri dönüştürmek için doğru Encoding'i seçmeniz gerekir ve bu seçim çoğu kişinin beklediğinden daha kritiktir. Yanlış bir encoding sessizce mojibake — sizi uyaran bir exception olmadan bozuk karakterler — üretir.

Minimal çalışan örnek

using System;
using System.Text;

// Kubernetes secret içinde Base64 olarak saklanan bağlantı dizesi
string encoded = "cmVkaXM6Ly9jYWNoZS1wcm9kLmludGVybmFsOjYzNzkvc2Vzc2lvbi1zdG9yZQ==";

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

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

Özel bir nedeniniz olmadıkça her zaman Encoding.UTF8kullanın. .NET çalışma zamanı string'leri dahili olarak UTF-16 ile temsil eder; ancak sistem sınırlarını geçen verilerin büyük çoğunluğu (API yanıtları, config dosyaları, secret'lar) UTF-8 olarak encode edilmiştir. Çok baytlı karakter içeren veriler üzerinde Encoding.ASCII kullanmak onları sessizce ? ile değiştirir — exception yok, sadece bozuk çıktı.

Gidiş-dönüş doğrulaması

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

Doğru Encoding\'i seçmek

GetString()'e geçirdiğiniz Encoding, verinin orijinal olarak encode edildiği encoding ile eşleşmelidir. Yanlış birini seçerseniz exception olmadan bozuk karakterler alırsınız — çözücü neşeyle saçmalık üretir. İşte pratik özet:

• Encoding.UTF8 — güvenli varsayılan. ASCII ve tüm Unicode'u işler. Başka bir neden yoksa bunu kullanın.
• Encoding.ASCII — yalnızca saf 7-bit ASCII veriler için. Çok baytlı karakterler ? olur.
• Encoding.Unicode — .NET'te UTF-16LE anlamına gelir. Bazı Windows dahili string'leri ve PowerShell dışa aktarmaları bunu kullanır.
• Encoding.Latin1 — eski Batı Avrupa encoding'i. Eski SOAP servisleri ve mainframe entegrasyonlarında karşılaşılır.

using System;
using System.Text;

// Aynı byte'lar, farklı encoding'ler — farklı sonuçlar
byte[] decoded = Convert.FromBase64String("w7bDvMOk");

Console.WriteLine(Encoding.UTF8.GetString(decoded));    // oua  (doğru)
Console.WriteLine(Encoding.ASCII.GetString(decoded));   // ??????  (kayıp)
Console.WriteLine(Encoding.Latin1.GetString(decoded));  // öüä  (mojibake)

Hata işleme ile yeniden kullanılabilir bir çözme yardımcısı

Convert.FromBase64String() hatalı girdide exception fırlattığından ve boşluk temizleme işlemi sürekli tekrarlandığından, çoğu projemde küçük bir yardımcı kullanırım:

using System;
using System.Text;

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

        // .NET'in çözücüsünün reddettiği boşlukları temizle
        string cleaned = encoded
            .Replace("
", "")
            .Replace("
", "")
            .Replace(" ", "")
            .Trim();

        try
        {
            byte[] bytes = Convert.FromBase64String(cleaned);
            return Encoding.UTF8.GetString(bytes);
        }
        catch (FormatException)
        {
            return null; // veya domain'e özgü bir exception fırlat
        }
    }
}

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

Base64\'ü Standart Olmayan Tiplere Çözme

Çözücü her zaman size byte[]verir. Bu byte'larla ne yapacağınız orijinal veriye bağlıdır. Bazen 16 ham byte olarak saklanan bir GUID, bazen serileştirilmiş bir protobuf mesajı, bazen de binary formatta bir zaman damgasıdır. İşte en sık başvurduğum dönüşümler.

Base64'ten GUID'e

using System;

// Bazı API'ler GUID'leri 36 karakterlik hex yerine 22 karakterlik Base64 olarak gönderir
string compactGuid = "C0HqetxMckKlZw4CssPUeQ==";
byte[] guidBytes = Convert.FromBase64String(compactGuid);
Guid recovered = new Guid(guidBytes);

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

Base64\'ten System.Text.Json ile seriden çıkarılmış JSON'a

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

// Mesaj kuyruğundan gelen Base64 kodlu JSON payload
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}

// Bir record'a deserialize et
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'ten hex string'e

using System;

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

Console.WriteLine(hex);
// 9F86D081884C7D659A2FEAA0C55AD015A3BF4F1B2B0B822CD15D6C15B0F00A08

Base64 Çözme Metodları Referansı

.NET, iki namespace genelinde birden fazla çözme metodu sunar. Convert sınıfı genel amaçlı çözme işlemlerini üstlenirken, System.Buffers.Text.Base64 ham UTF-8 byte tamponlarıyla çalıştığınız yüksek verimli senaryoları hedefler.

Convert.TryFromBase64String() — Exception'sız Çözme

Try kalıbı, .NET'te kullanıcı girdisinde başarısız olabilecek işlemler için standarttır. .NET 5'ten itibaren kullanılabilen Convert.TryFromBase64String(),FormatException fırlatmak yerine booldöner. Çözülen byte'ları çağıran tarafından sağlanan bir Span<byte>içine yazar; bu sayede küçük payload'lar için stack tahsisli bellek kullanabilir ve heap'i tamamen atlayabilirsiniz.

using System;
using System.Text;

string userInput = "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=";

// Küçük payload'lar için stack tahsis et (< 1KB güvenli bir kural)
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");
}

Bu yaklaşım, hatalı girdinin olağan olmayan bir durum değil, beklenen bir durum olduğu istek middleware'i veya doğrulama işlem hatlarında parlar. Her hatalı istek için FormatException fırlatıp yakalamak, ölçekte ölçülebilir ek yük getirir — TryFromBase64String() bunu tamamen önler.

Çözmeden Base64 girdisini doğrulama

API controller'larında yaygın bir kalıp: girdiyi akış aşağısına geçirmeden önce geçerli Base64 olup olmadığını kontrol etmek. Tek kullanımlık bir tampon tahsis ederek TryFromBase64String()'i bir doğrulayıcı olarak kullanabilirsiniz:

using System;

static bool IsValidBase64(string input)
{
    // Maksimum çözülmüş boyutu hesapla
    Span<byte> buffer = stackalloc byte[((input.Length + 3) / 4) * 3];
    return Convert.TryFromBase64String(input, buffer, out _);
}

// API controller'da kullanım
Console.WriteLine(IsValidBase64("eyJob3N0IjoiMTAuMC4xLjUwIn0=")); // True
Console.WriteLine(IsValidBase64("not!!valid!!base64"));              // False
Console.WriteLine(IsValidBase64(""));                                // True (boş geçerlidir)

Dosya ve API Yanıtından Base64 Çözme

Diskten Base64 kodlu dosya okuma

Sertifikalar, şifreli blob'lar ve veri dışa aktarma dosyaları bazen Base64 metin olarak gelir. Tipik kalıp: dosyayı string olarak okuyun, FormatException'a yol açacak boşluk veya satır sonlarını temizleyin, byte'lara çözün ve binary çıktıyı yazın. Hata işlemeye dikkat edin — dosya G/Ç hataları ve Base64 format hataları ayrı ayrı yakalanmalıdır.

using System;
using System.IO;

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

try
{
    string encoded = File.ReadAllText(inputPath).Trim();
    // Satır sonlarını kaldır — .NET'in çözücüsü bunları reddeder
    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}");
}

HTTP API yanıtından Base64 alanı çözme

Bulut API'leri (Azure Key Vault, AWS Secrets Manager, GitHub Contents API) sıklıkla binary veriyi JSON içine gömülü Base64 string'leri olarak döndürür. İş akışı her zaman aynıdır: HTTP isteği yapın, JSON yanıtı ayrıştırın, Base64 alanını çıkarın ve çözün. Aşağıdaki örnek .NET 6+ ile birlikte gelen HttpClient ve System.Text.Json'u kullanır.

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 döndürür: {"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}");
}

Komut Satırından Base64 Çözme

Her zaman derlenmiş bir projeye ihtiyaç duymazsınız. dotnet-script aracı ve PowerShell, tek satırla Base64 çözmeyi halleder. Hata ayıklama sırasında hızlı inceleme için bunlar bir konsol uygulaması oluşturmaktan çok daha hızlıdır.

# PowerShell (Windows'ta yerleşik, Linux/macOS'ta kullanılabilir)
[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String("eyJob3N0IjoiMTAuMC4xLjUwIn0="))
# {"host":"10.0.1.50"}

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

# macOS --decode yerine -D kullanır
echo "eyJob3N0IjoiMTAuMC4xLjUwIn0=" | base64 -D

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

# Çöz ve jq ile JSON'ı güzel yazdır
echo "eyJob3N0IjoiMTAuMC4xLjUwIiwicG9ydCI6ODQ0M30=" | base64 --decode | jq .

Encode edilmiş string'leri doğrudan tarayıcıya yapıştırmak için ToolDeck'in Base64 çözücüsü herhangi bir kurulum gerektirmeden hem standart hem URL güvenli varyantları işler.

Yüksek Performanslı Alternatif: System.Buffers.Text.Base64

.NET Core 2.1'den itibaren kullanılabilen System.Buffers.Text.Base64 sınıfı, .NET string'leri yerine ham UTF-8 byte span'ları üzerinde çalışır. Bu, string'den byte'a dönüşüm yükünü tamamen atlar — ara string tahsisi yok, UTF-16 kodlama adımı yok. Gelen verinin istek gövdesinden ReadOnlySpan<byte> olarak geldiği ASP.NET Core middleware'inde bunu tercih ediyorum. SadeceConvert.FromBase64String()'e geçirmek için stringoluşturmak, tahsisleri gereksiz yere iki katına çıkarır. .NET 8 üzerindeki BenchmarkDotNet testlerinde, span tabanlı yol 1 KB altındaki payload'larda yaklaşık 2-3 kat daha hızlıdır ve GC baskısı sabit kaldığından daha büyük girdilerde fark daha da açılır.

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

// HTTP istek gövdesinden ham UTF-8 byte'ları simüle et
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}");
    // Olası: InvalidData, DestinationTooSmall, NeedMoreData
}

Dönüş tipi OperationStatus'tur — dört değerli bir enum: Done, InvalidData, DestinationTooSmall ve NeedMoreData. Sonuncusu, akış verilerinin kısmi çözümü için kullanışlıdır. Mutlak sıfır tahsis için, new byte[] yerine ArrayPool<byte>.Shared.Rent() ile eşleştirin.

DecodeFromUtf8InPlace — girdi tamponunun üzerine yaz

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

// Girdi tamponu çözülmüş byte'larla üzerine yazılır
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
}

Dikkat edilmesi gereken bir nokta: System.Buffers.Text.Base64 URL güvenli Base64'ü doğrudan işlemez. Girdi - ve _ karakterleri içeriyorsa (JWT token'ları gibi), bu metodları çağırmadan önce bunları + ve /ile değiştirmeniz yine gerekir. Span tabanlı API'ler katı olarak RFC 4648 standart alfabesine uymaktadır. Modern API'lerde Base64url ne kadar yaygın olduğu göz önüne alındığında şaşırtıcı bir eksiklik olan DecodeFromUtf8Url varyantı yoktur.

Sözdizimi Vurgulamalı Terminal Çıktısı

Spectre.Console kütüphanesi, JSON vurgulama dahil zengin terminal çıktısı sunar — Base64 çözüp sonucu görüntüleyen CLI araçları oluştururken kullanışlıdır.dotnet add package Spectre.Console ile kurabilirsiniz.

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

// Terminalde sözdizimi vurgulamasıyla güzel yazdır
AnsiConsole.Write(new JsonText(json));
// Renkli JSON çıktısı:
// {
//   "host": "10.0.1.50",
//   "port": 8443,
//   "maxConn": 100
// }

Bu özellikle uzak servislerden yapılandırma alıp çözen CLI araçları için kullanışlıdır. Base64 yapılandırmasını çözün, JSON'a deserialize edin ve vurgulanan çıktıyı yazdırın — hepsi birkaç satırda. Terminalde daha karmaşık çözülmüş veri yapıları görüntülemeniz gerekiyorsa Spectre.Console ayrıca tablo oluşturma, ilerleme çubukları ve ağaç görünümleri sunar.

CryptoStream ile Büyük Base64 Dosyalarını Akış Olarak Çözme

File.ReadAllText()ile 500 MB'lık bir Base64 dosyası yükleyip ardındanConvert.FromBase64String()çağırmak heap'te yaklaşık 700 MB tahsis eder: string'in kendisi (UTF-16 olduğundan dosya boyutunun iki katı) artı çözülmüş byte dizisi. CryptoStream + FromBase64Transform kombinasyonu parça parça çözer ve bellek kullanımını sabit tutar.

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

FromBase64TransformMode.IgnoreWhiteSpacesbayrağı, manuel temizleme olmadan satır sarmalı Base64'ü (PEM dosyaları, e-posta dışa aktarmaları) işler. Bu bayrak olmadan girdideki satır sonları FormatException'a neden olur. Bu, Java'nın getMimeDecoder()'ına en yakın .NET karşılığıdır — çözme sırasında boşluk karakterlerini sessizce atlar.

CryptoStreamadı yanıltıcıdır — Base64'te kriptografik bir şey yoktur. Microsoft, FromBase64Transform'ı System.Security.Cryptography namespace'ine koymuştur çünkü AES ve diğer şifre dönüşümlerinde kullanılan aynı arayüz olan ICryptoTransform'u uygular. Stream'in kendisi yalnızca veriyi herhangi bir dönüşümden parça parça geçirir. Bunu yanlış namespace'te yer alan genel amaçlı bir akış dönüşüm hattı olarak düşünebilirsiniz.

ASP.NET Core senaryoları için asenkron akış

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

// Bir endpoint'te kullanım:
// await DecodeStreamAsync(Request.Body, "uploaded-file.bin");

C#'ta Base64 JWT Token Payload'ını Çözme

JWT'nin noktalara göre ayrılmış üç Base64url kodlu segmenti vardır. Ortadaki segment payload'dır. Bir JWT kütüphanesi kullanmadan çözebilirsiniz —.üzerinden ayırın, Base64url karakterlerini normalize edin, padding'i düzeltin ve Convert.FromBase64String() çağırın. JWT'nin + ve / yerine - ve _ kullandığını ve = padding'i çıkardığını bilmeden ilk kez deneyen herkesi yanıltır.

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'ı al (ikinci segment)
    string payload = parts[1];

    // URL güvenli karakterleri standart Base64 ile değiştir
    payload = payload.Replace('-', '+').Replace('_', '/');

    // 4'ün katına padding ekle
    switch (payload.Length % 4)
    {
        case 2: payload += "=="; break;
        case 3: payload += "=";  break;
    }

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

// Gerçek şekilli bir token ile test et
string token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9"
    + ".eyJzdWIiOiJ1c3ItNjcyIiwiaXNzIjoiYXV0aC5leGFtcGxlLmNvbSIsImV4cCI6MTc0MTk1NjgwMCwicm9sZXMiOlsiYWRtaW4iLCJiaWxsaW5nIl19"
    + ".SIGNATURE_PLACEHOLDER";

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

Kısa bir not: bu yalnızca payload'ı okur. İmzayı doğrulamaz. Üretim auth doğrulaması için Microsoft.IdentityModel.JsonWebTokens gibi uygun bir kütüphane kullanın. Ancak hata ayıklama, loglama ve test doğrulamaları için bu manuel yaklaşım yeterlidir.

Çözülmüş JWT payload'ını tipli nesneye ayrıştırma

JSON string'e sahip olduğunuzda, string işleme olmadan bireysel claim'lere erişmek için System.Text.Json ile deserialize edin:

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

// Yukarıdaki DecodeJwtPayload() sonrasında
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

Yaygın Hatalar

Bu hatalardan her birini üretim C# servislerinde bizzat yaşadım. İlk ikisi, kod incelemelerinde gördüğüm Base64 kaynaklı hataların büyük çoğunluğundan sorumludur. Her hata tek başına bariz görünür; ancak daha büyük bir özelliği geliştirirken ve Base64 çözme işlem hattındaki tek bir adım iken bunları gözden kaçırmak kolaydır.

// Ortam değişkeninin sonunda satır sonu var
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 — URL güvenli Base64 kullanır
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); // binary'i bozar
File.WriteAllText("image.png", imageStr); // bozuk dosya

byte[] decoded = Convert.FromBase64String(pngBase64);
// Byte'ları doğrudan yaz — string dönüşümü yok
File.WriteAllBytes("image.png", decoded);

byte[] decoded = Convert.FromBase64String(encoded);
// Encoding.Default platformlar arasında değişir
string result = Encoding.Default.GetString(decoded);

byte[] decoded = Convert.FromBase64String(encoded);
string result = Encoding.UTF8.GetString(decoded);
// Windows, Linux, macOS'ta tutarlı

Metot Karşılaştırması

.NET, çoğu geliştiricinin farkında olduğundan daha fazla Base64 çözme metodu sunar. Aşağıdaki tablo yerleşik seçeneklerin tamamını ve en yaygın iki üçüncü taraf alternatifi kapsamaktadır. "Ayırma" sütunu yüksek verimli servislerde en çok önem taşır — her çağrıda yeni bir byte[] tahsis eden bir metot, yoğun döngülerde GC üzerinde baskı oluşturur.

Günlük işler için: Convert.FromBase64String(). Kullanıcı girdisini doğruladığınız kritik yollar için: TryFromBase64String(). Ham istek byte'ları üzerinde çalışan ASP.NET Core middleware'i için: Base64.DecodeFromUtf8(). Büyük dosyalar için: CryptoStream + FromBase64Transform. BouncyCastle, yalnızca diğer kriptografik işlemler için bağımlılık ağacınızda zaten varsa mantıklıdır.

Herhangi bir şey derlemeden hızlı doğrulama için çevrimiçi Base64 çözücü tek seferlik bir konsol uygulaması yazmaktan daha hızlıdır.

Sıkça Sorulan Sorular

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

// Boşlukları temizle
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);

İlgili Araçlar

• Base64 Encoder — tarayıcıda metin veya binary veriyi Base64'e encode edin; C# unit testlerinize yapıştırmak için test fixture'ları oluşturmak için kullanışlıdır.
• JWT Decoder — üç JWT segmentini de aynı anda çözün ve inceleyin; yalnızca bir token okumak istediğinizde C# yardımcısı yazmaktan daha hızlıdır.
• URL Decoder — URL kodlu string'leri percent-decode edin; API yanıtlarında Base64url verisi ile percent-encode edilmiş sorgu parametreleri bir arada geldiğinde kullanışlıdır.
• JSON Formatter — Base64 JWT payload'ını veya API yapılandırmasını çözdükten sonra JSON'ı buraya yapıştırarak güzel yazdırın ve yapıyı doğrulayın.