Dekodowanie Base64 w Go — encoding/base64 z przykładami

Dekodowanie Base64 w Go pojawia się nieustannie — inspekcja JWT, binarne załączniki plików, ładunki API z usług chmurowych. Standardowy pakiet encoding/base64w Go obsługuje to wszystko, ale wybór niewłaściwego wariantu kodowania (standard vs URL-safe, z dopełnieniem vs bez dopełnienia) jest jedynym najczęstszym źródłem błędów “illegal base64 data”. Ten przewodnik omawia StdEncoding, URLEncoding, RawURLEncoding, strumieniowe dekodowanie za pomocą base64.NewDecoder, inspekcję ładunków JWT oraz cztery błędy, na które prawie każdy wpada za pierwszym razem. Do jednorazowego dekodowania w przeglądarce Dekoder Base64 ToolDeck załatwia sprawę natychmiast, bez pisania ani jednej linii kodu.

✓encoding/base64 jest częścią standardowej biblioteki Go — go get nie jest wymagane
✓Używaj RawURLEncoding dla tokenów JWT i większości nowoczesnych API (bez dopełnienia, alfabet URL-safe)
✓StdEncoding używa + i / z dopełnieniem =; URLEncoding zamienia je na - i _ zachowując dopełnienie
✓base64.NewDecoder opakowuje dowolny io.Reader do strumieniowego dekodowania bez ładowania do pamięci
✓Zawsze sprawdzaj zwrócony błąd — nieprawidłowe dopełnienie i zły alfabet powodują błąd illegal base64 data

Czym jest dekodowanie Base64?

Kodowanie Base64 reprezentuje dane binarne jako tekst ASCII przy użyciu 64 drukowalnych znaków (A–Z, a–z, 0–9 i dwóch dodatkowych). Dekodowanie odwraca ten proces — konwertuje tę reprezentację ASCII z powrotem na oryginalne bajty. Każde 4 znaki Base64 dekodują się dokładnie do 3 bajtów. Schemat ten istnieje, ponieważ wiele warstw transportowych (email, nagłówki HTTP, pola JSON) jest zaprojektowanych dla tekstu, nie surowych danych binarnych. Poniżej wygląd pełnego cyklu kodowania i dekodowania:

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	// Raw bytes → Base64 encoded → decoded back to raw bytes
	original := []byte("service_token:xK9mP2qR")
	// Encoded: "c2VydmljZV90b2tlbjp4SzltUDJxUg=="

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

Dekodowanie Base64 w Go za pomocą encoding/base64

Pakiet encoding/base64 jest dołączony do Go — bez zewnętrznych zależności. Udostępnia cztery predefiniowane warianty kodowania jako zmienne na poziomie pakietu. Najczęściej używaną funkcją dla danych wejściowych w postaci ciągu znaków jest DecodeString, która zwraca wycinek bajtów i błąd.

Go 1.21+

package main

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

func main() {
	// Standard Base64 — the alphabet uses + and / with = padding
	encoded := "eyJob3N0IjoiZGItcHJvZCF1cy1lYXN0LTEiLCJwb3J0Ijo1NDMyfQ=="
	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}
}

Metoda Decode operuje na wycinkach bajtów zamiast ciągów znaków i zapisuje wynik do wstępnie przydzielonego bufora docelowego. Musisz prawidłowo dobrać rozmiar bufora — użyj base64.StdEncoding.DecodedLen(len(src)), aby uzyskać maksymalny rozmiar (może być o kilka bajtów większy niż faktyczna długość zdekodowanych danych ze względu na dopełnienie).

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

Uwaga:DecodedLen zwraca górne ograniczenie, a nie dokładną długość. Zawsze używaj wartości zwracanej n z Decode, aby prawidłowo wyciąć wynik: dst[:n].

StdEncoding vs URLEncoding — Wybór właściwego wariantu

