Base64 Encoder og Decoder: Konverter tekst til/fra Base64

Base64 Encoder og Decoder

Introduktion

Base64 er et binært-til-tekst kodningsskema, der repræsenterer binære data i et ASCII-strengformat. Det er designet til at transportere data, der er gemt i binære formater, over kanaler, der kun pålideligt understøtter tekstindhold. Base64 kodning konverterer binære data til et sæt af 64 tegn (deraf navnet), som kan overføres sikkert over tekstbaserede protokoller uden datakorruption.

Base64-tegnsættet består af:

Store bogstaver A-Z (26 tegn)
Små bogstaver a-z (26 tegn)
Cifrene 0-9 (10 tegn)
To ekstra tegn, typisk "+" og "/" (2 tegn)

Dette værktøj giver dig mulighed for nemt at kode tekst til Base64-format eller dekode Base64-strenge tilbage til deres oprindelige tekst. Det er særligt nyttigt for udviklere, IT-professionelle og alle, der arbejder med data, der skal overføres sikkert over tekstbaserede kanaler.

Hvordan Base64 Kodning Fungerer

Kodningsproces

Base64 kodning fungerer ved at konvertere hver gruppe af tre bytes (24 bits) af binære data til fire Base64-tegn. Processen følger disse trin:

Konverter den indtastede tekst til dens binære repræsentation (ved hjælp af ASCII eller UTF-8 kodning)
Gruppér de binære data i klumper af 24 bits (3 bytes)
Del hver 24-bit klump op i fire 6-bit grupper
Konverter hver 6-bit gruppe til det tilsvarende Base64-tegn

Når længden af input ikke er delelig med 3, tilføjes polstring med "=" tegn for at opretholde forholdet 4:3 mellem output- og inputlængder.

Matematisk Repræsentation

For en sekvens af bytes $b_1, b_2, b_3$ , beregnes de tilsvarende Base64-tegn $c_1, c_2, c_3, c_4$ som:

$c_1 = \text{Base64}[(b_1 >> 2)]$ $c_2 = \text{Base64}[((b_1 \& 3) << 4) | (b_2 >> 4)]$ $c_3 = \text{Base64}[((b_2 \& 15) << 2) | (b_3 >> 6)]$ $c_4 = \text{Base64}[(b_3 \& 63)]$

Hvor $\text{Base64}[i]$ repræsenterer det $i$ -te tegn i Base64 alfabetet.

Dekodningsproces

Base64 dekodning reverserer kodningsprocessen:

Konverter hvert Base64-tegn til dets 6-bit værdi
Sammenkæd disse 6-bit værdier
Gruppér bits i 8-bit klumper (bytes)
Konverter hver byte til det tilsvarende tegn

Polstring

Når antallet af bytes, der skal kodes, ikke er deleligt med 3, anvendes polstring:

Hvis der er én byte tilbage, konverteres den til to Base64-tegn efterfulgt af "=="
Hvis der er to bytes tilbage, konverteres de til tre Base64-tegn efterfulgt af "="

Eksempel

Lad os kode teksten "Hello" til Base64:

ASCII-repræsentation af "Hello": 72 101 108 108 111
Binær repræsentation: 01001000 01100101 01101100 01101100 01101111
Gruppér i 6-bit klumper: 010010 000110 010101 101100 011011 000110 1111
Den sidste klump har kun 4 bits, så vi polstrer med nuller: 010010 000110 010101 101100 011011 000110 111100
Konvertering til decimal: 18, 6, 21, 44, 27, 6, 60
Opslag i Base64 alfabetet: S, G, V, s, b, G, 8
Resultatet er "SGVsbG8="

Bemærk polstringen "=" i slutningen, fordi inputlængden (5 bytes) ikke er delelig med 3.

Formel

Den generelle formel til beregning af længden af en Base64 kodet streng er:

$\text{encoded\_length} = 4 \times \lceil \frac{\text{input\_length}}{3} \rceil$

Hvor $\lceil x \rceil$ repræsenterer loftfunktionen (afrunding op til nærmeste heltal).

