Base64 enkoder i dekoder: Pretvorite tekst u/iz Base64
Besplatan online alat za kodiranje teksta u Base64 ili dekodiranje Base64 stringova nazad u tekst. Podržava standardno i URL-sigurno Base64 kodiranje sa trenutnom konverzijom.
Base64 Enkoder/Decodera
Konvertujte tekst u i iz Base64 kodiranja
Dokumentacija
Base64 Encoder i Dekoder
Uvod
Base64 je shema kodiranja binarnih podataka u tekst koja predstavlja binarne podatke u ASCII string formatu. Dizajnirana je da prenosi podatke pohranjene u binarnim formatima preko kanala koji pouzdano podržavaju samo tekstualni sadržaj. Base64 kodiranje pretvara binarne podatke u skup od 64 karaktera (otuda i naziv) koji se mogu sigurno prenositi preko protokola zasnovanih na tekstu bez oštećenja podataka.
Skup karaktera Base64 se sastoji od:
- Velikih slova A-Z (26 karaktera)
- Malih slova a-z (26 karaktera)
- Brojeva 0-9 (10 karaktera)
- Dva dodatna karaktera, obično "+" i "/" (2 karaktera)
Ovaj alat vam omogućava da lako kodirate tekst u Base64 format ili dekodirate Base64 stringove nazad u njihov izvorni tekst. Posebno je koristan za programere, IT stručnjake i svakoga ko radi sa podacima koji treba da se prenose sigurno preko kanala zasnovanih na tekstu.
Kako funkcioniše Base64 kodiranje
Proces kodiranja
Base64 kodiranje funkcioniše tako što pretvara svaku grupu od tri bajta (24 bita) binarnih podataka u četiri Base64 karaktera. Proces se sastoji od sledećih koraka:
- Pretvorite ulazni tekst u njegovu binarnu reprezentaciju (koristeći ASCII ili UTF-8 kodiranje)
- Grupisanje binarnih podataka u delove od 24 bita (3 bajta)
- Deljenje svake 24-bitne grupe u četiri 6-bitne grupe
- Pretvaranje svake 6-bitne grupe u njen odgovarajući Base64 karakter
Kada dužina ulaza nije deljiva sa 3, dodaje se padding sa "=" karakterima kako bi se održala 4:3 proporcija dužina izlaza i ulaza.
Matematička reprezentacija
Za niz bajtova , odgovarajući Base64 karakteri se računaju kao:
Gde predstavlja -ti karakter u Base64 abecedi.
Proces dekodiranja
Base64 dekodiranje obrnuto je od procesa kodiranja:
- Pretvorite svaki Base64 karakter u njegovu 6-bitnu vrednost
- Spojite ove 6-bitne vrednosti
- Grupisanje bitova u 8-bitne delove (bajte)
- Pretvorite svaki bajt u njegov odgovarajući karakter
Padding
Kada broj bajtova koji se kodiraju nije deljiv sa 3, primenjuje se padding:
- Ako ostane jedan bajt, on se pretvara u dva Base64 karaktera praćena "=="
- Ako ostanu dva bajta, oni se pretvaraju u tri Base64 karaktera praćena "="
Primer
Hajde da kodiramo tekst "Hello" u Base64:
- ASCII reprezentacija "Hello": 72 101 108 108 111
- Binarna reprezentacija: 01001000 01100101 01101100 01101100 01101111
- Grupisanje u 6-bitne delove: 010010 000110 010101 101100 011011 000110 1111
- Poslednji deo ima samo 4 bita, pa dodajemo nule: 010010 000110 010101 101100 011011 000110 111100
- Pretvaranje u decimalne vrednosti: 18, 6, 21, 44, 27, 6, 60
- Pretraživanje u Base64 abecedi: S, G, V, s, b, G, 8
- Rezultat je "SGVsbG8="
Napomena: "=" padding na kraju jer dužina ulaza (5 bajtova) nije deljiva sa 3.
Formula
Opšta formula za izračunavanje dužine Base64 kodirane stringa je:
Gde predstavlja funkciju zaokruživanja (zaokruživanje na najbliži ceo broj naviše).
Upotrebe
Base64 kodiranje se široko koristi u raznim aplikacijama:
-
Email Prilozi: MIME (Multipurpose Internet Mail Extensions) koristi Base64 za kodiranje binarnih priloga u emailovima.
-
Data URL-ovi: Uključivanje malih slika, fontova ili drugih resursa direktno u HTML, CSS ili JavaScript koristeći
data:URL shemu. -
API Komunikacije: Sigurno prenošenje binarnih podataka u JSON payload-ima ili drugim formatima API-ja zasnovanim na tekstu.
-
Skladištenje binarnih podataka u tekstualnim formatima: Kada je potrebno skladištiti binarne podatke u XML-u, JSON-u ili drugim tekstualnim formatima.
-
Sistemi autentifikacije: Osnovna autentifikacija u HTTP-u koristi Base64 kodiranje (iako to nije zbog sigurnosti, već zbog kodiranja).
-
Kriptografija: Kao deo različitih kriptografskih protokola i sistema, često za kodiranje ključeva ili sertifikata.
-
Vrednosti kolačića: Kodiranje složenih struktura podataka za skladištenje u kolačićima.
Alternativa
Iako je Base64 široko korišćen, postoje alternative koje bi mogle biti prikladnije u određenim situacijama:
-
URL-sigurna Base64: Varijanta koja koristi "-" i "_" umesto "+" i "/" kako bi se izbegli problemi sa URL kodiranjem. Korisna za podatke koji će biti uključeni u URL-ove.
-
Base32: Koristi skup od 32 karaktera, što rezultira dužim izlazom, ali sa boljom čitljivošću za ljude i bez obzira na velika i mala slova.
-
Hex Kodiranje: Jednostavna konverzija u heksadecimalni oblik, što je manje efikasno (udvostručava veličinu) ali vrlo jednostavno i široko podržano.
-
Binarni Prenos: Za velike datoteke ili kada je efikasnost ključna, direktni binarni protokoli kao što je HTTP sa odgovarajućim Content-Type zaglavljima su poželjniji.
-
Kompresija + Base64: Za velike tekstualne podatke, kompresija pre kodiranja može umanjiti povećanje veličine.
-
JSON/XML Serijalizacija: Za strukturirane podatke, korišćenje nativne JSON ili XML serijalizacije može biti prikladnije od Base64 kodiranja.
Istorija
Base64 kodiranje ima svoje korene u ranim računarima i telekomunikacionim sistemima gde su binarni podaci morali biti prenošeni preko kanala dizajniranih za tekst.
Formalna specifikacija Base64 prvi put je objavljena 1987. godine kao deo RFC 989, koji je definisao Privatno poboljšano poštansko (PEM). Ovo je kasnije ažurirano u RFC 1421 (1993) i RFC 2045 (1996, kao deo MIME).
Termin "Base64" dolazi od činjenice da kodiranje koristi 64 različita ASCII karaktera za predstavljanje binarnih podataka. Ovaj izbor od 64 karaktera bio je nameran, jer je 64 stepen od 2 (2^6), što čini konverziju između binarnog i Base64 efikasnom.
Tokom vremena, pojavile su se nekoliko varijanti Base64:
- Standardna Base64: Kako je definisano u RFC 4648, koristeći A-Z, a-z, 0-9, +, / i = za padding
- URL-sigurna Base64: Koristi - i _ umesto + i / kako bi se izbegli problemi sa URL kodiranjem
- Sigurna Base64 za nazive datoteka: Slična URL-sigurnoj, dizajnirana za korišćenje u nazivima datoteka
- Izmenjena Base64 za IMAP: Koristi se u IMAP protokolu sa različitim skupom specijalnih karaktera
I pored toga što je star više od tri decenije, Base64 ostaje osnovni alat u modernom računarstvu, posebno sa porastom web aplikacija i API-ja koji se oslanjaju na tekstualne formate podataka kao što je JSON.
Primeri Koda
Evo primera Base64 kodiranja i dekodiranja u raznim programskim jezicima:
1// JavaScript Base64 Kodiranje/Dekodiranje
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("Nevažeći Base64 string");
11 }
12}
13
14// Primer korišćenja
15const originalText = "Hello, World!";
16const encoded = encodeToBase64(originalText);
17console.log("Kodirano:", encoded); // SGVsbG8sIFdvcmxkIQ==
18
19try {
20 const decoded = decodeFromBase64(encoded);
21 console.log("Dekodirano:", decoded); // Hello, World!
22} catch (error) {
23 console.error(error.message);
24}
251# Python Base64 Kodiranje/Dekodiranje
2import base64
3
4def encode_to_base64(text):
5 # Pretvorite string u bajtove i zatim kodirajte
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 # Pretvorite base64 string u bajtove i zatim dekodirajte
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"Nevažeći Base64 string: {e}")
18
19# Primer korišćenja
20original_text = "Hello, World!"
21encoded = encode_to_base64(original_text)
22print(f"Kodirano: {encoded}") # SGVsbG8sIFdvcmxkIQ==
23
24try:
25 decoded = decode_from_base64(encoded)
26 print(f"Dekodirano: {decoded}") # Hello, World!
27except ValueError as e:
28 print(e)
291// Java Base64 Kodiranje/Dekodiranje
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("Nevažeći Base64 string: " + 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("Kodirano: " + encoded); // SGVsbG8sIFdvcmxkIQ==
26
27 try {
28 String decoded = decodeFromBase64(encoded);
29 System.out.println("Dekodirano: " + decoded); // Hello, World!
30 } catch (IllegalArgumentException e) {
31 System.err.println(e.getMessage());
32 }
33 }
34}
351<?php
2// PHP Base64 Kodiranje/Dekodiranje
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("Nevažeći Base64 string");
11 }
12 return $decoded;
13}
14
15// Primer korišćenja
16$originalText = "Hello, World!";
17$encoded = encodeToBase64($originalText);
18echo "Kodirano: " . $encoded . "\n"; // SGVsbG8sIFdvcmxkIQ==
19
20try {
21 $decoded = decodeFromBase64($encoded);
22 echo "Dekodirano: " . $decoded . "\n"; // Hello, World!
23} catch (Exception $e) {
24 echo "Greška: " . $e->getMessage() . "\n";
25}
26?>
271// C# Base64 Kodiranje/Dekodiranje
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("Nevažeći Base64 string");
23 }
24 }
25
26 static void Main()
27 {
28 string originalText = "Hello, World!";
29 string encoded = EncodeToBase64(originalText);
30 Console.WriteLine($"Kodirano: {encoded}"); // SGVsbG8sIFdvcmxkIQ==
31
32 try
33 {
34 string decoded = DecodeFromBase64(encoded);
35 Console.WriteLine($"Dekodirano: {decoded}"); // Hello, World!
36 }
37 catch (FormatException e)
38 {
39 Console.WriteLine($"Greška: {e.Message}");
40 }
41 }
42}
431# Ruby Base64 Kodiranje/Dekodiranje
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 "Nevažeći Base64 string: #{e.message}"
13 end
14end
15
16# Primer korišćenja
17original_text = "Hello, World!"
18encoded = encode_to_base64(original_text)
19puts "Kodirano: #{encoded}" # SGVsbG8sIFdvcmxkIQ==
20
21begin
22 decoded = decode_from_base64(encoded)
23 puts "Dekodirano: #{decoded}" # Hello, World!
24rescue StandardError => e
25 puts "Greška: #{e.message}"
26end
271// Go Base64 Kodiranje/Dekodiranje
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("nevažeći Base64 string: %v", err)
17 }
18 return string(bytes), nil
19}
20
21func main() {
22 originalText := "Hello, World!"
23 encoded := encodeToBase64(originalText)
24 fmt.Println("Kodirano:", encoded) // SGVsbG8sIFdvcmxkIQ==
25
26 decoded, err := decodeFromBase64(encoded)
27 if err != nil {
28 fmt.Println("Greška:", err)
29 } else {
30 fmt.Println("Dekodirano:", decoded) // Hello, World!
31 }
32}
331// Swift Base64 Kodiranje/Dekodiranje
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// Primer korišćenja
19let originalText = "Hello, World!"
20if let encoded = encodeToBase64(originalText) {
21 print("Kodirano: \(encoded)") // SGVsbG8sIFdvcmxkIQ==
22
23 if let decoded = decodeFromBase64(encoded) {
24 print("Dekodirano: \(decoded)") // Hello, World!
25 } else {
26 print("Greška: Ne može se dekodirati Base64 string")
27 }
28} else {
29 print("Greška: Ne može se kodirati tekst")
30}
311' Excel VBA Base64 Kodiranje/Dekodiranje
2' Napomena: Ovo zahteva referencu na 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 = "Greška: Nevažeći Base64 string"
39End Function
40
41' Korišćenje u radnom listu:
42' =EncodeToBase64("Hello, World!")
43' =DecodeFromBase64("SGVsbG8sIFdvcmxkIQ==")
441# R Base64 Kodiranje/Dekodiranje
2# Zahteva 'base64enc' paket
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7 # Pretvorite tekst u sirove bajtove, zatim kodirajte
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 # Pretvorite base64 string u sirove, zatim dekodirajte
16 base64_raw <- charToRaw(base64_string)
17 decoded_raw <- base64decode(base64_raw)
18 return(rawToChar(decoded_raw))
19 }, error = function(e) {
20 stop(paste("Nevažeći Base64 string:", e$message))
21 })
22}
23
24# Primer korišćenja
25original_text <- "Hello, World!"
26encoded <- encode_to_base64(original_text)
27cat("Kodirano:", encoded, "\n") # SGVsbG8sIFdvcmxkIQ==
28
29tryCatch({
30 decoded <- decode_from_base64(encoded)
31 cat("Dekodirano:", decoded, "\n") # Hello, World!
32}, error = function(e) {
33 cat("Greška:", e$message, "\n")
34})
351% MATLAB Base64 Kodiranje/Dekodiranje
2function demo_base64()
3 originalText = 'Hello, World!';
4
5 % Kodirajte
6 encoded = encode_to_base64(originalText);
7 fprintf('Kodirano: %s\n', encoded); % SGVsbG8sIFdvcmxkIQ==
8
9 % Dekodirajte
10 try
11 decoded = decode_from_base64(encoded);
12 fprintf('Dekodirano: %s\n', decoded); % Hello, World!
13 catch e
14 fprintf('Greška: %s\n', e.message);
15 end
16end
17
18function encoded = encode_to_base64(text)
19 % Pretvorite tekst u uint8 niz i kodirajte
20 bytes = uint8(text);
21 encoded = base64encode(bytes);
22end
23
24function decoded = decode_from_base64(base64String)
25 try
26 % Dekodirajte base64 string u uint8 niz
27 bytes = base64decode(base64String);
28 decoded = char(bytes);
29 catch
30 error('Nevažeći Base64 string');
31 end
32end
331// C Base64 Kodiranje/Dekodiranje koristeći 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; // Nevažeći Base64 ulaz
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("Kodirano: %s\n", encoded); // SGVsbG8sIFdvcmxkIQ==
61
62 char* decoded = decode_from_base64(encoded);
63 if (decoded) {
64 printf("Dekodirano: %s\n", decoded); // Hello, World!
65 free(decoded);
66 } else {
67 printf("Greška: Nevažeći Base64 string\n");
68 }
69
70 free(encoded);
71
72 return 0;
73}
741// Rust Base64 Kodiranje/Dekodiranje
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!("Nevažeća UTF-8 sekvenca: {}", e))
15 }
16 },
17 Err(e) => Err(format!("Nevažeći Base64 string: {}", e))
18 }
19}
20
21fn main() {
22 let original_text = "Hello, World!";
23 let encoded = encode_to_base64(original_text);
24 println!("Kodirano: {}", encoded); // SGVsbG8sIFdvcmxkIQ==
25
26 match decode_from_base64(&encoded) {
27 Ok(decoded) => println!("Dekodirano: {}", decoded), // Hello, World!
28 Err(e) => println!("Greška: {}", e)
29 }
30}
31Ivica i razmatranja
Kada radite sa Base64 kodiranjem i dekodiranjem, obratite pažnju na ove važne aspekte:
-
Unicode i ne-ASCII karakteri: Kada kodirate tekst sa ne-ASCII karakterima, osigurajte pravilno kodiranje karaktera (obično UTF-8) pre Base64 kodiranja.
-
Padding: Standardna Base64 koristi padding sa "=" karakterima kako bi se osigurala dužina izlaza višekratnik 4. Neki implementacije dozvoljavaju izostavljanje padding-a, što može izazvati probleme sa kompatibilnošću.
-
Prelomi linija: Tradicionalne Base64 implementacije umetnu prelome linija (obično svaka 76 karaktera) radi čitljivosti, ali moderne aplikacije često izostavljaju ove.
-
URL-sigurna Base64: Standardna Base64 koristi "+" i "/" karaktere koji imaju posebna značenja u URL-ovima. Za kontekste URL-a, koristite URL-sigurnu Base64 koja zamenjuje ove sa "-" i "_".
-
Razmak: Kada dekodirate, neke implementacije su blage i ignorišu razmake, dok druge zahtevaju tačan ulaz.
-
Povećanje veličine: Base64 kodiranje povećava veličinu podataka za otprilike 33% (4 izlazna bajta za svaki 3 ulazna bajta).
-
Performanse: Base64 kodiranje/dekodiranje može biti računski intenzivno za veoma velike podatke. Razmotrite pristupe strimovanja za velike datoteke.
Reference
Povratne informacije
Kliknite na obaveštenje o povratnim informacijama da biste započeli davanje povratnih informacija o ovom alatu
Povezani alati
Otkrijte više alata koji bi mogli biti korisni za vaš radni tok