Codificador e Decodificador Base64: Converter Texto para/da Base64

Codificador e Decodificador Base64

Introdução

Base64 é um esquema de codificação de texto binário que representa dados binários em um formato de string ASCII. Ele foi projetado para transportar dados armazenados em formatos binários através de canais que suportam apenas conteúdo de texto de forma confiável. A codificação Base64 converte dados binários em um conjunto de 64 caracteres (daí o nome) que podem ser transmitidos com segurança por meio de protocolos baseados em texto, sem corrupção de dados.

O conjunto de caracteres Base64 consiste em:

Letras maiúsculas A-Z (26 caracteres)
Letras minúsculas a-z (26 caracteres)
Dígitos 0-9 (10 caracteres)
Dois caracteres adicionais, tipicamente "+" e "/" (2 caracteres)

Esta ferramenta permite que você codifique facilmente texto para o formato Base64 ou decodifique strings Base64 de volta para seu texto original. É particularmente útil para desenvolvedores, profissionais de TI e qualquer pessoa que trabalhe com dados que precisam ser transmitidos com segurança através de canais baseados em texto.

Como Funciona a Codificação Base64

Processo de Codificação

A codificação Base64 funciona convertendo cada grupo de três bytes (24 bits) de dados binários em quatro caracteres Base64. O processo segue estas etapas:

Converta o texto de entrada para sua representação binária (usando codificação ASCII ou UTF-8)
Agrupe os dados binários em blocos de 24 bits (3 bytes)
Divida cada bloco de 24 bits em quatro grupos de 6 bits
Converta cada grupo de 6 bits em seu caractere Base64 correspondente

Quando o comprimento da entrada não é divisível por 3, o preenchimento com caracteres "=" é adicionado para manter a proporção de 4:3 dos comprimentos de saída para entrada.

Representação Matemática

Para uma sequência de bytes $b_1, b_2, b_3$ , os caracteres Base64 correspondentes $c_1, c_2, c_3, c_4$ são calculados como:

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

Onde $\text{Base64}[i]$ representa o $i$ -ésimo caractere no alfabeto Base64.

Processo de Decodificação

A decodificação Base64 reverte o processo de codificação:

Converta cada caractere Base64 em seu valor de 6 bits
Concatene esses valores de 6 bits
Agrupe os bits em blocos de 8 bits (bytes)
Converta cada byte em seu caractere correspondente

Preenchimento

Quando o número de bytes a serem codificados não é divisível por 3, o preenchimento é aplicado:

Se houver um byte restante, ele é convertido em dois caracteres Base64 seguidos de "=="
Se houver dois bytes restantes, eles são convertidos em três caracteres Base64 seguidos de "="

Exemplo

Vamos codificar o texto "Hello" para Base64:

Representação ASCII de "Hello": 72 101 108 108 111
Representação binária: 01001000 01100101 01101100 01101100 01101111
Agrupando em blocos de 6 bits: 010010 000110 010101 101100 011011 000110 1111
O último bloco tem apenas 4 bits, então preenchermos com zeros: 010010 000110 010101 101100 011011 000110 111100
Convertendo para decimal: 18, 6, 21, 44, 27, 6, 60
Consultando no alfabeto Base64: S, G, V, s, b, G, 8
O resultado é "SGVsbG8="

Note o preenchimento "=" no final porque o comprimento da entrada (5 bytes) não é divisível por 3.

Fórmula

A fórmula geral para calcular o comprimento de uma string codificada em Base64 é:

$\text{comprimento\_codificado} = 4 \times \lceil \frac{\text{comprimento\_entrada}}{3} \rceil$

Onde $\lceil x \rceil$ representa a função teto (arredondando para o inteiro mais próximo).

Casos de Uso

A codificação Base64 é amplamente utilizada em várias aplicações:

