Codificatore e Decodificatore Base64: Converti Testo in/da Base64

Codificatore e Decodificatore Base64

Introduzione

Base64 è uno schema di codifica binaria in testo che rappresenta i dati binari in un formato di stringa ASCII. È progettato per trasmettere dati memorizzati in formati binari attraverso canali che supportano in modo affidabile solo contenuti testuali. La codifica Base64 converte i dati binari in un insieme di 64 caratteri (da qui il nome) che possono essere trasmessi in sicurezza attraverso protocolli basati su testo senza corruzione dei dati.

Il set di caratteri Base64 è composto da:

Lettere maiuscole A-Z (26 caratteri)
Lettere minuscole a-z (26 caratteri)
Cifre 0-9 (10 caratteri)
Due caratteri aggiuntivi, tipicamente "+" e "/" (2 caratteri)

Questo strumento ti consente di codificare facilmente il testo in formato Base64 o di decodificare le stringhe Base64 nel loro testo originale. È particolarmente utile per sviluppatori, professionisti IT e chiunque lavori con dati che devono essere trasmessi in sicurezza attraverso canali basati su testo.

Come Funziona la Codifica Base64

Processo di Codifica

La codifica Base64 funziona convertendo ogni gruppo di tre byte (24 bit) di dati binari in quattro caratteri Base64. Il processo segue questi passaggi:

Converti il testo di input nella sua rappresentazione binaria (utilizzando la codifica ASCII o UTF-8)
Raggruppa i dati binari in blocchi di 24 bit (3 byte)
Suddividi ogni blocco da 24 bit in quattro gruppi da 6 bit
Converti ogni gruppo da 6 bit nel suo carattere Base64 corrispondente

Quando la lunghezza dell'input non è divisibile per 3, vengono aggiunti caratteri di riempimento "=" per mantenere il rapporto di 4:3 tra lunghezze di output e input.

Rappresentazione Matematica

Per una sequenza di byte $b_1, b_2, b_3$ , i corrispondenti caratteri Base64 $c_1, c_2, c_3, c_4$ vengono calcolati come:

$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)]$

Dove $\text{Base64}[i]$ rappresenta il $i$ -esimo carattere nell'alfabeto Base64.

Processo di Decodifica

La decodifica Base64 inverte il processo di codifica:

Converti ogni carattere Base64 nel suo valore da 6 bit
Concatenare questi valori da 6 bit
Raggruppa i bit in blocchi da 8 bit (byte)
Converti ogni byte nel suo carattere corrispondente

Riempimento

Quando il numero di byte da codificare non è divisibile per 3, viene applicato il riempimento:

Se rimane un byte, viene convertito in due caratteri Base64 seguiti da "=="
Se rimangono due byte, vengono convertiti in tre caratteri Base64 seguiti da "="

Esempio

Codifichiamo il testo "Hello" in Base64:

Rappresentazione ASCII di "Hello": 72 101 108 108 111
Rappresentazione binaria: 01001000 01100101 01101100 01101100 01101111
Raggruppamento in chunk da 6 bit: 010010 000110 010101 101100 011011 000110 1111
L'ultimo chunk ha solo 4 bit, quindi riempiamo con zeri: 010010 000110 010101 101100 011011 000110 111100
Conversione in decimale: 18, 6, 21, 44, 27, 6, 60
Ricerca nell'alfabeto Base64: S, G, V, s, b, G, 8
Il risultato è "SGVsbG8="

Nota il riempimento "=" alla fine perché la lunghezza dell'input (5 byte) non è divisibile per 3.

Formula

La formula generale per calcolare la lunghezza di una stringa codificata in Base64 è:

$\text{lunghezza\_codificata} = 4 \times \lceil \frac{\text{lunghezza\_input}}{3} \rceil$

