Go'da Base64 Kod Çözme — encoding/base64 + Örnekler

Go'da Base64 kod çözme sürekli karşılaşılan bir durumdur — JWT incelemesi, ikili dosya ekleri, bulut hizmetlerinden gelen API yükleri. Go'nun standart encoding/base64paketi bunların hepsini karşılar; ancak yanlış kodlama varyantı seçmek (standart ya da URL-güvenli, dolgulu ya da dolgusuz) “illegal base64 data” hatalarının tek ve en yaygın kaynağıdır. Bu kılavuz StdEncoding, URLEncoding, RawURLEncoding, base64.NewDecoder ile akış kod çözme, JWT payload incelemesi ve neredeyse herkesi ilk seferinde şaşırtan dört yaygın hatayı ele almaktadır. Tarayıcıda tek seferlik kod çözme için ToolDeck'in Base64 Kod Çözücüsü tek satır kod yazmadan işi anında halleder.

✓encoding/base64 Go standart kütüphanesinin bir parçasıdır — go get gerekmez
✓JWT token'ları ve modern API'lerin çoğu için RawURLEncoding kullanın (dolgu yok, URL-güvenli alfabe)
✓StdEncoding, = dolgulu + ve / kullanır; URLEncoding bunları - ve _ ile değiştirir ama dolguyu korur
✓base64.NewDecoder, belleğe yüklemeden akış kod çözme için herhangi bir io.Reader'ı sarar
✓Döndürülen hatayı her zaman kontrol edin — geçersiz dolgu ve yanlış alfabe "illegal base64 data" üretir

Base64 Kod Çözme Nedir?

Base64 kodlama, ikili verileri 64 yazdırılabilir karakter (A–Z, a–z, 0–9 ve iki ek karakter) kullanarak ASCII metni olarak temsil eder. Kod çözme bunu tersine çevirir — ASCII temsilini orijinal byte'lara dönüştürür. Her 4 Base64 karakteri tam olarak 3 byte'a karşılık gelir. Bu şema, birçok aktarım katmanının (e-posta, HTTP başlıkları, JSON alanları) ham ikili veri için değil metin için tasarlanmış olması nedeniyle kullanılmaktadır. Gidiş-dönüş şu şekilde görünür:

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	// Ham byte'lar → Base64 kodlanmış → ham byte'lara geri kod çözülmüş
	original := []byte("service_token:xK9mP2qR")
	// Kodlanmış: "c2VydmljZV90b2tlbjp4SzltUDJxUg=="

	encoded := base64.StdEncoding.EncodeToString(original)
	decoded, _ := base64.StdEncoding.DecodeString(encoded)
	fmt.Println(string(decoded) == string(original)) // true
}

encoding/base64 ile Go'da Base64 Kod Çözme

encoding/base64 paketi Go ile birlikte gelir — harici bağımlılık yoktur. Paket düzeyinde dört önceden tanımlı kodlama varyantını değişken olarak sunar. String girdisi için en yaygın kullanılan fonksiyon, bir byte dilimi ve hata döndüren DecodeString'dir.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"log"
)

func main() {
	// Standart Base64 — alfabe, = dolgulu + ve / kullanır
	encoded := "eyJob3N0IjoiZGItcHJvZC51cy1lYXN0LTEiLCJwb3J0Ijo1NDMyfQ=="
	decoded, err := base64.StdEncoding.DecodeString(encoded)
	if err != nil {
		log.Fatalf("decode error: %v", err)
	}
	fmt.Println(string(decoded))
	// {"host":"db-prod.us-east-1","port":5432}
}

Decode metodu, string yerine byte dilimleri üzerinde çalışır ve sonucu önceden tahsis edilmiş bir hedef tampona yazar. Tamponu doğru boyutlandırmanız gerekir — maksimum boyutu almak için base64.StdEncoding.DecodedLen(len(src)) kullanın (dolgu nedeniyle gerçek kod çözülmüş uzunluktan birkaç byte büyük olabilir).

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"log"
)