Anexos de Email: MIME (Extensões de Email Multipropósito da Internet) usa Base64 para codificar anexos binários em emails.
URLs de Dados: Incorporando pequenas imagens, fontes ou outros recursos diretamente em HTML, CSS ou JavaScript usando o esquema de URL data:.
Comunicações de API: Transmitindo com segurança dados binários em cargas úteis JSON ou outros formatos de API baseados em texto.
Armazenando Dados Binários em Formatos de Texto: Quando dados binários precisam ser armazenados em XML, JSON ou outros formatos baseados em texto.
Sistemas de Autenticação: A Autenticação Básica em HTTP usa codificação Base64 (embora não seja para segurança, apenas para codificação).
Criptografia: Como parte de vários protocolos e sistemas criptográficos, muitas vezes para codificar chaves ou certificados.
Valores de Cookies: Codificando estruturas de dados complexas para serem armazenadas em cookies.

Alternativas

Embora o Base64 seja amplamente utilizado, existem alternativas que podem ser mais apropriadas em certas situações:

Base64 Seguro para URL: Uma variante que usa "-" e "_" em vez de "+" e "/" para evitar problemas de codificação de URL. Útil para dados que serão incluídos em URLs.
Base32: Usa um conjunto de 32 caracteres, resultando em uma saída mais longa, mas com melhor legibilidade humana e insensibilidade a maiúsculas e minúsculas.
Codificação Hexadecimal: Conversão simples para hexadecimal, que é menos eficiente (dobra o tamanho), mas muito simples e amplamente suportada.
Transferência Binária: Para arquivos grandes ou quando a eficiência é crucial, protocolos de transferência binária direta, como HTTP com cabeçalhos de Content-Type apropriados, são preferíveis.
Compressão + Base64: Para grandes dados de texto, comprimir antes de codificar pode mitigar o aumento de tamanho.
Serialização JSON/XML: Para dados estruturados, usar a serialização nativa JSON ou XML pode ser mais apropriado do que a codificação Base64.

História

A codificação Base64 tem suas raízes em sistemas de computação e telecomunicações antigos, onde dados binários precisavam ser transmitidos por canais projetados para texto.

A especificação formal do Base64 foi publicada pela primeira vez em 1987 como parte do RFC 989, que definiu o Email Privado Aprimorado (PEM). Isso foi posteriormente atualizado no RFC 1421 (1993) e RFC 2045 (1996, como parte do MIME).

O termo "Base64" vem do fato de que a codificação usa 64 caracteres ASCII diferentes para representar dados binários. Essa escolha de 64 caracteres foi deliberada, uma vez que 64 é uma potência de 2 (2^6), o que torna a conversão entre binário e Base64 eficiente.

Com o tempo, várias variantes de Base64 surgiram:

Base64 Padrão: Conforme definido no RFC 4648, usando A-Z, a-z, 0-9, +, / e = para preenchimento
Base64 Seguro para URL: Usa - e _ em vez de + e / para evitar problemas de codificação de URL
Base64 Seguro para Nomes de Arquivo: Semelhante ao seguro para URL, projetado para uso em nomes de arquivo
Base64 Modificado para IMAP: Usado no protocolo IMAP com um conjunto diferente de caracteres especiais

Apesar de ter mais de três décadas, o Base64 continua sendo uma ferramenta fundamental na computação moderna, particularmente com o aumento de aplicativos da web e APIs que dependem fortemente de formatos de dados baseados em texto como JSON.

Exemplos de Código

Aqui estão exemplos de codificação e decodificação Base64 em várias linguagens de programação:

1// JavaScript Codificação/Decodificação Base64
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("String Base64 inválida");
11  }
12}
13
14// Exemplo de uso
15const originalText = "Hello, World!";
16const encoded = encodeToBase64(originalText);
17console.log("Codificado:", encoded);  // SGVsbG8sIFdvcmxkIQ==
18
19try {
20  const decoded = decodeFromBase64(encoded);
21  console.log("Decodificado:", decoded);  // Hello, World!
22} catch (error) {
23  console.error(error.message);
24}
25

1# Python Codificação/Decodificação Base64
2import base64
3
4def encode_to_base64(text):
5    # Converter string para bytes e depois codificar
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        # Converter string base64 para bytes e depois decodificar
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"String Base64 inválida: {e}")
18
19# Exemplo de uso
20original_text = "Hello, World!"
21encoded = encode_to_base64(original_text)
22print(f"Codificado: {encoded}")  # SGVsbG8sIFdvcmxkIQ==
23
24try:
25    decoded = decode_from_base64(encoded)
26    print(f"Decodificado: {decoded}")  # Hello, World!
27except ValueError as e:
28    print(e)
29