To tutaj kryje się większość nieporozumień. encoding/base64 w Go udostępnia cztery obiekty kodowania, a wybór niewłaściwego gwarantuje błąd. Różnica sprowadza się do dwóch rzeczy: alfabetu i dopełnienia.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	// JWT header payload — URL-safe, no padding
	jwtHeader := "eyJhbGciOiJSUzI1NiIsImtpZCI6IjIwMjMtMDkifQ"

	// Wrong: StdEncoding fails on URL-safe input without padding
	_, err1 := base64.StdEncoding.DecodeString(jwtHeader)
	fmt.Println("StdEncoding error:", err1)
	// StdEncoding error: illegal base64 data at input byte 43

	// Correct: RawURLEncoding — no padding, URL-safe alphabet
	decoded, err2 := base64.RawURLEncoding.DecodeString(jwtHeader)
	fmt.Println("RawURLEncoding ok:", err2, "→", string(decoded))
	// RawURLEncoding ok: <nil> → {"alg":"RS256","kid":"2023-09"}
}

Cztery warianty w prostych słowach:

Funkcja / Metoda

Kodowanie

Wymagane dopełnienie

Zwraca

base64.StdEncoding.DecodeString(s)

Standard (+, /)

Tak (=)

([]byte, error)

base64.URLEncoding.DecodeString(s)

URL-safe (-, _)

Tak (=)

([]byte, error)

base64.RawStdEncoding.DecodeString(s)

Standard (+, /)

Nie

([]byte, error)

base64.RawURLEncoding.DecodeString(s)

URL-safe (-, _)

Nie

([]byte, error)

base64.StdEncoding.Decode(dst, src)

Standard (+, /)

Tak (=)

(n int, error)

base64.NewDecoder(enc, r)

Dowolne kodowanie

Tak

io.Reader

Moja zasada kciuka: jeśli dane pochodzą z JWT, przepływu OAuth lub SDK dostawcy chmury, sięgnij najpierw po RawURLEncoding. Jeśli pochodzą z załączników email lub starych formularzy webowych, wypróbuj StdEncoding. Komunikat błędu zawsze wskazuje dokładną pozycję bajtu, w której dekodowanie zakończyło się niepowodzeniem.

Dekodowanie Base64 z pliku i odpowiedzi API

Odczyt pliku zakodowanego w Base64

Pliki binarne (obrazy, PDF-y, certyfikaty) są czasem przechowywane na dysku zakodowane w Base64. Odczytaj plik, usuń końcowe białe znaki, a następnie zdekoduj:

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

	// Strip newlines — Base64 files often have line breaks every 76 chars
	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))
}

Dekodowanie pola Base64 z odpowiedzi JSON API

Chmurowe API często zwracają dane binarne (klucze szyfrowania, podpisane dane, miniatury) jako ciągi Base64 wewnątrz JSON. Najpierw odczytaj JSON, a następnie zdekoduj docelowe pole:

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-encoded secret value
	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)
}

Uwaga:Opakowuj błędy za pomocą fmt.Errorf("decode base64: %w", err) zamiast tracić kontekst. Oryginalny komunikat błędu z encoding/base64 zawiera pozycję bajtu, w której wystąpił błąd, co jest przydatne podczas debugowania.

Strumieniowanie dużych plików zakodowanych w Base64

Załadowanie pliku zakodowanego w Base64 o rozmiarze 500 MB do pamięci za pomocą os.ReadFile, a następnie wywołanie DecodeString, zużywa około 750 MB RAM (zakodowany ciąg plus zdekodowane bajty). base64.NewDecoder opakowuje dowolny io.Reader i dekoduje porcjami, utrzymując zużycie pamięci niemal stałym. Połącz go z io.Copy, aby uzyskać przejrzysty potok strumieniowania:

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

Ostrzeżenie:base64.NewDecoder oczekuje czystych, nieprzerwanych danych Base64. Jeśli plik źródłowy zawiera znaki nowej linii (typowe dla plików PEM i MIME), opakuj czytnik źródłowy w czytnik usuwający linie lub przetwórz plik wstępnie, usuwając znaki nowej linii przed strumieniowaniem.

Dekodowanie Base64 z wiersza poleceń

Większość programistów Go sięga najpierw po wiersz poleceń podczas debugowania. Każdy system macOS i Linux ma zainstalowane narzędzie base64; w systemie Windows PowerShell ma wbudowany odpowiednik. Do szybkiej inspekcji ładunków API są szybsze niż pisanie skryptu Go.

bash

# Decode a Base64 string (Linux / macOS)
echo "eyJob3N0IjoiZGItcHJvZCIsInBvcnQiOjU0MzJ9" | base64 --decode
# {"host":"db-prod","port":5432}