func main() {
	src := []byte("eyJob3N0IjoiZGItcHJvZCIsInBvcnQiOjU0MzJ9")
	dst := make([]byte, base64.RawStdEncoding.DecodedLen(len(src)))

	n, err := base64.RawStdEncoding.Decode(dst, src)
	if err != nil {
		log.Fatalf("decode: %v", err)
	}
	fmt.Println(string(dst[:n]))
	// {"host":"db-prod","port":5432}
}

Not:DecodedLen tam uzunluğu değil, üst sınırı döndürür. Sonucu doğru şekilde dilimlemek için her zaman Decode'dan dönen n değerini kullanın: dst[:n].

StdEncoding ve URLEncoding — Doğru Varyantı Seçmek

Karışıklığın büyük bölümü buradan kaynaklanır. Go'nun encoding/base64 paketi dört kodlama nesnesi sunar ve yanlışını seçmek kesinlikle hatayla sonuçlanır. Fark iki şeye indirgenir: alfabe ve dolgu.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	// JWT başlık payload'ı — URL-güvenli, dolgu yok
	jwtHeader := "eyJhbGciOiJSUzI1NiIsImtpZCI6IjIwMjMtMDkifQ"

	// Yanlış: StdEncoding, dolgusuz URL-güvenli girdi üzerinde başarısız olur
	_, err1 := base64.StdEncoding.DecodeString(jwtHeader)
	fmt.Println("StdEncoding hatası:", err1)
	// StdEncoding hatası: illegal base64 data at input byte 43

	// Doğru: RawURLEncoding — dolgu yok, URL-güvenli alfabe
	decoded, err2 := base64.RawURLEncoding.DecodeString(jwtHeader)
	fmt.Println("RawURLEncoding tamam:", err2, "→", string(decoded))
	// RawURLEncoding tamam: <nil> → {"alg":"RS256","kid":"2023-09"}
}

Dört varyant açık bir şekilde:

Fonksiyon / Metot

Kodlama

Dolgu Gerekli

Döndürür

base64.StdEncoding.DecodeString(s)

Standart (+, /)

Evet (=)

([]byte, error)

base64.URLEncoding.DecodeString(s)

URL-güvenli (-, _)

Evet (=)

([]byte, error)

base64.RawStdEncoding.DecodeString(s)

Standart (+, /)

Hayır

([]byte, error)

base64.RawURLEncoding.DecodeString(s)

URL-güvenli (-, _)

Hayır

([]byte, error)

base64.StdEncoding.Decode(dst, src)

Standart (+, /)

Evet (=)

(n int, error)

base64.NewDecoder(enc, r)

Herhangi bir kodlama

Evet

io.Reader

Pratik kuralım şu: JWT'den, OAuth akışından veya bulut sağlayıcı SDK'sından geldiyse önce RawURLEncoding'e başvurun. E-posta eklerinden veya eski web formlarından geldiyse StdEncoding'i deneyin. Hata mesajı her zaman kod çözmenin başarısız olduğu tam byte konumunu gösterir.

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

Base64 kodlanmış bir dosyayı okuma

İkili dosyalar (görseller, PDF'ler, sertifikalar) bazen diskte Base64 kodlanmış olarak saklanır. Dosyayı okuyun, sondaki boşlukları temizleyin, ardından kod çözün:

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"log"
	"os"
	"strings"
)

func main() {
	raw, err := os.ReadFile("certificate.pem.b64")
	if err != nil {
		log.Fatalf("read file: %v", err)
	}

	// Yeni satırları temizle — Base64 dosyalarında genellikle her 76 karakterde satır sonu olur
	cleaned := strings.ReplaceAll(strings.TrimSpace(string(raw)), "\n", "")

	decoded, err := base64.StdEncoding.DecodeString(cleaned)
	if err != nil {
		log.Fatalf("decode: %v", err)
	}

	if err := os.WriteFile("certificate.pem", decoded, 0600); err != nil {
		log.Fatalf("write: %v", err)
	}
	fmt.Printf("decoded %d bytes → certificate.pem\n", len(decoded))
}

API JSON yanıtından Base64 alanını kod çözme

Bulut API'leri ikili verileri (şifreleme anahtarları, imzalı blob'lar, küçük resimler) JSON içinde Base64 string'i olarak sık sık döndürür. Önce JSON'ı ayrıştırın, ardından hedef alanı kod çözün:

Go 1.21+

package main

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
)