1// Java Codificação/Decodificação Base64
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("String Base64 inválida: " + 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("Codificado: " + encoded);  // SGVsbG8sIFdvcmxkIQ==
26        
27        try {
28            String decoded = decodeFromBase64(encoded);
29            System.out.println("Decodificado: " + decoded);  // Hello, World!
30        } catch (IllegalArgumentException e) {
31            System.err.println(e.getMessage());
32        }
33    }
34}
35

1<?php
2// PHP Codificação/Decodificação Base64
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("String Base64 inválida");
11    }
12    return $decoded;
13}
14
15// Exemplo de uso
16$originalText = "Hello, World!";
17$encoded = encodeToBase64($originalText);
18echo "Codificado: " . $encoded . "\n";  // SGVsbG8sIFdvcmxkIQ==
19
20try {
21    $decoded = decodeFromBase64($encoded);
22    echo "Decodificado: " . $decoded . "\n";  // Hello, World!
23} catch (Exception $e) {
24    echo "Erro: " . $e->getMessage() . "\n";
25}
26?>
27

1// C# Codificação/Decodificação Base64
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("String Base64 inválida");
23        }
24    }
25    
26    static void Main()
27    {
28        string originalText = "Hello, World!";
29        string encoded = EncodeToBase64(originalText);
30        Console.WriteLine($"Codificado: {encoded}");  // SGVsbG8sIFdvcmxkIQ==
31        
32        try
33        {
34            string decoded = DecodeFromBase64(encoded);
35            Console.WriteLine($"Decodificado: {decoded}");  // Hello, World!
36        }
37        catch (FormatException e)
38        {
39            Console.WriteLine($"Erro: {e.Message}");
40        }
41    }
42}
43

1# Ruby Codificação/Decodificação Base64
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 "String Base64 inválida: #{e.message}"
13  end
14end
15
16# Exemplo de uso
17original_text = "Hello, World!"
18encoded = encode_to_base64(original_text)
19puts "Codificado: #{encoded}"  # SGVsbG8sIFdvcmxkIQ==
20
21begin
22  decoded = decode_from_base64(encoded)
23  puts "Decodificado: #{decoded}"  # Hello, World!
24rescue StandardError => e
25  puts "Erro: #{e.message}"
26end
27

1// Go Codificação/Decodificação Base64
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("string Base64 inválida: %v", err)
17    }
18    return string(bytes), nil
19}
20
21func main() {
22    originalText := "Hello, World!"
23    encoded := encodeToBase64(originalText)
24    fmt.Println("Codificado:", encoded)  // SGVsbG8sIFdvcmxkIQ==
25    
26    decoded, err := decodeFromBase64(encoded)
27    if err != nil {
28        fmt.Println("Erro:", err)
29    } else {
30        fmt.Println("Decodificado:", decoded)  // Hello, World!
31    }
32}
33

1// Swift Codificação/Decodificação Base64
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// Exemplo de uso
19let originalText = "Hello, World!"
20if let encoded = encodeToBase64(originalText) {
21    print("Codificado: \(encoded)")  // SGVsbG8sIFdvcmxkIQ==
22    
23    if let decoded = decodeFromBase64(encoded) {
24        print("Decodificado: \(decoded)")  // Hello, World!
25    } else {
26        print("Erro: Não foi possível decodificar a string Base64")
27    }
28} else {
29    print("Erro: Não foi possível codificar o texto")
30}
31

1' Excel VBA Codificação/Decodificação Base64
2' Nota: Isso requer uma referência ao 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 = "Erro: String Base64 inválida"
39End Function
40
41' Uso em uma planilha:
42' =EncodeToBase64("Hello, World!")
43' =DecodeFromBase64("SGVsbG8sIFdvcmxkIQ==")
44