Anvendelsesområder

Base64 kodning bruges bredt i forskellige applikationer:

E-mail Vedhæftninger: MIME (Multipurpose Internet Mail Extensions) bruger Base64 til at kode binære vedhæftninger i e-mail.
Data URLs: Indlejring af små billeder, skrifttyper eller andre ressourcer direkte i HTML, CSS eller JavaScript ved hjælp af data: URL-scheme.
API Kommunikation: Sikkert overføre binære data i JSON-payloads eller andre tekstbaserede API-formater.
Lagring af Binære Data i Tekstformater: Når binære data skal gemmes i XML, JSON eller andre tekstbaserede formater.
Autentificeringssystemer: Basic Authentication i HTTP bruger Base64 kodning (selvom det ikke er til sikkerhed, kun til kodning).
Kryptografi: Som en del af forskellige kryptografiske protokoller og systemer, ofte til kodning af nøgler eller certifikater.
Cookie Værdier: Kodning af komplekse datastrukturer til at blive gemt i cookies.

Alternativer

Selvom Base64 er meget anvendt, er der alternativer, der måske er mere passende i visse situationer:

URL-sikker Base64: En variant, der bruger "-" og "_" i stedet for "+" og "/" for at undgå URL-kodningsproblemer. Nyttig til data, der skal inkluderes i URLs.
Base32: Bruger et 32-tegns sæt, hvilket resulterer i længere output, men med bedre menneskelig læsbarhed og case-insensitivitet.
Hex Kodning: Enkel konvertering til hexadecimal, som er mindre effektiv (fordobler størrelsen), men meget simpel og bredt understøttet.
Binær Overførsel: For store filer eller når effektivitet er afgørende, er direkte binær overførselsprotokoller som HTTP med passende Content-Type headers at foretrække.
Kompression + Base64: For store tekstdata kan komprimering før kodning mindske størrelsesforøgelsen.
JSON/XML Serialisering: For strukturerede data kan brugen af native JSON eller XML serialisering være mere passende end Base64 kodning.

Historie

Base64 kodning har sine rødder i tidlig computing og telekommunikationssystemer, hvor binære data skulle overføres over kanaler designet til tekst.

Den formelle specifikation af Base64 blev først offentliggjort i 1987 som en del af RFC 989, der definerede Privacy Enhanced Mail (PEM). Dette blev senere opdateret i RFC 1421 (1993) og RFC 2045 (1996, som en del af MIME).

Begrebet "Base64" stammer fra det faktum, at kodningen bruger 64 forskellige ASCII-tegn til at repræsentere binære data. Dette valg af 64 tegn var bevidst, da 64 er en potens af 2 (2^6), hvilket gør konverteringen mellem binær og Base64 effektiv.

Over tid er der opstået flere varianter af Base64:

Standard Base64: Som defineret i RFC 4648, der bruger A-Z, a-z, 0-9, +, / og = til polstring
URL-sikker Base64: Bruger - og _ i stedet for + og / for at undgå URL-kodningsproblemer
Filnavn-sikker Base64: Ligner URL-sikker, designet til brug i filnavne
Modificeret Base64 til IMAP: Bruges i IMAP-protokollen med et andet sæt specialtegn

På trods af at være over tre årtier gammel, forbliver Base64 et grundlæggende værktøj i moderne computing, især med stigningen af webapplikationer og API'er, der i høj grad er afhængige af tekstbaserede dataformater som JSON.

Kodeeksempler

Her er eksempler på Base64 kodning og dekodning i forskellige programmeringssprog:

1// JavaScript Base64 Kodning/Dekodning
2function encodeToBase64(text) {
3  return btoa(text);
4}
5
6function decodeFromBase64(base64String) {
7  try {
8    return atob(base64String);
9  } catch (e) {
10    throw new Error("Ugyldig Base64 streng");
11  }
12}
13
14// Eksempel på brug
15const originalText = "Hello, World!";
16const encoded = encodeToBase64(originalText);
17console.log("Kodet:", encoded);  // SGVsbG8sIFdvcmxkIQ==
18
19try {
20  const decoded = decodeFromBase64(encoded);
21  console.log("Dekodet:", decoded);  // Hello, World!
22} catch (error) {
23  console.error(error.message);
24}
25