# Decode and pretty-print with jq (pipe the JSON output)
echo "eyJob3N0IjoiZGItcHJvZCIsInBvcnQiOjU0MzJ9" | base64 --decode | jq .
# {
#   "host": "db-prod",
#   "port": 5432
# }

# Decode a Base64-encoded file to binary
base64 --decode < encrypted_payload.b64 > encrypted_payload.bin

# macOS uses -D flag instead of --decode
echo "c2VjcmV0LXRva2Vu" | base64 -D

Do inspekcji tokenów JWT bez żadnych zainstalowanych narzędzi wklej token do Dekodera Base64 ToolDeck — podziel po kropkach i zdekoduj każdą część.

Wysoka wydajność: encoding/base64 jest już szybkie

W przeciwieństwie do Pythona, gdzie wybór między orjson a json ma realne znaczenie dla wydajności, encoding/base64 w Go jest już zoptymalizowane w asemblerze i naprawdę szybkie dla większości obciążeń. Jednak jeśli przetwarzasz miliony rekordów w ciasnej pętli, filippo.io/base64 zapewnia dekodowanie akcelerowane SIMD z identycznym API.

bash

go get filippo.io/base64

Go 1.21+

package main

import (
	"fmt"
	"log"

	"filippo.io/base64"
)

func main() {
	// Drop-in replacement — same API as encoding/base64
	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}
}

Przyrost wydajności jest najbardziej widoczny na amd64 z obsługą AVX2 — benchmarki pokazują 2–4-krotną poprawę przepustowości na dużych danych wejściowych. W przypadku codziennego dekodowania odpowiedzi API (kilkaset bajtów naraz) trzymaj się biblioteki standardowej.

Dekodowanie ładunku JWT Base64 w Go

Inspekcja JWT pojawia się niemal w każdej usłudze backendowej. Z mojego doświadczenia większość sesji debugowania sprowadza się do pytania “co tak naprawdę jest w tym tokenie?” — i możesz odpowiedzieć bez potrzeby importowania pełnej biblioteki JWT. Token ma trzy segmenty zakodowane w Base64url, oddzielone kropkami. Środkowy segment to ładunek, na którym faktycznie ci zależy:

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 uses RawURLEncoding — URL-safe alphabet, no = padding
	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]
}

Częste błędy

Spotkałem wszystkie cztery w prawdziwych przeglądach kodu — pierwsze dwa pojawiają się niemal za każdym razem, gdy ktoś integruje nowego dostawcę uwierzytelniania.

❌ Użycie StdEncoding na danych URL-safe

Problem: Tokeny JWT i tokeny OAuth używają alfabetu Base64 URL-safe (- i _). Przekazanie ich do StdEncoding.DecodeString kończy się błędem 'illegal base64 data'.

Rozwiązanie: Sprawdź źródło danych wejściowych: tokeny z systemów uwierzytelniania używają RawURLEncoding; binarne załączniki używają StdEncoding.

Before · Go

After · Go

// JWT header — URL-safe, no padding
token := "eyJhbGciOiJSUzI1NiJ9"
decoded, err := base64.StdEncoding.DecodeString(token)
// err: illegal base64 data at input byte 19

// JWT header — correct encoding
token := "eyJhbGciOiJSUzI1NiJ9"
decoded, err := base64.RawURLEncoding.DecodeString(token)
// decoded: {"alg":"RS256"}
// err: nil

❌ Ignorowanie wartości zwracanej n przez Decode

Problem: Decode zapisuje do wstępnie przydzielonego bufora i zwraca liczbę faktycznie zapisanych bajtów. DecodedLen zwraca górne ograniczenie, więc ogon bufora może zawierać śmieci.

Rozwiązanie: Zawsze wycinaj wynik przez dst[:n] — nie przez dst[:len(dst)].

Before · Go

After · Go

dst := make([]byte, base64.StdEncoding.DecodedLen(len(src)))
base64.StdEncoding.Decode(dst, src)
fmt.Println(string(dst)) // może zawierać końcowe bajty zerowe

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])) // poprawnie — tylko zdekodowane bajty

❌ Brak usuwania białych znaków przed dekodowaniem

Problem: Ciągi Base64 skopiowane z terminali, emaili lub plików konfiguracyjnych często mają końcowe znaki nowej linii lub spacje. Przekazanie ich bezpośrednio do DecodeString kończy się błędem przy białym znaku.