type SecretResponse struct {
	Name    string `json:"name"`
	Payload string `json:"payload"` // Base64 kodlanmış gizli değer
	Version int    `json:"version"`
}

func fetchAndDecodeSecret(secretURL string) ([]byte, error) {
	resp, err := http.Get(secretURL)
	if err != nil {
		return nil, fmt.Errorf("http get: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("unexpected status: %d", resp.StatusCode)
	}

	var secret SecretResponse
	if err := json.NewDecoder(resp.Body).Decode(&secret); err != nil {
		return nil, fmt.Errorf("decode json: %w", err)
	}

	value, err := base64.StdEncoding.DecodeString(secret.Payload)
	if err != nil {
		return nil, fmt.Errorf("decode base64: %w", err)
	}
	return value, nil
}

func main() {
	value, err := fetchAndDecodeSecret("https://api.example.com/secrets/db-password")
	if err != nil {
		log.Fatalf("fetch secret: %v", err)
	}
	fmt.Printf("secret value: %s\n", value)
}

Not:Bağlamı kaybetmemek için fmt.Errorf("decode base64: %w", err) ile hataları sarmalayın. encoding/base64'ten gelen orijinal hata mesajı, hata ayıklama sırasında işe yarayan hata oluşan byte konumunu içerir.

Büyük Base64 Kodlanmış Dosyaları Akış Olarak Kod Çözme

500 MB'lık Base64 kodlanmış bir dosyayı os.ReadFile ile belleğe yükleyip DecodeStringçağırmak yaklaşık 750 MB RAM kullanır (kodlanmış string artı kod çözülmüş byte'lar). base64.NewDecoder herhangi bir io.Reader'ı sarar ve parçalar halinde kod çözerek bellek kullanımını sabit tutar. Temiz bir akış hattı için io.Copy ile birleştirin:

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"io"
	"log"
	"os"
)

func streamDecodeFile(srcPath, dstPath string) error {
	src, err := os.Open(srcPath)
	if err != nil {
		return fmt.Errorf("open source: %w", err)
	}
	defer src.Close()

	dst, err := os.Create(dstPath)
	if err != nil {
		return fmt.Errorf("create dest: %w", err)
	}
	defer dst.Close()

	decoder := base64.NewDecoder(base64.StdEncoding, src)
	written, err := io.Copy(dst, decoder)
	if err != nil {
		return fmt.Errorf("stream decode: %w", err)
	}
	fmt.Printf("written %d bytes to %s\n", written, dstPath)
	return nil
}

func main() {
	if err := streamDecodeFile("backup.tar.b64", "backup.tar"); err != nil {
		log.Fatal(err)
	}
}

Uyarı:base64.NewDecodertemiz, kesintisiz Base64 verisi bekler. Kaynak dosyada satır sonları varsa (PEM ve MIME kodlamalı dosyalarda yaygındır), akış yapmadan önce kaynak reader'ı satır temizleyici bir reader ile sarmalayın ya da dosyayı önceden işleyerek yeni satırları kaldırın.

Komut Satırından Base64 Kod Çözme

Çoğu Go geliştiricisi hata ayıklarken önce komut satırına başvurur. Her macOS ve Linux sisteminde base64bulunur; Windows'ta PowerShell'in yerleşik bir karşılığı vardır. API yüklerini hızlıca incelemek için bunlar Go betiği yazmaktan daha hızlıdır.

bash

# Base64 string'i kod çöz (Linux / macOS)
echo "eyJob3N0IjoiZGItcHJvZCIsInBvcnQiOjU0MzJ9" | base64 --decode
# {"host":"db-prod","port":5432}

# Kod çöz ve jq ile güzelleştir (JSON çıktısını pipe'la)
echo "eyJob3N0IjoiZGItcHJvZCIsInBvcnQiOjU0MzJ9" | base64 --decode | jq .
# {
#   "host": "db-prod",
#   "port": 5432
# }

# Base64 kodlanmış dosyayı ikili veriye çevir
base64 --decode < encrypted_payload.b64 > encrypted_payload.bin

# macOS --decode yerine -D bayrağını kullanır
echo "c2VjcmV0LXRva2Vu" | base64 -D

