Decodificação Base64 em Perl: um guia completo

Você recebeu uma string de letras, dígitos e o ocasional + ou /, e lá no fundo você sabe que ela não é o que parece. Talvez seja um token viajando em um cabeçalho Authorization, um arquivo .b64 escavado de um chamado de suporte, um certificado vestindo a sua armadura -----BEGIN, ou um blob sentado quieto em um arquivo de configuração. Você abre um terminal, digita perl, e uma única pergunta toma conta de tudo o resto: como eu trago os dados de verdade de volta?

A resposta é pequena e reconfortante. O Perl embarca um módulo de Base64 junto com a própria linguagem desde 2002, e uma única chamada de função, decode_base64, faz o trabalho inteiro: nada para instalar, nada para configurar. Uma revisão rápida enquanto o café passa: o Base64 reescreve cada três bytes de dados como quatro caracteres de um alfabeto de 64 símbolos, completando o final com um ou dois sinais de = para que o resultado sempre caia em um múltiplo de quatro, e é por isso que a forma codificada costuma ficar uns 33 por cento maior do que a origem. A página inicial deste site explica o formato em profundidade, então este guia gasta todo o seu tempo no lado Perl da cerca: as regras do decodificador, os dialetos e os formatos do mundo real que você realmente vai encontrar.

A caixa de ferramentas: cinco funções, zero instalações

Toda chamada que você precisa mora no MIME::Base64, que faz parte da distribuição core do Perl desde o 5.8, então ele está presente em toda instalação séria, da embutida no firmware de um roteador à de um servidor de banco de dados. A verificação é uma linha:

perl -MMIME::Base64 -e 'print $MIME::Base64::VERSION, "\n"'
# 3.16_01

Aqui está o lado de decodificação do módulo, a coisa inteira:

O mapa de versões para essas funções, caso você esteja mantendo uma frota de máquinas antigas:

Se o Perl do seu sistema está sem o módulo por algum motivo, e não deveria, a correção é uma destas duas linhas: o pacote da distro libmime-base64-perl no Debian e no Ubuntu, ou cpanm MIME::Base64 para puxar a versão atual do CPAN, onde o módulo vive como pacote dual-life desde os tempos do core. Para a máquina rara sem compilador C, o gêmeo puro em Perl, MIME::Base64::Perl, no CPAN, oferece a mesma interface básica, algumas vezes mais lento, mas bom o bastante para qualquer coisa que não seja trabalho em volume. Essa é a história inteira de dependências: nada mais.

Um decodificador que nunca diz não

O contrato tem uma linha só. Entregue uma string, e ele devolve os bytes decodificados como uma string Perl comum carregando octetos crus. Sem objetos, sem exceções, sem flags. A documentação declara as duas regras que definem a personalidade dele em uma única frase: qualquer caractere que não faz parte do subconjunto Base64 de 65 caracteres é ignorado em silêncio, e qualquer caractere que apareça depois de um caractere de padding = nunca é decodificado. Essa cortesia é a coisa mais importante deste artigo, então deixe ela trabalhar por você uma vez:

use MIME::Base64 qw(decode_base64);
print decode_base64("TWFu!"),   "\n";  # Man - o ponto de exclamação desaparece sem deixar rastro
print decode_base64("TWFu=XX"), "\n";  # Man - tudo depois do = é ignorado
print decode_base64("TQ"),      "\n";  # M - sem aviso, sem comentário
print decode_base64("T"),       "\n";  # a string vazia, e ainda assim nenhuma queixa

As duas últimas linhas são a tolerância no limite extremo. O TQ carrega um byte completo mais quatro bits sobrando, e o decodificador simplesmente guarda o byte e joga o resto fora. O T não carrega nem um byte completo, então o resultado é vazio. Não existe modo estrito nem validador no módulo para devolver a exigência de escola velha: desde a versão 3.11 em 2010, o decode_base64 nem sequer avisa sobre entrada truncada, e as versões mais antigas costumavam resmungar um aviso de Premature end of base64 data sob -w. Se o blob está errado, ele decodifica assim mesmo, o que faz de você o portão de qualidade.

Aqui está a política de tolerância em um só lugar, para você ver a coisa inteira num relance:

Essa última linha é a que vale lembrar. Um segmento base64url entregue ao decodificador padrão não falha: ele decodifica para lixo com cara de plausível, porque os caracteres - e _ são tratados como ruído estrangeiro enquanto as letras restantes ainda formam grupos válidos. O decodificador é uma testemunha, não um porteiro, então se a entrada não é confiável, você mesmo valida. Um pequeno teste estrito é tudo o que é preciso:

