Base64 cambia solo come appaiono i tuoi dati, mai ciò che sono. Tu porti la stringa o il file, e noi ci occupiamo del processo di decodifica o codifica. Il nostro strumento è giusto sotto, e Base64 spiegato è uno scroll più in basso.

Codifica in formato Base64

Per codificare file binari (come immagini, documenti, ecc.) usa il modulo di caricamento file più in basso in questa pagina.

Codifica file in formato Base64

0 Clicca (o tocca) qui per selezionare un file
La dimensione massima del file è 100MB.
Elaborazione...
Attendi fino al completamento del processo di codifica.
Operazione riuscita!
{{ output }} per scaricare il file codificato.
Nota: il file viene rimosso dal nostro sistema immediatamente dopo il primo tentativo di download o dopo 15 minuti di inattività.
Errore!
{{ error }}

Panoramica

Base64 è una metamorfosi reversibile, e questo strumento è la metà di andata del viaggio: prende qualsiasi cosa tu possa digitare o qualsiasi file tu possa caricare, e la riscrive nel testo stampabile che sopravvive a e-mail, URL e documenti JSON senza perdere un solo byte. Incolla una stringa, scegli la tua variante di Base64, e il risultato codificato sarà pronto da copiare. Il decodificatore corrispondente è sul sito gemello, a un link di distanza.

Opzioni avanzate

  • Set di caratteri: Il tuo testo ci arriva sempre come UTF-8, e per impostazione predefinita viene codificato come UTF-8. Cambia la lista quando l'altro lato si aspetta byte diversi, per esempio Windows-1252 per un programma Windows di vecchia generazione o una variante ISO-8859 per software europei più vecchi: la conversione avviene prima della codifica, quindi la stringa che ottieni contiene esattamente i byte che hai chiesto. Dì al decodificatore quale set hai scelto, perché il Base64 in sé non lo dice mai. Nel modulo per i file la lista parte da BINARY (nessuna conversione), la scelta giusta per tutto tranne il testo semplice.
  • Separatore di nuova linea: Unix e Windows non sono d'accordo su come terminare una riga, e il tuo input può portarne uno dei due (o entrambi). Prima che la codifica inizi, ogni a capo nel testo viene riscritto nello stile che scegli qui, quindi il carico codificato è coerente, a prescindere da dove vengono i dati. Lo stesso separatore unisce anche le righe dell'output quando una delle due opzioni multi-riga è attiva. Per i file caricati i byte restano come sono; il separatore decide solo come l'output codificato viene spezzato in righe.
  • Codifica ogni riga separatamente: Normalmente l'intero input viene codificato come un unico blocco, a capo inclusi, ed è ciò che la maggior parte delle applicazioni si aspetta. Attiva questa opzione quando l'input è invece una lista di voci indipendenti: ogni riga viene codificata da sola, e le righe codificate vengono riaggunte con il separatore che hai scelto. (*)
  • Dividi le righe in blocchi: Una stringa Base64 fresca è una riga lunghissima, adatta alla maggior parte dei sistemi ma non a tutti: la specifica MIME (RFC 2045) dice che le righe codificate non dovrebbero superare i 76 caratteri, e le e-mail in particolare le vogliono corte. Spunta questa casella e l'output viene avvolto a 76 caratteri per riga, usando il separatore che hai scelto. (*)
  • Esegui la codifica sicura per URL: Due caratteri dell'alfabeto standard, + e /, non stanno bene negli URL, e i padding = peggiorano le cose. Questa opzione passa invece alla variante Base64URL di RFC 4648: + diventa -, / diventa _, e i padding vengono eliminati del tutto, perché si possono ricavare dalla lunghezza. Il risultato è più corto e sicuro da mettere negli URL, nei nomi di file e nei JSON Web Tokens, senza alcun carattere di escape. Ricorda solo di dire al decodificatore quale dialetto hai scelto.
  • Modalità Live: Attivala e la codifica avviene nel tuo browser mentre scrivi, riprendendo da capo a ogni tasto, senza inviare nulla ai nostri server. Rispetta le altre opzioni, per riga, blocchi e sicura per URL, mentre le attivi e le disattivi, e funziona solo con UTF-8, quindi la lista dei set di caratteri resta bloccata finché è attiva, e il pulsante di codifica resta disabilitato finché non torni indietro.