Dove $\lceil x \rceil$ rappresenta la funzione di soffitto (arrotondando all'intero più vicino).

Casi d'Uso

La codifica Base64 è ampiamente utilizzata in varie applicazioni:

Allegati Email: MIME (Multipurpose Internet Mail Extensions) utilizza Base64 per codificare allegati binari nelle email.
Data URL: Incorporare piccole immagini, font o altre risorse direttamente in HTML, CSS o JavaScript utilizzando lo schema URL data:.
Comunicazioni API: Trasmettere in sicurezza dati binari nei payload JSON o in altri formati API basati su testo.
Memorizzazione di Dati Binari in Formati Testuali: Quando i dati binari devono essere memorizzati in XML, JSON o altri formati basati su testo.
Sistemi di Autenticazione: L'autenticazione di base in HTTP utilizza la codifica Base64 (anche se non per sicurezza, solo per codifica).
Criptografia: Come parte di vari protocolli e sistemi crittografici, spesso per codificare chiavi o certificati.
Valori dei Cookie: Codificare strutture di dati complesse da memorizzare nei cookie.

Alternative

Sebbene Base64 sia ampiamente utilizzato, ci sono alternative che potrebbero essere più appropriate in determinate situazioni:

Base64 sicura per URL: Una variante che utilizza "-" e "_" invece di "+" e "/" per evitare problemi di codifica URL. Utile per dati che saranno inclusi negli URL.
Base32: Utilizza un set di 32 caratteri, risultando in un output più lungo ma con una migliore leggibilità umana e insensibilità al caso.
Codifica Esadecimale: Conversione semplice in esadecimale, che è meno efficiente (raddoppia la dimensione) ma molto semplice e ampiamente supportata.
Trasferimento Binario: Per file di grandi dimensioni o quando l'efficienza è cruciale, i protocolli di trasferimento binario diretto come HTTP con intestazioni Content-Type appropriate sono preferibili.
Compressione + Base64: Per grandi dati testuali, comprimere prima di codificare può mitigare l'aumento di dimensione.
Serializzazione JSON/XML: Per dati strutturati, utilizzare la serializzazione JSON o XML nativa potrebbe essere più appropriato rispetto alla codifica Base64.

Storia

La codifica Base64 ha le sue radici nei primi sistemi informatici e di telecomunicazione in cui i dati binari dovevano essere trasmessi su canali progettati per il testo.

La specifica formale della Base64 è stata pubblicata per la prima volta nel 1987 come parte del RFC 989, che definiva la Privacy Enhanced Mail (PEM). Questo è stato successivamente aggiornato nel RFC 1421 (1993) e nel RFC 2045 (1996, come parte di MIME).

Il termine "Base64" deriva dal fatto che la codifica utilizza 64 caratteri ASCII diversi per rappresentare i dati binari. Questa scelta di 64 caratteri è stata deliberata, poiché 64 è una potenza di 2 (2^6), il che rende la conversione tra binario e Base64 efficiente.

Nel tempo, sono emerse diverse varianti di Base64:

Base64 standard: Come definito nel RFC 4648, utilizzando A-Z, a-z, 0-9, +, / e = per il riempimento
Base64 sicura per URL: Utilizza - e _ invece di + e / per evitare problemi di codifica URL
Base64 sicura per nomi di file: Simile alla Base64 sicura per URL, progettata per l'uso nei nomi di file
Base64 modificata per IMAP: Utilizzata nel protocollo IMAP con un diverso insieme di caratteri speciali

Nonostante abbia più di tre decenni, Base64 rimane uno strumento fondamentale nell'informatica moderna, in particolare con l'ascesa delle applicazioni web e delle API che si basano pesantemente su formati di dati basati su testo come JSON.

Esempi di Codice

Ecco esempi di codifica e decodifica Base64 in vari linguaggi di programmazione:

1// Codifica/Decodifica Base64 in JavaScript
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("Stringa Base64 non valida");
11  }
12}
13
14// Esempio di utilizzo
15const originalText = "Hello, World!";
16const encoded = encodeToBase64(originalText);
17console.log("Codificato:", encoded);  // SGVsbG8sIFdvcmxkIQ==
18
19try {
20  const decoded = decodeFromBase64(encoded);
21  console.log("Decodificato:", decoded);  // Hello, World!
22} catch (error) {
23  console.error(error.message);
24}
25

1# Codifica/Decodifica Base64 in Python
2import base64
3
4def encode_to_base64(text):
5    # Converti la stringa in byte e poi codifica
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        # Converti la stringa base64 in byte e poi decodifica
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"Stringa Base64 non valida: {e}")
18
19# Esempio di utilizzo
20original_text = "Hello, World!"
21encoded = encode_to_base64(original_text)
22print(f"Codificato: {encoded}")  # SGVsbG8sIFdvcmxkIQ==
23
24try:
25    decoded = decode_from_base64(encoded)
26    print(f"Decodificato: {decoded}")  # Hello, World!
27except ValueError as e:
28    print(e)
29