Rozwiązanie: Wywołaj strings.TrimSpace (i strings.ReplaceAll dla osadzonych znaków nowej linii) przed dekodowaniem.

Before · Go

After · Go

// Wartość odczytana z pliku konfiguracyjnego z końcowym znakiem nowej linii
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

❌ Nieprawidłowe przechowywanie zdekodowanych bajtów jako string

Problem: Wywołanie string(decoded) na danych binarnych (obrazy, skompresowane ładunki) produkuje nieprawidłowe ciągi UTF-8. Ciągi Go mogą przechowywać dowolne bajty, ale niektóre operacje mogą zniekształcić zawartość.

Rozwiązanie: Przechowuj dane binarne jako []byte w całym potoku. Wywołuj string(decoded) tylko wtedy, gdy zdekodowana zawartość jest gwarantowanie tekstem.

Before · Go

After · Go

decoded, _ := base64.StdEncoding.DecodeString(pngBase64)
// Traktowanie binarnego PNG jako ciągu powoduje utratę danych
imageStr := string(decoded)
os.WriteFile("image.png", []byte(imageStr), 0644) // może uszkodzić plik

decoded, err := base64.StdEncoding.DecodeString(pngBase64)
if err != nil {
    log.Fatal(err)
}
// Write bytes directly — no string conversion
os.WriteFile("image.png", decoded, 0644)

Porównanie metod

Wszystkie warianty są dostarczane z biblioteką standardową — żadna z tych metod nie wymaga zewnętrznych zależności.

Metoda

Typ wejścia

Warianty kodowania

Strumieniowanie

Własny alfabet

Własne dopełnienie

Wymaga instalacji

StdEncoding.DecodeString

string

Standard

✗

Nie (stdlib)

URLEncoding.DecodeString

string

URL-safe

✗

Nie (stdlib)

RawStdEncoding.DecodeString

string

Standard (bez pad.)

✗

Nie (stdlib)

RawURLEncoding.DecodeString

string

URL-safe (bez pad.)

✗

Nie (stdlib)

StdEncoding.Decode

[]byte

Standard

✗

Nie (stdlib)

base64.NewDecoder

io.Reader

Dowolne

✓

✗

Nie (stdlib)

encoding/base64 + NewEncoding

string

Własny alfabet

✗

✓

Nie (stdlib)

Dla tokenów JWT i przepływów OAuth: RawURLEncoding. Dla załączników email i danych MIME: StdEncoding. Dla dużych plików binarnych z dysku lub sieci: opakuj czytnik w base64.NewDecoder — utrzymuje stałe zużycie pamięci niezależnie od rozmiaru pliku. Potrzebujesz własnego alfabetu? base64.NewEncoding(alphabet) tworzy nowy obiekt kodowania dla egzotycznych przypadków użycia.

Do szybkich jednorazowych sprawdzeń podczas programowania internetowy Dekoder Base64 jest szybszy niż uruchamianie programu Go.

Często zadawane pytania

Jak zdekodować ciąg Base64 w Go?

Zaimportuj encoding/base64 i wywołaj base64.StdEncoding.DecodeString(s). Funkcja zwraca ([]byte, error) — zawsze sprawdzaj błąd. Jeśli ciąg używa znaków URL-safe (- i _ zamiast + i /), użyj base64.URLEncoding.DecodeString. W przypadku tokenów JWT i większości nowoczesnych API właściwym wyborem jest RawURLEncoding (bez dopełnienia).

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

Jaka jest różnica między StdEncoding a URLEncoding w Go?

StdEncoding używa standardowego alfabetu Base64 ze znakami + i / oraz dopełnieniem = — zdefiniowanego w RFC 4648 §4. URLEncoding zastępuje + przez - oraz / przez _, dzięki czemu dane wyjściowe są bezpieczne w adresach URL i nagłówkach HTTP bez percent-encoding — zdefiniowane w RFC 4648 §5. Używaj URLEncoding dla tokenów JWT, tokenów OAuth i wszelkich danych osadzanych w query stringach.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	// Standard: może zawierać znaki + / i =
	std := base64.StdEncoding.EncodeToString([]byte("hello/world"))
	fmt.Println(std) // "aGVsbG8vd29ybGQ="

	// URL-safe: zastępuje + przez - i / przez _
	url := base64.URLEncoding.EncodeToString([]byte("hello/world"))
	fmt.Println(url) // "aGVsbG8vd29ybGQ=" (takie samo — różnica widoczna przy innych bajtach)

	// Nagłówki JWT nigdy nie mają dopełnienia — użyj RawURLEncoding
	raw := base64.RawURLEncoding.EncodeToString([]byte("hello/world"))
	fmt.Println(raw) // "aGVsbG8vd29ybGQ" (brak końcowego =)
}