(*) Queste opzioni non possono essere abilitate simultaneamente, poiché l'output risultante non sarebbe valido per la maggior parte delle applicazioni. Il modulo se ne occupa: spuntando una, l'altra viene disattivata.

Sicuro e protetto

Tutto avviene su una connessione HTTPS cifrata, e nulla di quello che invii viene conservato: i file caricati vengono eliminati nel momento in cui vengono elaborati, e il risultato scaricabile sparisce subito dopo il primo tentativo di download o dopo 15 minuti di inattività, a seconda di quale viene per primo. I contenuti di ciò che invii non vengono mai memorizzati né esaminati oltre la conversione stessa. Con la modalità Live attiva, il tuo testo non lascia mai il browser. Tutti i dettagli si trovano nella nostra informativa sulla privacy, collegata nel piè di pagina in basso.

Completamente gratuito

Tutto su questa pagina è gratuito - la lista completa dei set di caratteri, i caricamenti di file e la modalità Live inclusi. Nessun account, nessun software da installare, nessuna barriera a pagamento: per un compito così piccolo, è così che deve essere.

Base64 spiegato

Alcuni dati semplicemente non possono viaggiare attraverso un canale solo-testo: una foto, un archivio, un hash, un pezzo di binario che farebbe impazzire una connessione e-mail a 7 bit. Base64 è il traduttore per momenti come questo. Riscrive qualsiasi sequenza di byte in un testo semplice e stampabile, così che i dati possano stare nel corpo di un'e-mail, in un documento JSON, in un file XML o in un URL, e arrivare esattamente come erano partiti. La traduzione è completamente reversibile: ogni byte torna indietro, nello stesso ordine, senza che nulla si perda lungo il percorso.

L'intero formato si racchiude in una frase: tre byte in entrata, quattro caratteri in uscita. Il prezzo è un risultato circa un terzo più grande dell'originale. La ricompensa è una stringa che sembra testo, si comporta come testo, e sopravvive a canali che distruggerebbero i byte grezzi. E vale la pena chiarire fin da subito cosa Base64 non è: non è crittografia e non è compressione. È una metamorfosi reversibile, e questo è il suo unico compito.

Perché 64, e perché proprio quei caratteri

Un byte contiene 8 bit, ma i vecchi canali testuali, e-mail innanzitutto, trasportavano in sicurezza solo ASCII a 7 bit. L'astuzia è scegliere un alfabeto di caratteri stampabili che sopravviva a un viaggio del genere, e dimensionarlo in modo che i conti tornino puliti. Con 64 caratteri, ogni carattere codificato trasporta esattamente 6 bit, e 24 è divisibile sia per 8 (il byte) sia per 6 (il carattere): tre byte in entrata diventano quattro caratteri in uscita, senza avanzi. Il nome è semplicemente la base di quel calcolo dei caratteri, come base 10 per le nostre cifre.

L'alfabeto standard è composto dai 62 caratteri alfanumerici, da A a Z, da a a z e da 0 a 9, con + e / come ultimi due. La specifica aggiunge un 65° carattere, =, che non fa parte dell'alfabeto: appare solo alla fine, come padding. La scelta è stata deliberata. L'intero insieme è stampabile; è comune a tutti i sistemi testuali; e la specifica MIME segnala che è scritto identicamente in ogni versione di ISO 646, inclusa US-ASCII, e in ogni versione di EBCDIC. È quest'ultima proprietà a tenere i dati intatti mentre attraversano la vecchia macchineria di internet, non a 8 bit puliti.