1// Codifica/Decodifica Base64 in Java
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("Stringa Base64 non valida: " + 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("Codificato: " + encoded);  // SGVsbG8sIFdvcmxkIQ==
26        
27        try {
28            String decoded = decodeFromBase64(encoded);
29            System.out.println("Decodificato: " + decoded);  // Hello, World!
30        } catch (IllegalArgumentException e) {
31            System.err.println(e.getMessage());
32        }
33    }
34}
35

1<?php
2// Codifica/Decodifica Base64 in PHP
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("Stringa Base64 non valida");
11    }
12    return $decoded;
13}
14
15// Esempio di utilizzo
16$originalText = "Hello, World!";
17$encoded = encodeToBase64($originalText);
18echo "Codificato: " . $encoded . "\n";  // SGVsbG8sIFdvcmxkIQ==
19
20try {
21    $decoded = decodeFromBase64($encoded);
22    echo "Decodificato: " . $decoded . "\n";  // Hello, World!
23} catch (Exception $e) {
24    echo "Errore: " . $e->getMessage() . "\n";
25}
26?>
27

1// Codifica/Decodifica Base64 in C#
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("Stringa Base64 non valida");
23        }
24    }
25    
26    static void Main()
27    {
28        string originalText = "Hello, World!";
29        string encoded = EncodeToBase64(originalText);
30        Console.WriteLine($"Codificato: {encoded}");  // SGVsbG8sIFdvcmxkIQ==
31        
32        try
33        {
34            string decoded = DecodeFromBase64(encoded);
35            Console.WriteLine($"Decodificato: {decoded}");  // Hello, World!
36        }
37        catch (FormatException e)
38        {
39            Console.WriteLine($"Errore: {e.Message}");
40        }
41    }
42}
43

1# Codifica/Decodifica Base64 in Ruby
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 "Stringa Base64 non valida: #{e.message}"
13  end
14end
15
16# Esempio di utilizzo
17original_text = "Hello, World!"
18encoded = encode_to_base64(original_text)
19puts "Codificato: #{encoded}"  # SGVsbG8sIFdvcmxkIQ==
20
21begin
22  decoded = decode_from_base64(encoded)
23  puts "Decodificato: #{decoded}"  # Hello, World!
24rescue StandardError => e
25  puts "Errore: #{e.message}"
26end
27

1// Codifica/Decodifica Base64 in Go
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("stringa Base64 non valida: %v", err)
17    }
18    return string(bytes), nil
19}
20
21func main() {
22    originalText := "Hello, World!"
23    encoded := encodeToBase64(originalText)
24    fmt.Println("Codificato:", encoded)  // SGVsbG8sIFdvcmxkIQ==
25    
26    decoded, err := decodeFromBase64(encoded)
27    if err != nil {
28        fmt.Println("Errore:", err)
29    } else {
30        fmt.Println("Decodificato:", decoded)  // Hello, World!
31    }
32}
33

1// Codifica/Decodifica Base64 in Swift
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// Esempio di utilizzo
19let originalText = "Hello, World!"
20if let encoded = encodeToBase64(originalText) {
21    print("Codificato: \(encoded)")  // SGVsbG8sIFdvcmxkIQ==
22    
23    if let decoded = decodeFromBase64(encoded) {
24        print("Decodificato: \(decoded)")  // Hello, World!
25    } else {
26        print("Errore: Impossibile decodificare la stringa Base64")
27    }
28} else {
29    print("Errore: Impossibile codificare il testo")
30}
31

1' Codifica/Decodifica Base64 in Excel VBA
2' Nota: Questo richiede un riferimento a 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 = "Errore: Stringa Base64 non valida"
39End Function
40
41' Utilizzo in un foglio di lavoro:
42' =EncodeToBase64("Hello, World!")
43' =DecodeFromBase64("SGVsbG8sIFdvcmxkIQ==")
44

