Base64-koder og -dekoder: Konverter tekst til/fra Base64
Gratis nettverktøy for å kode tekst til Base64 eller dekode Base64-strenger tilbake til tekst. Støtter standard og URL-sikker Base64-koding med øyeblikkelig konvertering.
Base64 Koder/Dekoder
Konverter tekst til og fra Base64-koding
Dokumentasjon
Base64-koderen og -dekoderen
Introduksjon
Base64 er en binær-til-tekst kodingsordning som representerer binærdata i et ASCII-strengformat. Den er designet for å bære data lagret i binære formater over kanaler som bare pålitelig støtter tekstinnhold. Base64-koding konverterer binærdata til et sett med 64 tegn (derav navnet) som trygt kan overføres over tekstbaserte protokoller uten datakorruptjon.
Base64-tegnsettet består av:
- Store bokstaver A-Z (26 tegn)
- Små bokstaver a-z (26 tegn)
- Siffer 0-9 (10 tegn)
- To ekstra tegn, vanligvis "+" og "/" (2 tegn)
Dette verktøyet lar deg enkelt kode tekst til Base64-format eller dekode Base64-strenger tilbake til deres opprinnelige tekst. Det er spesielt nyttig for utviklere, IT-profesjonelle, og alle som arbeider med data som må overføres trygt over tekstbaserte kanaler.
Hvordan Base64-koding fungerer
Kodingprosess
Base64-koding fungerer ved å konvertere hver gruppe av tre byte (24 biter) med binærdata til fire Base64-tegn. Prosessen følger disse trinnene:
- Konverter den innkommende teksten til dens binære representasjon (ved hjelp av ASCII eller UTF-8-koding)
- Gruppere binærdataene i biter av 24 biter (3 byte)
- Splitte hver 24-bits chunk i fire 6-bits grupper
- Konvertere hver 6-bits gruppe til sitt tilsvarende Base64-tegn
Når inngangslengden ikke er delelig med 3, legges det til padding med "=" tegn for å opprettholde 4:3-forholdet mellom utgang og inngangslengder.
Matematisk representasjon
For en sekvens av bytes , beregnes de tilsvarende Base64-tegnene som:
Hvor representerer det -te tegnet i Base64-alphabetet.
Dekodingsprosess
Base64-dekoding reverserer kodingprosessen:
- Konverter hvert Base64-tegn til sin 6-bits verdi
- Koble disse 6-bits verdiene sammen
- Gruppere bitene i 8-bits chunks (bytes)
- Konvertere hver byte til sitt tilsvarende tegn
Padding
Når antallet bytes som skal kodes ikke er delelig med 3, brukes padding:
- Hvis det er én byte igjen, konverteres den til to Base64-tegn etterfulgt av "=="
- Hvis det er to bytes igjen, konverteres de til tre Base64-tegn etterfulgt av "="
Eksempel
La oss kode teksten "Hello" til Base64:
- ASCII-representasjon av "Hello": 72 101 108 108 111
- Binær representasjon: 01001000 01100101 01101100 01101100 01101111
- Gruppere i 6-bits chunks: 010010 000110 010101 101100 011011 000110 1111
- Den siste chunk har bare 4 biter, så vi legger til nuller: 010010 000110 010101 101100 011011 000110 111100
- Konvertering til desimal: 18, 6, 21, 44, 27, 6, 60
- Ser opp i Base64-alphabetet: S, G, V, s, b, G, 8
- Resultatet er "SGVsbG8="
Merk padding med "=" på slutten fordi inngangslengden (5 bytes) ikke er delelig med 3.
Formel
Den generelle formelen for å beregne lengden på en Base64-kodet streng er:
Hvor representerer tak-funksjonen (runder opp til nærmeste heltall).
Bruksområder
Base64-koding er mye brukt i ulike applikasjoner:
-
E-postvedlegg: MIME (Multipurpose Internet Mail Extensions) bruker Base64 for å kode binære vedlegg i e-post.
-
Data-URL-er: Innkapsling av små bilder, skrifttyper eller andre ressurser direkte i HTML, CSS eller JavaScript ved hjelp av
data:URL-skjemaet. -
API-kommunikasjon: Trygt overføre binærdata i JSON-payloads eller andre tekstbaserte API-formater.
-
Lagring av binærdata i tekstformater: Når binærdata må lagres i XML, JSON eller andre tekstbaserte formater.
-
Autentiseringssystemer: Basic Authentication i HTTP bruker Base64-koding (selv om det ikke er for sikkerhet, bare for koding).
-
Kryptografi: Som en del av ulike kryptografiske protokoller og systemer, ofte for koding av nøkler eller sertifikater.
-
Cookie-verdier: Koding av komplekse datastrukturer for å lagres i informasjonskapsler.
Alternativer
Selv om Base64 er mye brukt, finnes det alternativer som kan være mer passende i visse situasjoner:
-
URL-sikker Base64: En variant som bruker "-" og "_" i stedet for "+" og "/" for å unngå URL-kodingsproblemer. Nyttig for data som skal inkluderes i URL-er.
-
Base32: Bruker et 32-tegns sett, noe som resulterer i lengre utdata, men med bedre lesbarhet for mennesker og case-insensitivitet.
-
Hex-koding: Enkel konvertering til heksadesimal, som er mindre effektiv (dobler størrelsen) men veldig enkel og mye støttet.
-
Binæroverføring: For store filer eller når effektivitet er avgjørende, er direkte binæroverføringsprotokoller som HTTP med passende Content-Type-headere å foretrekke.
-
Kompresjon + Base64: For store tekstdata kan komprimering før koding redusere størrelsesøkningen.
-
JSON/XML-serialisering: For strukturerte data kan det være mer passende å bruke innfødt JSON- eller XML-serialisering enn Base64-koding.
Historie
Base64-koding har sine røtter i tidlig databehandling og telekommunikasjonssystemer der binærdata måtte overføres over kanaler designet for tekst.
Den formelle spesifikasjonen av Base64 ble først publisert i 1987 som en del av RFC 989, som definerte Privacy Enhanced Mail (PEM). Dette ble senere oppdatert i RFC 1421 (1993) og RFC 2045 (1996, som en del av MIME).
Begrepet "Base64" kommer fra det faktum at kodingen bruker 64 forskjellige ASCII-tegn for å representere binærdata. Dette valget av 64 tegn var bevisst, ettersom 64 er en makt av 2 (2^6), noe som gjør konverteringen mellom binær og Base64 effektiv.
Over tid har flere varianter av Base64 dukket opp:
- Standard Base64: Som definert i RFC 4648, bruker A-Z, a-z, 0-9, +, / og = for padding
- URL-sikker Base64: Bruker - og _ i stedet for + og / for å unngå URL-kodingsproblemer
- Filnavn-sikker Base64: Ligner på URL-sikker, designet for bruk i filnavn
- Modifisert Base64 for IMAP: Brukt i IMAP-protokollen med et annet sett med spesialtegn
Til tross for å være over tre tiår gammel, forblir Base64 et grunnleggende verktøy i moderne databehandling, spesielt med fremveksten av webapplikasjoner og API-er som i stor grad er avhengige av tekstbaserte dataformater som JSON.
Kodeeksempler
Her er eksempler på Base64-koding og dekoding i ulike programmeringsspråk:
1// JavaScript Base64-koding/dekoding
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å bruk
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}
251# Python Base64-koding/dekoding
2import base64
3
4def encode_to_base64(text):
5 # Konvertere streng til bytes og deretter 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 # Konvertere base64-streng til bytes og deretter 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å bruk
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)
291// Java Base64-koding/dekoding
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}
351<?php
2// PHP Base64-koding/dekoding
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å bruk
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 "Feil: " . $e->getMessage() . "\n";
25}
26?>
271// C# Base64-koding/dekoding
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($"Feil: {e.Message}");
40 }
41 }
42}
431# Ruby Base64-koding/dekoding
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å bruk
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 "Feil: #{e.message}"
26end
271// Go Base64-koding/dekoding
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("Feil:", err)
29 } else {
30 fmt.Println("Dekodet:", decoded) // Hello, World!
31 }
32}
331// Swift Base64-koding/dekoding
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å bruk
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("Feil: Kunne ikke dekode Base64-streng")
27 }
28} else {
29 print("Feil: Kunne ikke kode tekst")
30}
311' Excel VBA Base64-koding/dekoding
2' Merk: Dette krever en referanse 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 = "Feil: Ugyldig Base64-streng"
39End Function
40
41' Bruk i et regneark:
42' =EncodeToBase64("Hello, World!")
43' =DecodeFromBase64("SGVsbG8sIFdvcmxkIQ==")
441# R Base64-koding/dekoding
2# Krever 'base64enc'-pakken
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7 # Konvertere tekst til rå bytes, deretter 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 # Konvertere base64-streng til rå, deretter 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å bruk
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("Feil:", e$message, "\n")
34})
351% MATLAB Base64-koding/dekoding
2function demo_base64()
3 originalText = 'Hello, World!';
4
5 % Kode
6 encoded = encode_to_base64(originalText);
7 fprintf('Kodet: %s\n', encoded); % SGVsbG8sIFdvcmxkIQ==
8
9 % Dekode
10 try
11 decoded = decode_from_base64(encoded);
12 fprintf('Dekodet: %s\n', decoded); % Hello, World!
13 catch e
14 fprintf('Feil: %s\n', e.message);
15 end
16end
17
18function encoded = encode_to_base64(text)
19 % Konvertere 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
331// C Base64-koding/dekoding ved hjelp av 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-inndata
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("Feil: Ugyldig Base64-streng\n");
68 }
69
70 free(encoded);
71
72 return 0;
73}
741// Rust Base64-koding/dekoding
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!("Feil: {}", e)
29 }
30}
31Kanttilfeller og hensyn
Når du arbeider med Base64-koding og dekoding, vær oppmerksom på disse viktige hensynene:
-
Unicode og ikke-ASCII-tegn: Når du koder tekst med ikke-ASCII-tegn, sørg for riktig tegnkoding (vanligvis UTF-8) før Base64-koding.
-
Padding: Standard Base64 bruker padding med "=" tegn for å sikre at utgangslengden er et multiplum av 4. Noen implementeringer tillater å utelate padding, noe som kan forårsake kompatibilitetsproblemer.
-
Linjeskift: Tradisjonelle Base64-implementeringer setter inn linjeskift (vanligvis hver 76 tegn) for lesbarhet, men moderne applikasjoner utelater ofte disse.
-
URL-sikker Base64: Standard Base64 bruker "+" og "/" tegn som har spesielle betydninger i URL-er. For URL-kontekster, bruk URL-sikker Base64 som erstatter disse med "-" og "_".
-
Whitespace: Ved dekoding er noen implementeringer tolerante og ignorerer whitespace, mens andre krever nøyaktig inndata.
-
Størrelsesøkning: Base64-koding øker størrelsen på data med omtrent 33% (4 utdata bytes for hver 3 inndata bytes).
-
Ytelse: Base64-koding/dekoding kan være beregningsmessig intensivt for veldig store data. Vurder strømming tilnærminger for store filer.
Referanser
Tilbakemelding
Klikk på tilbakemeldings-toast for å begynne å gi tilbakemelding om dette verktøyet
Relaterte verktøy
Oppdag flere verktøy som kan være nyttige for arbeidsflyten din