Valore Carattere Valore Carattere Valore Carattere Valore Carattere
0 A 16 Q 32 g 48 w
1 B 17 R 33 h 49 x
2 C 18 S 34 i 50 y
3 D 19 T 35 j 51 z
4 E 20 U 36 k 52 0
5 F 21 V 37 l 53 1
6 G 22 W 38 m 54 2
7 H 23 X 39 n 55 3
8 I 24 Y 40 o 56 4
9 J 25 Z 41 p 57 5
10 K 26 a 42 q 58 6
11 L 27 b 43 r 59 7
12 M 28 c 44 s 60 8
13 N 29 d 45 t 61 9
14 O 30 e 46 u 62 +
15 P 31 f 47 v 63 /
(Il 65° carattere, =, è il padding: non trasporta mai dati; segna solo la fine.)

Codifica, passo dopo passo

Il codificatore è una catena di montaggio a quattro passaggi. Legge l'input tre byte alla volta e fonde ogni tripletta in una singola stringa di 24 bit. Quella stringa viene tagliata in quattro blocchi di 6 bit. Ogni blocco è un numero da 0 a 63, e ogni numero viene cercato nella tabella sopra. Quattro numeri in entrata, quattro caratteri in uscita.

Guardala all'opera sulla parola foo, che arriva come i valori byte 102, 111 e 111 (esadecimale 66, 6F, 6F). Messi uno accanto all'altro, i 24 bit sono 01100110 01101111 01101111. Tagliati a sei a sei, diventano 011001, 100110, 111101 e 101111, cioè 25, 38, 61 e 47. La tabella dice che sono Z, m, 9 e v, quindi foo viene codificato in Zm9v, e qualsiasi decodificatore Base64 al mondo lo riporterà ai tre byte originali.

Passo 1° byte 2° byte 3° byte
Testo f o o
Valore byte 102 111 111
Esadecimale 66 6F 6F
Bit 0 1 1 0 0 1 1 0 0 1 1 0 1 1 1 1 0 1 1 0 1 1 1 1
Valore a 6 bit 25 38 61 47
Carattere Z m 9 v

Il resto dell'input viene elaborato allo stesso modo, tripletta dopo tripletta, finché non resta più nulla. Solo l'ultimo gruppo, quando contiene meno di tre byte, ha bisogno di una mossa speciale.

Padding: il = alla fine

L'input è sempre un numero intero di byte, ma tre non sempre lo divide esattamente. Quando alla fine avanzano uno o due byte, il codificatore deve comunque completare un gruppo intero di quattro caratteri. Riempie i bit mancanti con zeri, esegue le ricerche come al solito, e sostituisce i caratteri che i bit di padding avrebbero prodotto con segni =. Sono possibili esattamente tre finali:

Fine dell'input Fine codificata Si decodifica di nuovo in
3 byte 4 caratteri, senza padding 3 byte
2 byte 3 caratteri + 1 = 2 byte
1 byte 2 caratteri + 2 = 1 byte

Quindi fo, due byte, diventa Zm8=, e la solitaria f diventa Zg==, mentre foo non ha bisogno di nessun padding. Il decodificatore sa esattamente cosa fare con i padding: ogni = significa altri otto bit zero da buttare. I padding stanno solo alla fine, e sono al massimo due. La specifica MIME lo usa addirittura come una funzionalità: dato che = non può comparire altrove, un carico con padding annuncia la propria fine, e il ricevente può capire che i dati non sono stati troncati in transito. E per il caso più piccolo: l'input vuoto viene codificato in un output vuoto. Anche il nulla fa un giro di andata e ritorno perfetto.

Decodifica: la catena di montaggio al contrario

La decodifica è la stessa macchina in marcia indietro, e è altrettanto meccanica. Prendi quattro caratteri, cerca quelli veri (un padding vale sei zeri), scrivi i 24 bit, e restituisci i primi 16 bit se c'è un padding, oppure tutti e 24 se non ce ne sono. Quattro caratteri in entrata, tre byte in uscita; due byte in uscita con un padding; un byte in uscita con due. I bit zero aggiunti dal codificatore sono l'unica cosa buttata via, e ogni altro bit è esattamente quello che è entrato. È questo che significa davvero reversibile qui: il formato in sé è senza perdita, e le uniche cose che possono danneggiare i tuoi dati sono un canale che corrompe la stringa, o un decodificatore che molla silenziosamente.