Jak naprawić błąd "illegal base64 data" w Go?

Ten błąd oznacza, że dane wejściowe zawierają znaki spoza oczekiwanego alfabetu lub dopełnienie jest nieprawidłowe. Trzy częste przyczyny: użycie StdEncoding na danych URL-safe (zamień na URLEncoding), użycie kodera z dopełnieniem na danych bez dopełnienia (zamień na RawStdEncoding/RawURLEncoding) lub końcowe białe znaki/znaki nowej linii. Przed dekodowaniem usuń białe znaki za pomocą strings.TrimSpace.

Go 1.21+

package main

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

func main() {
	// Dane z webhooka — usunięto znaki nowej linii z formatu przesyłu
	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
}

Jak strumieniować dekodowanie dużego pliku zakodowanego w Base64 w Go?

Użyj base64.NewDecoder(base64.StdEncoding, reader), który opakowuje dowolny io.Reader i dekoduje dane na bieżąco. Przepuść go przez io.Copy, żeby zapisywać do miejsca docelowego bez buforowania całego pliku w pamięci. To standardowy wzorzec dla dekodowania binarnych załączników zakodowanych w Base64 lub dużych ładunków danych.

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

Czy mogę zdekodować ładunek JWT w Base64 w Go bez biblioteki JWT?

Tak. JWT to trzy segmenty zakodowane w Base64url, połączone kropkami. Podziel po "." i zdekoduj drugi segment (indeks 1) za pomocą base64.RawURLEncoding.DecodeString — nagłówki i ładunki JWT używają alfabetu URL-safe bez dopełnienia. Segment podpisu (indeks 2) jest binarny i zazwyczaj potrzebny tylko do weryfikacji.

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("nieprawidłowy format JWT")
	}

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

Jakiego kodowania użyć do dekodowania danych Base64 z odpowiedzi HTTP API?

Sprawdź dokumentację API lub przejrzyj zakodowany ciąg. Jeśli zawiera znaki + lub / i kończy się =, użyj StdEncoding. Jeśli używa znaków - i _ bez =, użyj RawURLEncoding. W razie wątpliwości najpierw spróbuj RawURLEncoding — większość nowoczesnych API (OAuth2, JWT, Google Cloud, AWS) używa URL-safe Base64 bez dopełnienia.

Go 1.21+

package main

import (
	"encoding/base64"
	"strings"
)

// Wykryj wariant kodowania na podstawie zakodowanego ciągu
func decodeAPIPayload(encoded string) ([]byte, error) {
	// Znaki URL-safe bez dopełnienia — typowe dla nowoczesnych API
	if !strings.Contains(encoded, "+") && !strings.Contains(encoded, "/") {
		return base64.RawURLEncoding.DecodeString(encoded)
	}
	// Standardowy Base64 z dopełnieniem
	return base64.StdEncoding.DecodeString(encoded)
}

Powiązane narzędzia

Enkoder Base64 — zakoduj dane binarne lub tekst do Base64 w przeglądarce, przydatne do generowania testowych danych wejściowych do wklejenia do testów jednostkowych Go.
Dekoder JWT — podziel i zdekoduj wszystkie trzy segmenty JWT jednocześnie, z inspekcją ładunku pole po polu — żaden kod Go nie jest potrzebny, gdy chcesz tylko odczytać token podczas debugowania.
Dekoder URL — dekoduj percent-encoded ciągi URL, przydatne gdy odpowiedzi API mieszają dane Base64url z parametrami zapytania zakodowanymi procentowo.
Formater JSON — po zdekodowaniu ładunku JWT lub odpowiedzi API w Base64, wklej JSON tutaj, aby natychmiast sformatować i zwalidować strukturę.