sub strict_base64 {
  my ($blob) = @_;
  $blob =~ s/[\r\n]//g;  # o decodificador ignora estes, e nós também
  return 0 unless length($blob) % 4 == 0;
  return $blob =~ /\A[0-9A-Za-z+\/]+(?:={1,2})?\z/ ? 1 : 0;
}
print strict_base64("TWFu"),  "\n";  # 1
print strict_base64("TQ="),   "\n";  # 0 - contagem de padding errada
print strict_base64("ab-cd"), "\n";  # 0 - alfabeto URL-safe

Uma pequena palavra sobre aquela regex, de uma lição cara: se um sub termina em um return $x =~ /.../ puro e o resultado da correspondência falha vai direto para o printf, o Perl levanta um aviso enganoso de Missing argument in printf em vez de um zero limpo. Force a correspondência com ? 1 : 0 antes de retornar, como a função acima faz, e o truque desaparece por completo.

Bytes primeiro, caracteres depois

Lembre-se do que o decode_base64 retorna: bytes crus, uma string comum sem a flag UTF-8 definida. O que esses bytes significam é uma decisão que só você pode tomar, e é a etapa em que o Unicode faz as pessoas tropeçarem. O Perl acompanha se uma string carrega caracteres ou bytes, e o length(), o substr() e a maioria das expressões regulares se comportam de forma diferente dependendo da resposta. A correção é nomear a sua codificação de propósito, com o módulo Encode que vem em toda instalação do Perl:

use MIME::Base64 qw(decode_base64);
use Encode qw(decode);
my $raw  = decode_base64("SMOrbGxvIFdvcmxkIQ==");
my $text = decode("UTF-8", $raw);
print $text, "\n";            # Hëllo World!
print length($text), " chars\n";  # 12
print length($raw),  " bytes\n";  # 13

Esse par de números é a lição inteira. O blob tem 13 bytes mas só 12 caracteres, porque a letra acentuada ocupa dois bytes em UTF-8. Pule a etapa de charset e os bytes ainda vão imprimir certinho num terminal UTF-8, e é exatamente por isso que o erro fica escondido até uma função de string contar eles, ou os bytes viajarem por um pipeline que espera caracteres. Na dúvida, decodifique com um charset estrito e deixe a exceção contar a verdade sobre os bytes: passe Encode::FB_CROAK e o decode() morre em sequências inválidas em vez da substituição silenciosa por U+FFFD do padrão, o que é um recurso.

A lista curta de charsets que você vai realmente usar:

E aqui está a armadilha da qual a etapa de charset te protege. Se os bytes que você decodificou já são UTF-8 e você passa eles por um encode("UTF-8", ...) na saída, você não ganha uma cópia: você ganha uma codificação dupla, onde cada caractere acentuado incha para virar dois caracteres por conta própria. O sintoma clássico é texto que antes lia Hëllo e agora lê Hëllo, e o receptor do outro lado do fio vai decodificar aquilo com fidelidade. Bytes entrando, bytes saindo, uma conversão nomeada no meio.

base64url: o alfabeto para URLs e tokens

Metade do Base64 que cruza a internet moderna não é o alfabeto padrão, nem de longe. O caractere + é o jeito que um navegador codifica um espaço numa string de query, e o / é um separador de caminho, então as letras padrão são um desastre em URLs. A RFC 4648, seção 5, define a correção: um segundo alfabeto que troca o + e o / por - e _, e por convenção joga fora também o padding de = e as quebras de linha. A RFC é explícita: essa codificação não deve ser considerada a mesma que a codificação base64, e o Perl tem um par dedicado para ela desde a versão 3.11 em 2010:

use MIME::Base64 qw(decode_base64url);
my $raw = decode_base64url("c3Vuc2V0LTQy");
print $raw, "\n";  # sunset-42

Dois pontos para saber. Primeiro, o decode_base64url fica feliz com entrada sem padding, que é a forma que você vai encontrar de verdade na natureza, então o ritual de restaurar o padding primeiro, que outras linguagens exigem, não se aplica aqui; entrada com padding também funciona. Segundo, o decodificador padrão é um bicho diferente: alimente ele com um segmento base64url e você ganha bytes errados em silêncio, porque os caracteres - e _ são descartados como ruído e o resto ainda decodifica. Use o decodificador certo, ou normalize na mão quando estiver preso num caminho de código legado:

my $seg = "ab-cd_efgh";
$seg =~ tr{-_}{+/};                    # as letras URL-safe, traduzidas para casa
$seg .= "=" x (-length($seg) % 4);     # padding restaurado para o decodificador padrão
my $raw = decode_base64($seg);
print unpack("H*", $raw), "\n";  # 69bf9c77f79f82 - sete bytes, de volta ao alfabeto padrão

Você vai encontrar base64url imediatamente nos JWTs, os tokens que toda API moderna entrega, e em qualquer ID opaco que vive numa URL: IDs de vídeo de onze caracteres, UUIDs guardados no alfabeto URL-safe (o CPAN tem o Data::UUID::Base64URLSafe exatamente para isso), e chaves de banco de dados que precisam sobreviver a uma barra de endereço. E se você está num Perl antigo, anterior às funções do core, o módulo standalone MIME::Base64::URLSafe de 2006, um port do codec urlsafe do Python, fornece urlsafe_b64encode e urlsafe_b64decode; em qualquer coisa a partir do 3.11, as funções embutidas são a melhor escolha.

JWTs: lendo o cabeçalho e o payload

Um JSON Web Token é, estruturalmente, dois pedaços de JSON de disfarce mais um recibo criptográfico. A forma compacta da RFC 7515 é três segmentos base64url unidos por pontos: o cabeçalho protegido, o payload e a assinatura. Dividir e ler um é três linhas:

use MIME::Base64 qw(decode_base64url);
use JSON::PP;
my $jwt = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJob21lciJ9.uzM6l0c4...";
my ($head_b64, $claims_b64, $sig_b64) = split /\./, $jwt, 3;
my $head   = decode_json(decode_base64url($head_b64));
my $claims = decode_json(decode_base64url($claims_b64));
print $claims->{sub}, " (", $head->{alg}, ")\n";  # homer (HS256)

Note a divisão do trabalho: o decode_base64url transforma cada segmento em bytes, e o decode_json do módulo JSON::PP do core, presente desde o Perl 5.14, transforma os bytes do cabeçalho e do payload em estruturas de dados Perl. O segmento de assinatura também é base64url, mas ele é um resumo criptográfico, então você só decodifica os dois primeiros segmentos e deixa uma biblioteca adequada cuidar do terceiro.

A armadilha é a que todo mundo esquece: legível não quer dizer válido. O cabeçalho e o payload são legíveis por design, o que também significa que qualquer um pode reescrevê-los; a assinatura é a única prova. Para qualquer coisa de verdade, verifique, não decodifique só. O módulo do CPAN Crypt::JWT, que se constrói sobre o CryptX, faz o trabalho inteiro:

use Crypt::JWT qw(decode_jwt);
my $claims = decode_jwt(
  token        => $jwt,
  key          => $secret,
  accepted_alg => "HS256",
);

Ele croaks em uma assinatura ruim, e fixar o accepted_alg fecha o buraco de confusão de algoritmos onde um atacante vira o token para uma variante mais fraca. Um fluxo de decodificar-e-imprimir é bom o bastante para inspecionar um token durante uma chamada de suporte; não é autenticação.

Arquivos: do .b64 de volta ao original

Arquivos é onde a cultura de one-liners do Perl realmente brilha, e o trabalho inteiro cabe num comando. A flag -0777 é o ingrediente secreto, porque ela devora o arquivo inteiro em uma única string em vez de alimentar o decodificador linha por linha:

perl -MMIME::Base64 -0777 -ne 'print decode_base64($_)' < in.b64 > out

A forma linha por linha é segura para uma classe específica de arquivos: aqueles onde cada linha carrega um múltiplo de quatro caracteres Base64, o que vale para todo corpo devidamente envolto em MIME, já que 76 é um múltiplo de 4. No momento em que os pontos de quebra ficam desalinhados - e em arquivos embrulhados na mão eles quase sempre ficam - a decodificação linha por linha começa a produzir padding no meio dos dados. O modo slurp não tem essa condição, e é por isso que ele é a escolha padrão:

perl -MMIME::Base64 -ne 'print decode_base64($_)' < in.b64 > out