1# Python Base64 Kodning/Dekodning
2import base64
3
4def encode_to_base64(text):
5    # Konverter string til bytes og derefter kode
6    text_bytes = text.encode('utf-8')
7    base64_bytes = base64.b64encode(text_bytes)
8    return base64_bytes.decode('utf-8')
9
10def decode_from_base64(base64_string):
11    try:
12        # Konverter base64 streng til bytes og derefter dekode
13        base64_bytes = base64_string.encode('utf-8')
14        text_bytes = base64.b64decode(base64_bytes)
15        return text_bytes.decode('utf-8')
16    except Exception as e:
17        raise ValueError(f"Ugyldig Base64 streng: {e}")
18
19# Eksempel på brug
20original_text = "Hello, World!"
21encoded = encode_to_base64(original_text)
22print(f"Kodet: {encoded}")  # SGVsbG8sIFdvcmxkIQ==
23
24try:
25    decoded = decode_from_base64(encoded)
26    print(f"Dekodet: {decoded}")  # Hello, World!
27except ValueError as e:
28    print(e)
29

1// Java Base64 Kodning/Dekodning
2import java.util.Base64;
3import java.nio.charset.StandardCharsets;
4
5public class Base64Example {
6    public static String encodeToBase64(String text) {
7        byte[] textBytes = text.getBytes(StandardCharsets.UTF_8);
8        byte[] encodedBytes = Base64.getEncoder().encode(textBytes);
9        return new String(encodedBytes, StandardCharsets.UTF_8);
10    }
11    
12    public static String decodeFromBase64(String base64String) {
13        try {
14            byte[] base64Bytes = base64String.getBytes(StandardCharsets.UTF_8);
15            byte[] decodedBytes = Base64.getDecoder().decode(base64Bytes);
16            return new String(decodedBytes, StandardCharsets.UTF_8);
17        } catch (IllegalArgumentException e) {
18            throw new IllegalArgumentException("Ugyldig Base64 streng: " + e.getMessage());
19        }
20    }
21    
22    public static void main(String[] args) {
23        String originalText = "Hello, World!";
24        String encoded = encodeToBase64(originalText);
25        System.out.println("Kodet: " + encoded);  // SGVsbG8sIFdvcmxkIQ==
26        
27        try {
28            String decoded = decodeFromBase64(encoded);
29            System.out.println("Dekodet: " + decoded);  // Hello, World!
30        } catch (IllegalArgumentException e) {
31            System.err.println(e.getMessage());
32        }
33    }
34}
35

1<?php
2// PHP Base64 Kodning/Dekodning
3function encodeToBase64($text) {
4    return base64_encode($text);
5}
6
7function decodeFromBase64($base64String) {
8    $decoded = base64_decode($base64String, true);
9    if ($decoded === false) {
10        throw new Exception("Ugyldig Base64 streng");
11    }
12    return $decoded;
13}
14
15// Eksempel på brug
16$originalText = "Hello, World!";
17$encoded = encodeToBase64($originalText);
18echo "Kodet: " . $encoded . "\n";  // SGVsbG8sIFdvcmxkIQ==
19
20try {
21    $decoded = decodeFromBase64($encoded);
22    echo "Dekodet: " . $decoded . "\n";  // Hello, World!
23} catch (Exception $e) {
24    echo "Fejl: " . $e->getMessage() . "\n";
25}
26?>
27