Herhangi bir araç yüklenmeden JWT token'larını incelemek için token'ı ToolDeck'in Base64 Kod Çözücüsü'ne yapıştırın — noktalara göre ayırın ve her parçayı ayrı ayrı kod çözün.

Yüksek Performanslı Alternatif: encoding/base64 Zaten Hızlıdır

Python'da orjson ile jsonarasındaki performans tartışmasının aksine, Go'nun encoding/base64 paketi zaten assembly ile optimize edilmiştir ve çoğu iş yükü için gerçekten hızlıdır. Bununla birlikte, sıkı bir döngüde milyonlarca kayıt işliyorsanız filippo.io/base64, birebir aynı API ile SIMD hızlandırmalı kod çözme sunar.

bash

go get filippo.io/base64

Go 1.21+

package main

import (
	"fmt"
	"log"

	"filippo.io/base64"
)

func main() {
	// Birebir değiştirilebilir — encoding/base64 ile aynı API
	encoded := "eyJob3N0IjoiY2FjaGUtcHJvZCIsInBvcnQiOjYzNzl9"
	decoded, err := base64.StdEncoding.DecodeString(encoded)
	if err != nil {
		log.Fatalf("decode: %v", err)
	}
	fmt.Println(string(decoded))
	// {"host":"cache-prod","port":6379}
}

Performans kazanımı, AVX2 destekli amd64 üzerinde en belirgin şekilde görülür — büyük girdilerde benchmark'lar 2–4x verim artışı göstermektedir. Günlük API yanıtı kod çözme (seferinde birkaç yüz byte) için standart kütüphane yeterlidir.

Go'da Base64 JWT Payload Kod Çözme

JWT incelemesi neredeyse her backend servisinde karşıma çıkar. Deneyimlerime göre çoğu hata ayıklama oturumu “bu token'da aslında ne var?” sorusuna indirgeniyor — ve bunu tam bir JWT kütüphanesi çekmeden yanıtlayabilirsiniz. Token, nokta ile ayrılmış üç Base64url kodlanmış segmentten oluşur. Ortadaki segment gerçekten önemsediğiniz payload'dır:

Go 1.21+

package main

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"log"
	"strings"
)

type JWTPayload struct {
	Subject  string   `json:"sub"`
	Issuer   string   `json:"iss"`
	Expiry   int64    `json:"exp"`
	Roles    []string `json:"roles"`
}

func decodeJWTPayload(token string) (*JWTPayload, error) {
	parts := strings.Split(token, ".")
	if len(parts) != 3 {
		return nil, fmt.Errorf("invalid JWT: expected 3 segments, got %d", len(parts))
	}

	// JWT, RawURLEncoding kullanır — URL-güvenli alfabe, = dolgu yok
	raw, err := base64.RawURLEncoding.DecodeString(parts[1])
	if err != nil {
		return nil, fmt.Errorf("decode payload: %w", err)
	}

	var payload JWTPayload
	if err := json.Unmarshal(raw, &payload); err != nil {
		return nil, fmt.Errorf("unmarshal payload: %w", err)
	}
	return &payload, nil
}

func main() {
	token := "eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJ1c3ItNDQyIiwiaXNzIjoiYXV0aC5leGFtcGxlLmNvbSIsImV4cCI6MTc0MTk1NjgwMCwicm9sZXMiOlsiYWRtaW4iLCJhdWRpdG9yIl19.SIGNATURE"

	payload, err := decodeJWTPayload(token)
	if err != nil {
		log.Fatalf("jwt: %v", err)
	}
	fmt.Printf("Subject: %s\n", payload.Subject)
	fmt.Printf("Issuer:  %s\n", payload.Issuer)
	fmt.Printf("Roles:   %v\n", payload.Roles)
	// Subject: usr-442
	// Issuer:  auth.example.com
	// Roles:   [admin auditor]
}

Yaygın Hatalar

Bu dördünün hepsine gerçek kod incelemelerinde rastladım — özellikle ilk ikisi, biri yeni bir auth sağlayıcısını entegre ettiğinde neredeyse her seferinde ortaya çıkıyor.

❌ URL-güvenli girdi üzerinde StdEncoding kullanmak