Dentro de um script, o padrão é a dança padrão de arquivos do Perl, com um detalhe discreto mas importante: as camadas :raw nos dois handles, para que o Perl nunca tente interpretar os bytes como texto da plataforma na entrada ou na saída:

use MIME::Base64 qw(decode_base64);
use Digest::SHA qw(sha256_hex);
open my $in, "<:raw", $ARGV[0] or die $!;
local $/;
my $blob = <$in>;
close $in;
my $decoded = decode_base64($blob);
print sha256_hex($decoded), "\n";  # compare com o checksum do remetente
open my $out, ">:raw", $ARGV[1] or die $!;
print {$out} $decoded;
close $out;

A linha do hash está fazendo mais do que se exibir. Porque o decodificador aceita quase qualquer coisa, um checksum que bate com o que o remetente publicou é a única prova de que a viagem foi exata byte a byte. Para arquivos realmente gigantes, o loop linha por linha é a alternativa de baixa memória, desde que as quebras caiam em fronteiras de quatro caracteres, e o MIME::Base64::decoded_base64_length te conta o tamanho que a saída vai ter antes de você se comprometer com um buffer.

A armadura PEM: tire o casaco, guarde o DER

Os arquivos .pem de todo stack de segurança são o mesmo Base64 vestindo armadura: uma linha de cabeçalho, uma linha de rodapé e um corpo envolto a 64 caracteres, por convenção da antiga Privacy Enhanced Mail. O invólucro é a única parte interessante, porque o decodificador do módulo não se importa com o comprimento das linhas de jeito nenhum:

use MIME::Base64 qw(decode_base64);
open my $fh, "<:raw", "cert.pem" or die $!;
local $/;
my $blob = <$fh>;
close $fh;
my @body = grep { !/^-----/ && /\S/ } split /\n/, $blob;
my $der = decode_base64(join "", @body);
print length($der), " bytes of DER\n";

As linhas BEGIN e END são removidas, o resto é juntado em uma única string, e cada quebra de linha é ignorada pelo caminho. Para o trabalho diário com certificados a ferramenta OpenSSL já faz isso por você; as oito linhas acima são o padrão para lembrar quando você precisa dos bytes DER crus por conta própria, para um hash, uma impressão digital ou uma comparação.

Data URIs: imagens que carregam o próprio endereço

O esquema data: da RFC 2397 embute um payload direto numa URL: data:, um tipo de mídia opcional, uma flag ;base64 opcional, uma vírgula e os dados. Mídias binárias como imagens usam a flag, então o payload é o alfabeto padrão com padding, e o decodificador comum cuida dele depois de um pequeno corte:

use MIME::Base64 qw(decode_base64);
my $uri = "data:image/png;base64,iVBORw0KGgo...";
$uri =~ s/^data:[^,]+,// or die "not a data URI";
my $raw = decode_base64($uri);
print unpack("H8", $raw), "\n";  # 89504e47: os bytes mágicos do PNG

Conferir os bytes mágicos é a jogada. Se aqueles primeiros oito caracteres hexadecimais não forem 89504e47, a imagem não é um PNG, não importa o que o tipo de mídia declare, e um decodificador que nunca reclama torna exatamente esse tipo de mentira silenciosa possível.

Primos e fósseis: uuencode e os outros alfabetos

Antes de o Base64 vencer, o jeito clássico UNIX de enviar um binário por e-mail era o uuencode, e você ainda vai encontrar ele em listas antigas e ferramentas antigas. A boa notícia: o Perl tem um decodificador embutido para ele, sem nenhum módulo, graças ao template u no pack e no unpack:

my $uu   = pack("u", "Hello, World!");
print $uu, "\n";  # -2&5L;&\L(%=O<FQD(0`` mais um newline
my $back = unpack("u", $uu);
print $back, "\n";  # Hello, World!

As duas chamadas são perfeitamente inversas, que é a história inteira que você precisa, e o clássico comando uuencode da toolchain UNIX simplesmente envolve as linhas soltas num cabeçalho begin e num rodapé end, então o payload que você está decodificando é a parte entre eles.

O Base64 também tem primos dialetos, e saber qual decodificador come qual te poupa uma sessão de debugging:

A conclusão: para toda variante de alfabeto padrão que só muda o envoltório, um decodificador tolerante cobre todas. Só quando o próprio alfabeto muda é que você precisa traduzir os caracteres primeiro.

Config, bancos de dados e variáveis de ambiente