1# R Codificação/Decodificação Base64
2# Requer o pacote 'base64enc'
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7  # Converter texto para bytes brutos, depois codificar
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    # Converter string base64 para bytes brutos, depois decodificar
16    base64_raw <- charToRaw(base64_string)
17    decoded_raw <- base64decode(base64_raw)
18    return(rawToChar(decoded_raw))
19  }, error = function(e) {
20    stop(paste("String Base64 inválida:", e$message))
21  })
22}
23
24# Exemplo de uso
25original_text <- "Hello, World!"
26encoded <- encode_to_base64(original_text)
27cat("Codificado:", encoded, "\n")  # SGVsbG8sIFdvcmxkIQ==
28
29tryCatch({
30  decoded <- decode_from_base64(encoded)
31  cat("Decodificado:", decoded, "\n")  # Hello, World!
32}, error = function(e) {
33  cat("Erro:", e$message, "\n")
34})
35

1% MATLAB Codificação/Decodificação Base64
2function demo_base64()
3    originalText = 'Hello, World!';
4    
5    % Codificar
6    encoded = encode_to_base64(originalText);
7    fprintf('Codificado: %s\n', encoded);  % SGVsbG8sIFdvcmxkIQ==
8    
9    % Decodificar
10    try
11        decoded = decode_from_base64(encoded);
12        fprintf('Decodificado: %s\n', decoded);  % Hello, World!
13    catch e
14        fprintf('Erro: %s\n', e.message);
15    end
16end
17
18function encoded = encode_to_base64(text)
19    % Converter texto para array uint8 e codificar
20    bytes = uint8(text);
21    encoded = base64encode(bytes);
22end
23
24function decoded = decode_from_base64(base64String)
25    try
26        % Decodificar string base64 para array uint8
27        bytes = base64decode(base64String);
28        decoded = char(bytes);
29    catch
30        error('String Base64 inválida');
31    end
32end
33

1// C Codificação/Decodificação Base64 usando 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; // Entrada Base64 inválida
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("Codificado: %s\n", encoded);  // SGVsbG8sIFdvcmxkIQ==
61    
62    char* decoded = decode_from_base64(encoded);
63    if (decoded) {
64        printf("Decodificado: %s\n", decoded);  // Hello, World!
65        free(decoded);
66    } else {
67        printf("Erro: String Base64 inválida\n");
68    }
69    
70    free(encoded);
71    
72    return 0;
73}
74

1// Rust Codificação/Decodificação Base64
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!("Sequência UTF-8 inválida: {}", e))
15            }
16        },
17        Err(e) => Err(format!("String Base64 inválida: {}", e))
18    }
19}
20
21fn main() {
22    let original_text = "Hello, World!";
23    let encoded = encode_to_base64(original_text);
24    println!("Codificado: {}", encoded);  // SGVsbG8sIFdvcmxkIQ==
25    
26    match decode_from_base64(&encoded) {
27        Ok(decoded) => println!("Decodificado: {}", decoded),  // Hello, World!
28        Err(e) => println!("Erro: {}", e)
29    }
30}
31

Casos de Borda e Considerações

Ao trabalhar com codificação e decodificação Base64, esteja ciente dessas considerações importantes:

Unicode e Caracteres Não ASCII: Ao codificar texto com caracteres não ASCII, garanta a codificação de caracteres apropriada (geralmente UTF-8) antes da codificação Base64.
Preenchimento: O Base64 padrão usa preenchimento com caracteres "=" para garantir que o comprimento da saída seja um múltiplo de 4. Algumas implementações permitem omitir o preenchimento, o que pode causar problemas de compatibilidade.
Quebras de Linha: Implementações tradicionais de Base64 inserem quebras de linha (tipicamente a cada 76 caracteres) para legibilidade, mas aplicativos modernos frequentemente omitem isso.
Base64 Seguro para URL: O Base64 padrão usa os caracteres "+" e "/" que têm significados especiais em URLs. Para contextos de URL, use Base64 seguro para URL que substitui esses por "-" e "_".
Espaços em Branco: Ao decodificar, algumas implementações são tolerantes e ignoram espaços em branco, enquanto outras exigem a entrada exata.
Aumento de Tamanho: A codificação Base64 aumenta o tamanho dos dados em aproximadamente 33% (4 bytes de saída para cada 3 bytes de entrada).
Desempenho: A codificação/decodificação Base64 pode ser computacionalmente intensiva para dados muito grandes. Considere abordagens de streaming para arquivos grandes.

Whiz Tools

Codificador e Decodificador Base64: Converter Texto para/da Base64

Codificador/Decodificador Base64

Documentação