1// C# Base64 Kodning/Dekodning
2using System;
3using System.Text;
4
5class Base64Example
6{
7    public static string EncodeToBase64(string text)
8    {
9        byte[] textBytes = Encoding.UTF8.GetBytes(text);
10        return Convert.ToBase64String(textBytes);
11    }
12    
13    public static string DecodeFromBase64(string base64String)
14    {
15        try
16        {
17            byte[] base64Bytes = Convert.FromBase64String(base64String);
18            return Encoding.UTF8.GetString(base64Bytes);
19        }
20        catch (FormatException)
21        {
22            throw new FormatException("Ugyldig Base64 streng");
23        }
24    }
25    
26    static void Main()
27    {
28        string originalText = "Hello, World!";
29        string encoded = EncodeToBase64(originalText);
30        Console.WriteLine($"Kodet: {encoded}");  // SGVsbG8sIFdvcmxkIQ==
31        
32        try
33        {
34            string decoded = DecodeFromBase64(encoded);
35            Console.WriteLine($"Dekodet: {decoded}");  // Hello, World!
36        }
37        catch (FormatException e)
38        {
39            Console.WriteLine($"Fejl: {e.Message}");
40        }
41    }
42}
43

1# Ruby Base64 Kodning/Dekodning
2require 'base64'
3
4def encode_to_base64(text)
5  Base64.strict_encode64(text)
6end
7
8def decode_from_base64(base64_string)
9  begin
10    Base64.strict_decode64(base64_string)
11  rescue ArgumentError => e
12    raise "Ugyldig Base64 streng: #{e.message}"
13  end
14end
15
16# Eksempel på brug
17original_text = "Hello, World!"
18encoded = encode_to_base64(original_text)
19puts "Kodet: #{encoded}"  # SGVsbG8sIFdvcmxkIQ==
20
21begin
22  decoded = decode_from_base64(encoded)
23  puts "Dekodet: #{decoded}"  # Hello, World!
24rescue StandardError => e
25  puts "Fejl: #{e.message}"
26end
27

1// Go Base64 Kodning/Dekodning
2package main
3
4import (
5    "encoding/base64"
6    "fmt"
7)
8
9func encodeToBase64(text string) string {
10    return base64.StdEncoding.EncodeToString([]byte(text))
11}
12
13func decodeFromBase64(base64String string) (string, error) {
14    bytes, err := base64.StdEncoding.DecodeString(base64String)
15    if err != nil {
16        return "", fmt.Errorf("ugyldig Base64 streng: %v", err)
17    }
18    return string(bytes), nil
19}
20
21func main() {
22    originalText := "Hello, World!"
23    encoded := encodeToBase64(originalText)
24    fmt.Println("Kodet:", encoded)  // SGVsbG8sIFdvcmxkIQ==
25    
26    decoded, err := decodeFromBase64(encoded)
27    if err != nil {
28        fmt.Println("Fejl:", err)
29    } else {
30        fmt.Println("Dekodet:", decoded)  // Hello, World!
31    }
32}
33

1// Swift Base64 Kodning/Dekodning
2import Foundation
3
4func encodeToBase64(_ text: String) -> String? {
5    if let data = text.data(using: .utf8) {
6        return data.base64EncodedString()
7    }
8    return nil
9}
10
11func decodeFromBase64(_ base64String: String) -> String? {
12    if let data = Data(base64Encoded: base64String) {
13        return String(data: data, encoding: .utf8)
14    }
15    return nil
16}
17
18// Eksempel på brug
19let originalText = "Hello, World!"
20if let encoded = encodeToBase64(originalText) {
21    print("Kodet: \(encoded)")  // SGVsbG8sIFdvcmxkIQ==
22    
23    if let decoded = decodeFromBase64(encoded) {
24        print("Dekodet: \(decoded)")  // Hello, World!
25    } else {
26        print("Fejl: Kunne ikke dekode Base64 streng")
27    }
28} else {
29    print("Fejl: Kunne ikke kode tekst")
30}
31