Plataformas de container, consoles de nuvem e um número surpreendente de arquivos de configuração guardam credenciais e documentos pequenos como strings Base64 opacas, porque um blob de letras e dígitos parece menos perigoso do que a senha que ele é. A decodificação é sempre as mesmas duas etapas: decode_base64 mais uma decisão de charset:

use MIME::Base64 qw(decode_base64);
use Encode qw(decode);
my $secret = decode("UTF-8", decode_base64($config->{api_key}));

O motivo de o formato ser tão popular nesse lugar é exatamente o que a RFC 4648 adverte: as pessoas deixam de perceber que os dados são legíveis. Então trate a saída decodificada como confidencial desde o momento em que ela é devolvida, e mantenha tanto o blob quanto o resultado dele longe de arquivos de log, alertas e dumps de debug.

A mesma forma aparece em bancos de dados, onde dados binários frequentemente viajam numa coluna TEXT como Base64, porque a coluna não pode prometer que deixa bytes arbitrários passarem intactos:

use MIME::Base64 qw(decode_base64);
my $icon = decode_base64($row->{icon_data});
open my $fh, ">:raw", "icon.png" or die $!;
print {$fh} $icon;
close $fh;

E-mail: partes MIME e anexos

E-mail é onde o Base64 ganhou o nome, e a tolerância do módulo é desenhada exatamente para esse tráfego. Uma parte MIME com Content-Transfer-Encoding: base64 chega como linhas de 76 caracteres de texto terminado em CRLF, e o decodificador come o envelope inteiro como está, quebras de linha incluídas:

use MIME::Base64 qw(decode_base64);
my $part_body = "SGVsbG8sIHF1ZXJ5IQpUaGlzIE1JTUUgcGFydCB0cmF2ZWxsZWQgYXMgYmFzZTY0LCB3cmFwcGVk";
$part_body .= "\r\nIGF0IDc2IGNoYXJhY3RlcnMsIENSTEYgYmV0d2VlbiBsaW5lcy4=";
my $text = decode_base64($part_body);
print $text;  # o corpo original da mensagem, em duas linhas

Se você monta ou faz parse de e-mail com um framework, não faz nada disso na mão: o MIME::Lite codifica um anexo em base64 para você quando você passa Encoding => "base64" para o attach, e o Email::MIME faz o mesmo automaticamente. A versão feita na mão acima é para o e-mail que chega como texto cru num log, num chamado ou numa mensagem encaminhada, o que na prática é boa parte dele.

Armadilhas, coletadas e ranqueadas

O módulo é pequeno o bastante para memorizar, então aqui está a lista inteira de armadilhas em um só lugar, ordenadas mais ou menos pela frequência com que mordem:

Bons hábitos

Os hábitos que impedem o Base64 de dar o troco nos seus scripts:

• Esperar bytes, sempre. Escreva código que saiba que o decode_base64 retorna octetos crus, e encadeie o decode de charset explicitamente em vez de torcer para que o terminal faça a coisa certa.
• Nomeie o seu charset. Padrãoize no UTF-8 e mude só quando os dados disserem o contrário. A falha estrita do decode("UTF-8", ..., Encode::FB_CROAK) é um recurso: ela te conta que os bytes não são o que você presumiu.
• Combine o alfabeto com a origem. decode_base64url para URLs, tokens e IDs; decode_base64 para tudo o resto. Os dois alfabetos não são intercambiáveis, e o decodificador não vai te avisar quando você errar a escolha.
• Valide antes de decodificar. Não existe flag de modo estrito neste módulo, então um pequeno teste é o porteiro.
• Devore arquivos por padrão. -0777 ou local $/ = undef elimina uma classe inteira de bugs de ponto de quebra, e o custo de memória não é problema para os arquivos que você realmente decodifica.
• Use :raw em todo file handle. Binário entrando, binário saindo. Camadas de texto são para humanos, não para bytes.
• Verifique com um hash. Quando o original está disponível, um checksum que bate é a única prova de uma decodificação exata byte a byte.
• Nunca registre o que você decodifica. O formato não esconde nada.

Uma breve história, contada pelo changelog

O formato é antigo, e o relacionamento do Perl com ele é mais antigo do que parece. Algumas datas conferidas, em ordem:

• O código C é anterior ao Perl 5. O decodificador rápido dentro do módulo descende de código do metamail, o programa de e-mail da Bellcore, com copyright em 1991, três anos antes do primeiro release do Perl 5. Quando você chama o decode_base64 hoje, um pedaço dos anos 90 está fazendo o trabalho.
• Nascido nas ferramentas web. O módulo começou como LWP::Base64 dentro do libwww-perl no meio dos anos 90, escrito por Martijn Koster e Joerg Reichelt, e se formou na própria distribuição do CPAN, MIME::Base64, em abril de 1997, versão 2.00, com a entrada no changelog lendo baseado no libwww-perl-5.08.
• A era dos avisos. A partir do 2.03 em 1997, entrada truncada produzia um aviso de Premature end of base64 data sob -w em vez de um croak, e o 2.11 em 1999 corrigiu os builds que avisavam sobre dados que estavam bons. Foi uma década mais nervosa para decodificadores.
• No core desde 2002. O Perl 5.8 puxou o módulo para a distribuição core, e a sincronização 2.13 com o core naquele mesmo dezembro trouxe o suporte EBCDIC junto, e é por isso que o codificador e o decodificador ainda funcionam em mainframes.
• O dialeto URL-safe chegou no core do Perl em 2010. A versão 3.11 adicionou o decode_base64url e o irmão dele, quatro anos depois que o módulo standalone MIME::Base64::URLSafe aterrissou no CPAN em 2006, o mesmo ano em que a RFC 4648 codificou o dialeto.
• O silenciamento. Aquele mesmo release 3.11 removeu até o antigo aviso de truncamento, pela pequena chance de que a entrada suspeita fosse intencional - e todos os releases desde então, incluindo a linha atual 3.16 de 2020, mantiveram o decodificador educado e silencioso.

Fatos curiosos, especificamente do Perl

Para fechar o passeio, as curiosidades que fazem desta história uma boa história:

• Decodifique o nome do próprio formato. decode_base64("YmFzZTY0") retorna base64. É verdade desde 1997 e vai ser verdade para sempre.
• O decodificador é um fantasma educado. Na sua história 3.x ele nunca lançou uma exceção em entrada ruim. Corrompida, truncada, alfabeto errado: ele decodifica tudo e não reclama de nada, um comportamento que o changelog cimentou de propósito em 2010.
• O envoltório MIME é um múltiplo de quatro de propósito. O limite de 76 caracteres é dezenove grupos de três bytes, 57 bytes no total, vezes quatro caracteres, e é por isso que uma decodificação linha por linha é segura em qualquer corpo MIME devidamente envolto e insegura em qualquer outra coisa.
• O uuencode nunca imprime uma letra minúscula. O alfabeto dele termina no underscore, e é por isso que arquivos uuencoded antigos parecem datilografados por uma máquina só de maiúsculas, e por que o Perl ainda carrega um decodificador embutido para um formato mais velho que a internet.
• O Perl já embarcou um comando decode-base64 próprio. Releases do 2.14 em 2003 ao 3.05 em 2004 incluíam encode-base64, decode-base64 e os gêmeos deles de quoted-printable como scripts; o 3.06 em 2005 os moveu para a distribuição separada MIME-Base64-Scripts. Se você encontrar uma instalação antiga com esse comando no PATH, agora você sabe de onde ele veio.
• IDs de vídeo do YouTube são base64url de disfarce. O ID de onze caracteres na sua barra de endereço é um número de 64 bits no alfabeto URL-safe com o padding removido, então todo vídeo que você já assistiu tem uma string Base64 na URL dele, e o decode_base64url consegue ler um.
• A tolerância é um padrão, não um bug. A regra MIME de ser liberal no que você aceita é o motivo deste decodificador sobreviver a três décadas de dados bagunçados, e o motivo da RFC 4648 avisar que a mesma tolerância pode virar um canal encoberto se você confiar em entrada não confiável.

Então da próxima vez que uma string de letras, dígitos, mais e barra cair no seu terminal, você sabe a história inteira. Uma chamada de função faz o trabalho, o decodificador é um fantasma educado que nunca vai te recusar, o base64url tem o decodificador dele, o charset é uma decisão que você toma de propósito, os arquivos entram crus e saem crus, e um hash é a única prova que importa. E se um dia você precisar fazer a viagem na direção oposta, embutindo os seus próprios dados crus num envelope de texto e os despachando para o mundo, o artigo relacionado sobre codificação Base64 em Perl, linkado abaixo, cobre esse ritual na mesma profundidade.

Última atualização: 2026-09-08

Artigo relacionado: Codificação Base64 em Perl: um guia completo