Sorun: JWT ve OAuth token'ları URL-güvenli Base64 alfabesi (- ve _) kullanır. Bunları StdEncoding.DecodeString'e geçirmek 'illegal base64 data' hatasıyla başarısız olur.

Çözüm: Girdi kaynağınızı kontrol edin: auth sistemlerinden gelen token'lar RawURLEncoding kullanır; ikili ekler StdEncoding kullanır.

Before · Go

After · Go

// JWT başlığı — URL-güvenli, dolgu yok
token := "eyJhbGciOiJSUzI1NiJ9"
decoded, err := base64.StdEncoding.DecodeString(token)
// err: illegal base64 data at input byte 19

// JWT başlığı — doğru kodlama
token := "eyJhbGciOiJSUzI1NiJ9"
decoded, err := base64.RawURLEncoding.DecodeString(token)
// decoded: {"alg":"RS256"}
// err: nil

❌ Decode'dan dönen n değerini göz ardı etmek

Sorun: Decode, önceden tahsis edilmiş bir tampona yazar ve gerçekte yazılan byte sayısını döndürür. DecodedLen üst sınırı döndürür, bu nedenle tamponun kuyruğu çöp byte içerebilir.

Çözüm: Sonucu her zaman dst[:n] ile dilimleyin — dst[:len(dst)] değil.

Before · Go

After · Go

dst := make([]byte, base64.StdEncoding.DecodedLen(len(src)))
base64.StdEncoding.Decode(dst, src)
fmt.Println(string(dst)) // sondaki sıfır byte'lar içerebilir

dst := make([]byte, base64.StdEncoding.DecodedLen(len(src)))
n, err := base64.StdEncoding.Decode(dst, src)
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(dst[:n])) // doğru — yalnızca kod çözülmüş byte'lar

❌ Kod çözmeden önce boşlukları temizlememek

Sorun: Terminallerden, e-postalardan veya yapılandırma dosyalarından kopyalanan Base64 string'lerinde genellikle sondaki yeni satırlar veya boşluklar bulunur. Bunları doğrudan DecodeString'e geçirmek boşluk karakterinde başarısız olur.

Çözüm: Kod çözmeden önce strings.TrimSpace (ve gömülü yeni satırlar için strings.ReplaceAll) çağrısı yapın.

Before · Go

After · Go

// Yapılandırma dosyasından okunan değer, sonda yeni satır içeriyor
encoded := "c2VydmljZV9rZXk6eEtNcDI=\n"
decoded, err := base64.StdEncoding.DecodeString(encoded)
// err: illegal base64 data at input byte 24

encoded := "c2VydmljZV9rZXk6eEtNcDI=\n"
cleaned := strings.TrimSpace(encoded)
decoded, err := base64.StdEncoding.DecodeString(cleaned)
// decoded: "service_key:xKMp2"
// err: nil

❌ Kod çözülmüş byte'ları yanlış şekilde string olarak saklamak

Sorun: İkili veri (görseller, sıkıştırılmış yükler) üzerinde string(decoded) çağrısı geçersiz UTF-8 string'leri üretir. Go string'leri rastgele byte'ları tutabilir, ancak bazı işlemler içeriği bozar.

Çözüm: İkili verileri pipeline boyunca []byte olarak tutun. string(decoded) yalnızca kod çözülmüş içeriğin metin olduğundan emin olduğunuzda çağrısı yapın.

Before · Go

After · Go

decoded, _ := base64.StdEncoding.DecodeString(pngBase64)
// İkili PNG'yi string olarak işlemek veri kaybına yol açar
imageStr := string(decoded)
os.WriteFile("image.png", []byte(imageStr), 0644) // bozulabilir

decoded, err := base64.StdEncoding.DecodeString(pngBase64)
if err != nil {
    log.Fatal(err)
}
// Byte'ları doğrudan yaz — string dönüşümü yok
os.WriteFile("image.png", decoded, 0644)

Metot Karşılaştırması

Tüm varyantlar standart kütüphanede yer alır — bunların hiçbiri için harici bağımlılık gerekmez.

Metot

Girdi Tipi

Kodlama Varyantları

Akış

Özel Alfabe

Özel Dolgu

Kurulum Gerekir

StdEncoding.DecodeString

string

Standart

✗

Hayır (stdlib)

URLEncoding.DecodeString

string