Ecco perché lo standard è severo su una cosa: i caratteri che non sono nell'alfabeto. RFC 4648 dice che un decodificatore deve rifiutare un carico che contiene qualsiasi carattere fuori dai 64, a meno che la specifica circostante non lo consenta esplicitamente. Il motivo è pratico, non pedante. Un decodificatore che inghiotte silenziosamente caratteri estranei può essere ingannato: i caratteri contrabbandati diventano un canale laterale nascosto, e questo trucco è stato usato per nascondere dati ai filtri e per esplorare i bug dei decodificatori. L'eccezione famosa è la MIME stessa, che precede lo standard e dice l'opposto: ignora ogni carattere fuori dall'alfabeto, ed è così che gli a capo passano indisturbati in un allegato e-mail. Quando validi l'input da solo, la regola moderna è quella giusta: se la tua stringa contiene un @, uno spazio o qualsiasi altra cosa che non sia nella tabella, non è Base64 pulito.

A capo e la regola dei 76 caratteri

Incontrerai spesso Base64 avvolto su più righe, e l'abitudine viene dalle e-mail. La vecchia macchineria SMTP aveva limiti sulla lunghezza delle righe, quindi MIME avvolge il carico a 76 caratteri per riga, con un a capo CRLF, e il più vecchio formato PEM, quello che trasporta certificati e chiavi, avvolge a 64. La regola di RFC 4648 per il codice nuovo è opposta: non aggiungere a capo affatto, a meno che il formato che stai implementando non lo dica. Nella pratica, il decodificatore non ci fa caso. Un a capo è solo un carattere fuori dall'alfabeto, quindi un carico avvolto in MIME, un blocco PEM e una lunga stringa continua senza interruzioni si decodificano tutti negli stessi byte. Se incolli Base64 da qualche parte, rimuovi prima gli a capo e hai finito.

L'avvolgimento ha un piccolo costo, e si vede nei conti sulla dimensione. Senza a capo, Base64 è esattamente quattro terzi dell'originale, circa il 33 per cento più grande. Avvolto a 76 caratteri con a capo CRLF, è circa il 37 per cento più grande, ed è per questo che un file che dovrebbe fare 100 KB spesso arriva come circa 137 KB di testo. I conti tornano sempre.

Base64URL: il gemello sicuro per URL

L'alfabeto standard ha due caratteri che non fanno amicizia con gli URL. Un + in una stringa di query viene tradizionalmente letto come uno spazio, e / è un separatore di percorso, quindi una stringa Base64 grezza in un URL ha bisogno della codifica percentuale per entrambi, oltre ai padding =. La sezione 5 di RFC 4648 definisce la soluzione: l'alfabeto sicuro per URL e nomi di file, in cui + diventa - e / diventa _. Di solito spariscono anche i padding, perché un padding mancante si può ricavare dalla lunghezza. L'RFC lo dice chiaramente: questo non deve essere chiamato Base64 semplice: è una codifica diversa, di solito scritta base64url.

Nella pratica, i due sono a uno scambio di distanza, in quella direzione pericolosa. Alimenta un decodificatore standard con una stringa base64url e va storto, perché - e _ non sono nell'alfabeto standard: un decodificatore tollerante li scarta e restituisce una stringa di byte più corta e sbagliata - oppure, quando il resto è troppo corto per stare da solo, un errore - mentre uno severo rifiuta l'intero carico. La danza giusta è riportare - a + e _ a /, completare i padding mancanti, e solo allora decodificare. È il dialetto che incontri nei JSON Web Tokens (JWT), nelle stringhe di stato OAuth e negli ID di un certo sito di video molto grande.

Una guida rapida sul campo