1' Excel VBA Base64 Kodning/Dekodning
2' Bemærk: Dette kræver en reference til Microsoft XML, v6.0
3Function EncodeToBase64(text As String) As String
4    Dim xmlObj As Object
5    Set xmlObj = CreateObject("MSXML2.DOMDocument")
6    
7    Dim xmlNode As Object
8    Set xmlNode = xmlObj.createElement("b64")
9    
10    xmlNode.DataType = "bin.base64"
11    xmlNode.nodeTypedValue = StrConv(text, vbFromUnicode)
12    
13    EncodeToBase64 = xmlNode.text
14    
15    Set xmlNode = Nothing
16    Set xmlObj = Nothing
17End Function
18
19Function DecodeFromBase64(base64String As String) As String
20    On Error GoTo ErrorHandler
21    
22    Dim xmlObj As Object
23    Set xmlObj = CreateObject("MSXML2.DOMDocument")
24    
25    Dim xmlNode As Object
26    Set xmlNode = xmlObj.createElement("b64")
27    
28    xmlNode.DataType = "bin.base64"
29    xmlNode.text = base64String
30    
31    DecodeFromBase64 = StrConv(xmlNode.nodeTypedValue, vbUnicode)
32    
33    Set xmlNode = Nothing
34    Set xmlObj = Nothing
35    Exit Function
36    
37ErrorHandler:
38    DecodeFromBase64 = "Fejl: Ugyldig Base64 streng"
39End Function
40
41' Brug i et regneark:
42' =EncodeToBase64("Hello, World!")
43' =DecodeFromBase64("SGVsbG8sIFdvcmxkIQ==")
44

1# R Base64 Kodning/Dekodning
2# Kræver pakken 'base64enc'
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7  # Konverter tekst til rå bytes, og derefter kode
8  text_raw <- charToRaw(text)
9  base64_encoded <- base64encode(text_raw)
10  return(rawToChar(base64_encoded))
11}
12
13decode_from_base64 <- function(base64_string) {
14  tryCatch({
15    # Konverter base64 streng til rå, og derefter dekode
16    base64_raw <- charToRaw(base64_string)
17    decoded_raw <- base64decode(base64_raw)
18    return(rawToChar(decoded_raw))
19  }, error = function(e) {
20    stop(paste("Ugyldig Base64 streng:", e$message))
21  })
22}
23
24# Eksempel på brug
25original_text <- "Hello, World!"
26encoded <- encode_to_base64(original_text)
27cat("Kodet:", encoded, "\n")  # SGVsbG8sIFdvcmxkIQ==
28
29tryCatch({
30  decoded <- decode_from_base64(encoded)
31  cat("Dekodet:", decoded, "\n")  # Hello, World!
32}, error = function(e) {
33  cat("Fejl:", e$message, "\n")
34})
35

1% MATLAB Base64 Kodning/Dekodning
2function demo_base64()
3    originalText = 'Hello, World!';
4    
5    % Kodning
6    encoded = encode_to_base64(originalText);
7    fprintf('Kodet: %s\n', encoded);  % SGVsbG8sIFdvcmxkIQ==
8    
9    % Dekodning
10    try
11        decoded = decode_from_base64(encoded);
12        fprintf('Dekodet: %s\n', decoded);  % Hello, World!
13    catch e
14        fprintf('Fejl: %s\n', e.message);
15    end
16end
17
18function encoded = encode_to_base64(text)
19    % Konverter tekst til uint8 array og kode
20    bytes = uint8(text);
21    encoded = base64encode(bytes);
22end
23
24function decoded = decode_from_base64(base64String)
25    try
26        % Dekode base64 streng til uint8 array
27        bytes = base64decode(base64String);
28        decoded = char(bytes);
29    catch
30        error('Ugyldig Base64 streng');
31    end
32end
33