URL-güvenli

✗

Hayır (stdlib)

RawStdEncoding.DecodeString

string

Standart (dolgu yok)

✗

Hayır (stdlib)

RawURLEncoding.DecodeString

string

URL-güvenli (dolgu yok)

✗

Hayır (stdlib)

StdEncoding.Decode

[]byte

Standart

✗

Hayır (stdlib)

base64.NewDecoder

io.Reader

Herhangi

✓

✗

Hayır (stdlib)

encoding/base64 + NewEncoding

string

Özel alfabe

✗

✓

Hayır (stdlib)

JWT ve OAuth akışları için: RawURLEncoding. E-posta ekleri ve MIME verisi için: StdEncoding. Diskten veya ağdan gelen büyük ikili dosyalar için: base64.NewDecoder ile bir reader sarmalayın — dosya boyutundan bağımsız olarak bellek kullanımını sabit tutar. Özel bir alfabeye mi ihtiyaç var? base64.NewEncoding(alphabet) alışılmadık kullanım durumları için yeni bir kodlama nesnesi oluşturur.

Geliştirme sırasında hızlı tek seferlik kontroller için çevrimiçi Base64 Kod Çözücü bir Go programı başlatmaktan daha hızlıdır.

Sık Sorulan Sorular

Go'da Base64 string nasıl kod çözülür?

encoding/base64 paketini import edin ve base64.StdEncoding.DecodeString(s) çağrısı yapın. ([]byte, error) döndürür — hatayı her zaman kontrol edin. String URL-güvenli karakterler (+ ve / yerine - ve _) içeriyorsa bunun yerine base64.URLEncoding.DecodeString kullanın. JWT token'ları ve modern API'lerin çoğu için RawURLEncoding (dolgu yok) doğru seçimdir.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"log"
)

func main() {
	encoded := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"
	decoded, err := base64.RawURLEncoding.DecodeString(encoded)
	if err != nil {
		log.Fatalf("decode: %v", err)
	}
	fmt.Println(string(decoded))
	// {"alg":"HS256","typ":"JWT"}
}

Go'da StdEncoding ile URLEncoding arasındaki fark nedir?

StdEncoding, + ve / karakterleriyle standart Base64 alfabesini ve = dolgu karakterini kullanır — RFC 4648 §4'te tanımlanmıştır. URLEncoding, +'yı - ile ve /'yi _ ile değiştirerek çıktıyı URL'lerde ve HTTP başlıklarında yüzde-kodlama gerektirmeden kullanılabilir hale getirir — RFC 4648 §5'te tanımlanmıştır. JWT token'ları, OAuth token'ları ve sorgu dizelerine gömülen veriler için URLEncoding kullanın.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	// Standart: + / ve = karakterleri içerebilir
	std := base64.StdEncoding.EncodeToString([]byte("hello/world"))
	fmt.Println(std) // "aGVsbG8vd29ybGQ="

	// URL-güvenli: + yerine - ve / yerine _ kullanır
	url := base64.URLEncoding.EncodeToString([]byte("hello/world"))
	fmt.Println(url) // "aGVsbG8vd29ybGQ=" (aynı — farklı byte'larla fark görünür)

	// JWT başlıklarında hiçbir zaman dolgu olmaz — RawURLEncoding kullanın
	raw := base64.RawURLEncoding.EncodeToString([]byte("hello/world"))
	fmt.Println(raw) // "aGVsbG8vd29ybGQ" (sondaki = yok)
}

Go'da "illegal base64 data" hataları nasıl düzeltilir?

Bu hata, girdinin beklenen alfabe dışında karakterler içerdiği veya dolgunun yanlış olduğu anlamına gelir. Üç yaygın neden: URL-güvenli girdi üzerinde StdEncoding kullanmak (URLEncoding ile değiştirin), dolgulu encoder'ı dolgusuz girdi üzerinde kullanmak (RawStdEncoding/RawURLEncoding ile değiştirin) veya sondaki boşluklar/yeni satırlar. Kod çözmeden önce strings.TrimSpace ile boşlukları temizleyin.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"log"
	"strings"
)