1# Codifica/Decodifica Base64 in R
2# Richiede il pacchetto 'base64enc'
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7  # Converti il testo in byte raw, poi codifica
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    # Converti la stringa base64 in raw, poi decodifica
16    base64_raw <- charToRaw(base64_string)
17    decoded_raw <- base64decode(base64_raw)
18    return(rawToChar(decoded_raw))
19  }, error = function(e) {
20    stop(paste("Stringa Base64 non valida:", e$message))
21  })
22}
23
24# Esempio di utilizzo
25original_text <- "Hello, World!"
26encoded <- encode_to_base64(original_text)
27cat("Codificato:", encoded, "\n")  # SGVsbG8sIFdvcmxkIQ==
28
29tryCatch({
30  decoded <- decode_from_base64(encoded)
31  cat("Decodificato:", decoded, "\n")  # Hello, World!
32}, error = function(e) {
33  cat("Errore:", e$message, "\n")
34})
35

1% Codifica/Decodifica Base64 in MATLAB
2function demo_base64()
3    originalText = 'Hello, World!';
4    
5    % Codifica
6    encoded = encode_to_base64(originalText);
7    fprintf('Codificato: %s\n', encoded);  % SGVsbG8sIFdvcmxkIQ==
8    
9    % Decodifica
10    try
11        decoded = decode_from_base64(encoded);
12        fprintf('Decodificato: %s\n', decoded);  % Hello, World!
13    catch e
14        fprintf('Errore: %s\n', e.message);
15    end
16end
17
18function encoded = encode_to_base64(text)
19    % Converti il testo in array uint8 e codifica
20    bytes = uint8(text);
21    encoded = base64encode(bytes);
22end
23
24function decoded = decode_from_base64(base64String)
25    try
26        % Decodifica la stringa base64 in array uint8
27        bytes = base64decode(base64String);
28        decoded = char(bytes);
29    catch
30        error('Stringa Base64 non valida');
31    end
32end
33

1// Codifica/Decodifica Base64 in C utilizzando 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; // Input Base64 non valido
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("Codificato: %s\n", encoded);  // SGVsbG8sIFdvcmxkIQ==
61    
62    char* decoded = decode_from_base64(encoded);
63    if (decoded) {
64        printf("Decodificato: %s\n", decoded);  // Hello, World!
65        free(decoded);
66    } else {
67        printf("Errore: Stringa Base64 non valida\n");
68    }
69    
70    free(encoded);
71    
72    return 0;
73}
74

1// Codifica/Decodifica Base64 in Rust
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!("Sequenza UTF-8 non valida: {}", e))
15            }
16        },
17        Err(e) => Err(format!("Stringa Base64 non valida: {}", e))
18    }
19}
20
21fn main() {
22    let original_text = "Hello, World!";
23    let encoded = encode_to_base64(original_text);
24    println!("Codificato: {}", encoded);  // SGVsbG8sIFdvcmxkIQ==
25    
26    match decode_from_base64(&encoded) {
27        Ok(decoded) => println!("Decodificato: {}", decoded),  // Hello, World!
28        Err(e) => println!("Errore: {}", e)
29    }
30}
31

Casi Ed Eccezioni e Considerazioni

Quando si lavora con la codifica e la decodifica Base64, sii consapevole di queste importanti considerazioni:

Caratteri Unicode e Non-ASCII: Quando si codificano testi con caratteri non ASCII, assicurati di utilizzare la corretta codifica dei caratteri (di solito UTF-8) prima della codifica Base64.
Riempimento: La Base64 standard utilizza il riempimento con caratteri "=" per garantire che la lunghezza dell'output sia un multiplo di 4. Alcune implementazioni consentono di omettere il riempimento, il che può causare problemi di compatibilità.
Interruzioni di Riga: Le implementazioni Base64 tradizionali inseriscono interruzioni di riga (tipicamente ogni 76 caratteri) per la leggibilità, ma le applicazioni moderne spesso omettono queste.
Base64 Sicura per URL: La Base64 standard utilizza i caratteri "+" e "/" che hanno significati speciali negli URL. Per contesti URL, utilizza la Base64 sicura per URL che sostituisce questi con "-" e "_".
Spazi Bianchi: Durante la decodifica, alcune implementazioni sono tolleranti e ignorano gli spazi bianchi, mentre altre richiedono un input esatto.
Aumento delle Dimensioni: La codifica Base64 aumenta la dimensione dei dati di circa il 33% (4 byte di output per ogni 3 byte di input).
Prestazioni: La codifica/decodifica Base64 può essere computazionalmente intensiva per dati molto grandi. Considera approcci di streaming per file di grandi dimensioni.

Whiz Tools

Codificatore e Decodificatore Base64: Converti Testo in/da Base64

Codificatore/Decodificatore Base64

Documentazione