Prima di prendere in mano uno strumento, puoi leggere molto della stringa da solo. Alcuni controlli ti dicono se un carico è Base64 in quanto tale, e cosa nasconde:

  • Guarda i caratteri. Il Base64 standard usa solo da A a Z, da a a z, da 0 a 9, + e /; il gemello sicuro per URL usa - e _ al posto di quelli due. Qualsiasi altro simbolo, o uno spazio fuori posto, significa che non è Base64 pulito.
  • Controlla i padding. I segni =, se presenti, stanno solo alla fine, e sono al massimo due. Un padding in mezzo alla stringa è un campanello d'allarme.
  • Conta la lunghezza. Con i padding, la lunghezza è sempre un multiplo di 4. Senza padding, dividendo la lunghezza per 4 il resto è 0, 2 o 3. Un resto di 1 è impossibile, perché un singolo carattere trasporta solo 6 bit e un byte ne richiede 8.
  • Stima la dimensione. Ogni gruppo di 4 caratteri contiene 3 byte, meno un byte per ogni segno =. Quindi Zm9vYmFy, otto caratteri senza padding, fa 6 byte, e Zm9vYg==, otto caratteri con due padding, ne fa 4.

Un ultimo trucco sul campo, e il più utile. Il codificatore deve azzerare i bit di padding, ma un decodificatore tollerante non li controlla. Il carico Zg== si decodifica nel singolo byte f, e lo stesso vale per Zh==: i bit bassi dell'ultimo carattere sono padding in entrambi i casi, quindi entrambi scrivono lo stesso byte. Lo standard chiama la versione a bit zero forma canonica, e permette ai decodificatori severi di rifiutare l'altra. Due stringhe, un solo carico. Se due sistemi non sono d'accordo su un valore Base64, i bit di padding sono un buon posto da cui iniziare a cercare.

Cosa non è Base64

  • Non è crittografia. Non c'è nessuna chiave e nessun segreto; chiunque può riportare una stringa Base64 in byte in un secondo. L'RFC menziona persino incidenti reali in cui le persone hanno segnalato scambi di protocollo che includevano una password "codificata", convinte che la codifica la stesse nascondendo. Se i dati sono sensibili, proteggili con vera crittografia prima di codificarli, non dopo.
  • Non è compressione. Va nella direzione opposta: il risultato è circa il 33 per cento più grande dell'input, e ancora di più una volta aggiunti gli a capo. Base64 ti compra la sicurezza testuale, e ti fattura il conto in dimensioni.
  • Non è un set di caratteri. Base64 sposta byte, non lettere. Non sa e non gli importa se quei byte sono testo UTF-8, una codifica di vecchia generazione a un byte o un JPEG. La domanda "qual è il set di caratteri?" vive prima della codifica e dopo la decodifica, mai dentro.
  • Non è una codifica unica. Il nome copre una famiglia: l'alfabeto standard, il gemello sicuro per URL, carichi avvolti a 76 o 64 caratteri, varianti che saltano i padding, e un po' di bizzarrie (IMAP, per esempio, usa una virgola al posto del / dell'alfabeto quando codifica nomi di mailbox internazionali). Quando due sistemi non sono d'accordo su un carico, di solito il colpevole è una differenza di dialetto.

Le note in piccolo

Le fonti primarie sono brevi e leggibili. RFC 4648, Le codifiche di dati Base16, Base32 e Base64 (2006), è lo standard attuale: entrambi gli alfabeti, le regole su padding e a capo, le regole di severità, e un insieme di vettori di test ufficiali, come foo che diventa Zm9v, contro cui le implementazioni si autoverificano. Dietro di esso sta RFC 2045, la specifica MIME del 1996 da cui provengono la regola delle righe a 76 caratteri e la tolleranza per i caratteri fuori posto, e RFC 1421, la specifica Privacy Enhanced Mail, oggi superata, che ha iniziato la famiglia con righe a 64 caratteri. Un precedente tentativo di unificazione, RFC 3548, è stato sostituito da RFC 4648.

Questa è la storia intera: 64 caratteri, tre byte in entrata e quattro caratteri in uscita, = per completare la coda, e un perfetto giro di andata e ritorno. Ogni strumento, libreria e convertitore online che incontrerai è solo un ingresso verso questo. Una volta che sai guardare una stringa Base64 e vedere i byte che stanno dietro, niente del formato ti sorprenderà più. E quando sei pronto a scrivere il codificatore da solo, gli articoli sui linguaggi di programmazione giusto sotto questa sezione ti consegnano gli stessi 64 caratteri come codice funzionante: una guida completa per linguaggio.