func main() {
	// Webhook payload'ından gelen girdi — yeni satırlar temizlenmiş
	raw := "  aGVsbG8gd29ybGQ=  \n"
	cleaned := strings.TrimSpace(raw)

	decoded, err := base64.StdEncoding.DecodeString(cleaned)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(decoded)) // hello world
}

Go'da büyük Base64 kodlanmış bir dosya akış olarak nasıl kod çözülür?

base64.NewDecoder(base64.StdEncoding, reader) kullanın; bu, herhangi bir io.Reader'ı sarmalayarak anında kod çözme yapar. Tüm dosyayı belleğe almadan hedefe yazmak için io.Copy ile birleştirin. Bu, Base64 kodlanmış ikili ekleri veya büyük veri yüklerini kod çözmek için standart kalıptır.

Go 1.21+

package main

import (
	"encoding/base64"
	"io"
	"log"
	"os"
)

func main() {
	src, err := os.Open("attachment.b64")
	if err != nil {
		log.Fatal(err)
	}
	defer src.Close()

	dst, err := os.Create("attachment.bin")
	if err != nil {
		log.Fatal(err)
	}
	defer dst.Close()

	decoder := base64.NewDecoder(base64.StdEncoding, src)
	io.Copy(dst, decoder)
}

Go'da JWT library kullanmadan Base64 JWT payload'ı kod çözebilir miyim?

Evet. JWT, nokta ile ayrılmış üç Base64url kodlanmış segmentten oluşur. "." üzerinde bölün ve ikinci segmenti (index 1) base64.RawURLEncoding.DecodeString ile kod çözün — JWT başlıkları ve payload'ları URL-güvenli alfabe kullanır ve dolgu içermez. İmza segmenti (index 2) ikil veridir ve genellikle yalnızca doğrulama için gereklidir.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"log"
	"strings"
)

func main() {
	token := "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c3ItOTAxIiwicm9sZSI6ImFkbWluIn0.SIG"
	parts := strings.Split(token, ".")
	if len(parts) < 2 {
		log.Fatal("invalid JWT format")
	}

	payload, err := base64.RawURLEncoding.DecodeString(parts[1])
	if err != nil {
		log.Fatalf("decode payload: %v", err)
	}
	fmt.Println(string(payload))
	// {"sub":"usr-901","role":"admin"}
}

HTTP API yanıtından gelen Base64 verisini kod çözmek için hangi kodlamayı kullanmalıyım?

API belgelerini kontrol edin veya kodlanmış string'i inceleyin. + veya / karakterleri içeriyor ve = ile bitiyorsa StdEncoding kullanın. - ve _ karakterleri içeriyor ve = yoksa RawURLEncoding kullanın. Emin değilseniz önce RawURLEncoding deneyin — çoğu modern API (OAuth2, JWT, Google Cloud, AWS) dolgu olmaksızın URL-güvenli Base64 kullanır.

Go 1.21+

package main

import (
	"encoding/base64"
	"strings"
)

// Kodlanmış string'den kodlama varyantını tespit et
func decodeAPIPayload(encoded string) ([]byte, error) {
	// Dolgu olmaksızın URL-güvenli karakterler — modern API'lerde yaygın
	if !strings.Contains(encoded, "+") && !strings.Contains(encoded, "/") {
		return base64.RawURLEncoding.DecodeString(encoded)
	}
	// Dolgulu standart Base64
	return base64.StdEncoding.DecodeString(encoded)
}

İlgili Araçlar

Base64 Kodlayıcı — ikili veriyi veya metni tarayıcıda Base64'e kodlayın; Go unit testlerinize yapıştırmak için test fixture'ları oluşturmada kullanışlıdır.
JWT Kod Çözücü — üç JWT segmentinin tamamını tek seferde ayırıp kod çözün; alan alan payload incelemesiyle — hata ayıklama sırasında bir token okumak için Go kodu yazmanıza gerek yoktur.
URL Kod Çözücü — URL kodlanmış string'leri yüzde-çöz; API yanıtları Base64url verisiyle yüzde-kodlanmış sorgu parametrelerini bir arada içerdiğinde kullanışlıdır.
JSON Biçimlendirici — Base64 JWT payload'ını veya API yanıtını kod çözdükten sonra JSON'ı buraya yapıştırarak yapıyı anında güzelleştirin ve doğrulayın.