1// C Base64 Kodning/Dekodning ved hjælp af OpenSSL
2#include <stdio.h>
3#include <string.h>
4#include <openssl/bio.h>
5#include <openssl/evp.h>
6#include <openssl/buffer.h>
7#include <stdint.h>
8
9char* encode_to_base64(const char* input) {
10    BIO *bio, *b64;
11    BUF_MEM *bufferPtr;
12    
13    b64 = BIO_new(BIO_f_base64());
14    bio = BIO_new(BIO_s_mem());
15    bio = BIO_push(b64, bio);
16    
17    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
18    BIO_write(bio, input, strlen(input));
19    BIO_flush(bio);
20    BIO_get_mem_ptr(bio, &bufferPtr);
21    
22    char* result = (char*)malloc(bufferPtr->length + 1);
23    memcpy(result, bufferPtr->data, bufferPtr->length);
24    result[bufferPtr->length] = '\0';
25    
26    BIO_free_all(bio);
27    
28    return result;
29}
30
31char* decode_from_base64(const char* input) {
32    BIO *bio, *b64;
33    size_t length = strlen(input);
34    char* buffer = (char*)malloc(length);
35    
36    b64 = BIO_new(BIO_f_base64());
37    bio = BIO_new_mem_buf(input, -1);
38    bio = BIO_push(b64, bio);
39    
40    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
41    int decoded_length = BIO_read(bio, buffer, length);
42    
43    if (decoded_length <= 0) {
44        free(buffer);
45        BIO_free_all(bio);
46        return NULL; // Ugyldig Base64 input
47    }
48    
49    buffer[decoded_length] = '\0';
50    
51    BIO_free_all(bio);
52    
53    return buffer;
54}
55
56int main() {
57    const char* original_text = "Hello, World!";
58    
59    char* encoded = encode_to_base64(original_text);
60    printf("Kodet: %s\n", encoded);  // SGVsbG8sIFdvcmxkIQ==
61    
62    char* decoded = decode_from_base64(encoded);
63    if (decoded) {
64        printf("Dekodet: %s\n", decoded);  // Hello, World!
65        free(decoded);
66    } else {
67        printf("Fejl: Ugyldig Base64 streng\n");
68    }
69    
70    free(encoded);
71    
72    return 0;
73}
74

1// Rust Base64 Kodning/Dekodning
2use base64::{encode, decode};
3use std::str;
4
5fn encode_to_base64(text: &str) -> String {
6    encode(text)
7}
8
9fn decode_from_base64(base64_string: &str) -> Result<String, String> {
10    match decode(base64_string) {
11        Ok(bytes) => {
12            match str::from_utf8(&bytes) {
13                Ok(text) => Ok(text.to_string()),
14                Err(e) => Err(format!("Ugyldig UTF-8 sekvens: {}", e))
15            }
16        },
17        Err(e) => Err(format!("Ugyldig Base64 streng: {}", e))
18    }
19}
20
21fn main() {
22    let original_text = "Hello, World!";
23    let encoded = encode_to_base64(original_text);
24    println!("Kodet: {}", encoded);  // SGVsbG8sIFdvcmxkIQ==
25    
26    match decode_from_base64(&encoded) {
27        Ok(decoded) => println!("Dekodet: {}", decoded),  // Hello, World!
28        Err(e) => println!("Fejl: {}", e)
29    }
30}
31

Kantsager og Overvejelser

Når du arbejder med Base64 kodning og dekodning, skal du være opmærksom på disse vigtige overvejelser:

Unicode og Non-ASCII Tegn: Når du koder tekst med non-ASCII tegn, skal du sikre korrekt tegnkodning (normalt UTF-8) før Base64 kodning.
Polstring: Standard Base64 bruger polstring med "=" tegn for at sikre, at outputlængden er et multiplum af 4. Nogle implementeringer tillader at undlade polstring, hvilket kan forårsage kompatibilitetsproblemer.
Linjeskift: Traditionelle Base64 implementeringer indsætter linjeskift (typisk hver 76 tegn) for læsbarhed, men moderne applikationer udelader ofte disse.
URL-Sikker Base64: Standard Base64 bruger "+" og "/" tegn, som har specielle betydninger i URLs. Til URL-kontekster skal du bruge URL-sikker Base64, der erstatter disse med "-" og "_".
Whitespace: Ved dekodning er nogle implementeringer lempelige og ignorerer whitespace, mens andre kræver præcist input.
Størrelsesforøgelse: Base64 kodning øger størrelsen af data med cirka 33% (4 output bytes for hver 3 input bytes).
Ydelse: Base64 kodning/dekodning kan være beregningsmæssigt intensiv for meget store data. Overvej streamingtilgange for store filer.

Whiz Tools

Base64 Encoder og Decoder: Konverter tekst til/fra Base64

Base64 Encoder/Decoder

Dokumentation