Кодировщик и декодировщик Base64: Конвертировать текст в/из Base64
Бесплатный онлайн инструмент для кодирования текста в Base64 или декодирования строк Base64 обратно в текст. Поддерживает стандартное и безопасное для URL кодирование Base64 с мгновенным преобразованием.
Кодировщик/Декодировщик Base64
Преобразуйте текст в кодировку Base64 и обратно
Документация
Кодировщик и декодировщик Base64
Введение
Base64 — это схема кодирования бинарных данных в текстовом формате, которая представляет бинарные данные в виде ASCII-строки. Она предназначена для передачи данных, хранящихся в бинарных форматах, по каналам, которые надежно поддерживают только текстовое содержимое. Кодирование Base64 преобразует бинарные данные в набор из 64 символов (отсюда и название), которые можно безопасно передавать по текстовым протоколам без повреждения данных.
Набор символов Base64 состоит из:
- Заглавные буквы A-Z (26 символов)
- Строчные буквы a-z (26 символов)
- Цифры 0-9 (10 символов)
- Два дополнительных символа, обычно "+" и "/" (2 символа)
Этот инструмент позволяет вам легко кодировать текст в формат Base64 или декодировать строки Base64 обратно в их исходный текст. Он особенно полезен для разработчиков, ИТ-специалистов и всех, кто работает с данными, которые необходимо безопасно передавать через текстовые каналы.
Как работает кодирование Base64
Процесс кодирования
Кодирование Base64 работает путем преобразования каждой группы из трех байтов (24 бита) бинарных данных в четыре символа Base64. Процесс включает следующие шаги:
- Преобразуйте входной текст в его бинарное представление (используя кодировку ASCII или UTF-8)
- Группируйте бинарные данные в блоки по 24 бита (3 байта)
- Разделите каждый 24-битный блок на четыре 6-битные группы
- Преобразуйте каждую 6-битную группу в соответствующий символ Base64
Когда длина входных данных не делится на 3, добавляется дополнение с символами "=" для поддержания соотношения 4:3 между длиной выходных и входных данных.
Математическое представление
Для последовательности байтов соответствующие символы Base64 вычисляются следующим образом:
Где представляет собой -й символ в алфавите Base64.
Процесс декодирования
Декодирование Base64 обращает процесс кодирования:
- Преобразуйте каждый символ Base64 в его 6-битное значение
- Объедините эти 6-битные значения
- Группируйте биты в 8-битные блоки (байты)
- Преобразуйте каждый байт в соответствующий символ
Дополнение
Когда количество байтов для кодирования не делится на 3, применяется дополнение:
- Если остается один байт, он преобразуется в два символа Base64, за которыми следуют "=="
- Если остается два байта, они преобразуются в три символа Base64, за которыми следует "="
Пример
Давайте закодируем текст "Hello" в Base64:
- ASCII представление "Hello": 72 101 108 108 111
- Бинарное представление: 01001000 01100101 01101100 01101100 01101111
- Группировка в 6-битные блоки: 010010 000110 010101 101100 011011 000110 1111
- Последний блок имеет только 4 бита, поэтому мы дополняем нулями: 010010 000110 010101 101100 011011 000110 111100
- Преобразование в десятичное: 18, 6, 21, 44, 27, 6, 60
- Поиск в алфавите Base64: S, G, V, s, b, G, 8
- Результат: "SGVsbG8="
Обратите внимание на дополнение "=" в конце, потому что длина входных данных (5 байт) не делится на 3.
Формула
Общая формула для вычисления длины закодированной строки Base64:
Где представляет собой функцию округления вверх (округление до ближайшего целого числа).
Сценарии использования
Кодирование Base64 широко используется в различных приложениях:
-
Вложения в электронную почту: MIME (расширения многоцелевой интернет-почты) использует Base64 для кодирования бинарных вложений в электронной почте.
-
URL-данные: Встраивание небольших изображений, шрифтов или других ресурсов непосредственно в HTML, CSS или JavaScript с использованием схемы URL
data:. -
API-коммуникации: Безопасная передача бинарных данных в JSON-данных или других текстовых форматах API.
-
Хранение бинарных данных в текстовых форматах: Когда бинарные данные необходимо хранить в XML, JSON или других текстовых форматах.
-
Системы аутентификации: Базовая аутентификация в HTTP использует кодирование Base64 (хотя это не для безопасности, а просто для кодирования).
-
Криптография: В рамках различных криптографических протоколов и систем, часто для кодирования ключей или сертификатов.
-
Значения cookie: Кодирование сложных структур данных для хранения в cookie.
Альтернативы
Хотя Base64 широко используется, существуют альтернативы, которые могут быть более подходящими в определенных ситуациях:
-
Безопасный для URL Base64: Вариант, который использует "-" и "_" вместо "+" и "/", чтобы избежать проблем с кодированием URL. Полезно для данных, которые будут включены в URL.
-
Base32: Использует набор из 32 символов, что приводит к более длинному выходу, но с лучшей читаемостью для человека и нечувствительностью к регистру.
-
Шестнадцатеричное кодирование: Простое преобразование в шестнадцатеричный формат, который менее эффективен (удваивает размер), но очень прост и широко поддерживается.
-
Бинарная передача: Для больших файлов или когда эффективность имеет решающее значение, предпочтительнее прямой бинарный передачный протокол, такой как HTTP с соответствующими заголовками Content-Type.
-
Сжатие + Base64: Для больших текстовых данных сжатие перед кодированием может уменьшить увеличение размера.
-
Сериализация JSON/XML: Для структурированных данных использование родной сериализации JSON или XML может быть более подходящим, чем кодирование Base64.
История
Кодирование Base64 имеет свои корни в ранних вычислительных и телекоммуникационных системах, где бинарные данные необходимо было передавать по каналам, предназначенным для текста.
Официальная спецификация Base64 была впервые опубликована в 1987 году в RFC 989, который определял защищенную почту (PEM). Это было позже обновлено в RFC 1421 (1993) и RFC 2045 (1996, как часть MIME).
Термин "Base64" происходит от того, что кодирование использует 64 различных ASCII-символа для представления бинарных данных. Этот выбор 64 символов был преднамеренным, так как 64 является степенью двойки (2^6), что делает преобразование между бинарными данными и Base64 эффективным.
Со временем возникло несколько вариантов Base64:
- Стандартный Base64: Как определено в RFC 4648, использует A-Z, a-z, 0-9, +, / и = для дополнения
- Безопасный для URL Base64: Использует - и _ вместо + и / для избежания проблем с кодированием URL
- Безопасный для имени файла Base64: Похож на безопасный для URL, предназначен для использования в именах файлов
- Модифицированный Base64 для IMAP: Используется в протоколе IMAP с другим набором специальных символов
Несмотря на то, что ему более трех десятилетий, Base64 остается основным инструментом в современном вычислении, особенно с ростом веб-приложений и API, которые сильно зависят от текстовых форматов данных, таких как JSON.
Примеры кода
Вот примеры кодирования и декодирования Base64 на различных языках программирования:
1// Кодирование/декодирование Base64 на 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("Недопустимая строка Base64");
11 }
12}
13
14// Пример использования
15const originalText = "Hello, World!";
16const encoded = encodeToBase64(originalText);
17console.log("Закодировано:", encoded); // SGVsbG8sIFdvcmxkIQ==
18
19try {
20 const decoded = decodeFromBase64(encoded);
21 console.log("Декодировано:", decoded); // Hello, World!
22} catch (error) {
23 console.error(error.message);
24}
251# Кодирование/декодирование Base64 на Python
2import base64
3
4def encode_to_base64(text):
5 # Преобразовать строку в байты, а затем закодировать
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 # Преобразовать строку base64 в байты, а затем декодировать
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"Недопустимая строка Base64: {e}")
18
19# Пример использования
20original_text = "Hello, World!"
21encoded = encode_to_base64(original_text)
22print(f"Закодировано: {encoded}") # SGVsbG8sIFdvcmxkIQ==
23
24try:
25 decoded = decode_from_base64(encoded)
26 print(f"Декодировано: {decoded}") # Hello, World!
27except ValueError as e:
28 print(e)
291// Кодирование/декодирование Base64 на 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("Недопустимая строка Base64: " + 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("Закодировано: " + encoded); // SGVsbG8sIFdvcmxkIQ==
26
27 try {
28 String decoded = decodeFromBase64(encoded);
29 System.out.println("Декодировано: " + decoded); // Hello, World!
30 } catch (IllegalArgumentException e) {
31 System.err.println(e.getMessage());
32 }
33 }
34}
351<?php
2// Кодирование/декодирование Base64 на 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("Недопустимая строка Base64");
11 }
12 return $decoded;
13}
14
15// Пример использования
16$originalText = "Hello, World!";
17$encoded = encodeToBase64($originalText);
18echo "Закодировано: " . $encoded . "\n"; // SGVsbG8sIFdvcmxkIQ==
19
20try {
21 $decoded = decodeFromBase64($encoded);
22 echo "Декодировано: " . $decoded . "\n"; // Hello, World!
23} catch (Exception $e) {
24 echo "Ошибка: " . $e->getMessage() . "\n";
25}
26?>
271// Кодирование/декодирование Base64 на 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("Недопустимая строка Base64");
23 }
24 }
25
26 static void Main()
27 {
28 string originalText = "Hello, World!";
29 string encoded = EncodeToBase64(originalText);
30 Console.WriteLine($"Закодировано: {encoded}"); // SGVsbG8sIFdvcmxkIQ==
31
32 try
33 {
34 string decoded = DecodeFromBase64(encoded);
35 Console.WriteLine($"Декодировано: {decoded}"); // Hello, World!
36 }
37 catch (FormatException e)
38 {
39 Console.WriteLine($"Ошибка: {e.Message}");
40 }
41 }
42}
431# Кодирование/декодирование Base64 на 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 "Недопустимая строка Base64: #{e.message}"
13 end
14end
15
16# Пример использования
17original_text = "Hello, World!"
18encoded = encode_to_base64(original_text)
19puts "Закодировано: #{encoded}" # SGVsbG8sIFdvcmxkIQ==
20
21begin
22 decoded = decode_from_base64(encoded)
23 puts "Декодировано: #{decoded}" # Hello, World!
24rescue StandardError => e
25 puts "Ошибка: #{e.message}"
26end
271// Кодирование/декодирование Base64 на 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("недопустимая строка Base64: %v", err)
17 }
18 return string(bytes), nil
19}
20
21func main() {
22 originalText := "Hello, World!"
23 encoded := encodeToBase64(originalText)
24 fmt.Println("Закодировано:", encoded) // SGVsbG8sIFdvcmxkIQ==
25
26 decoded, err := decodeFromBase64(encoded)
27 if err != nil {
28 fmt.Println("Ошибка:", err)
29 } else {
30 fmt.Println("Декодировано:", decoded) // Hello, World!
31 }
32}
331// Кодирование/декодирование Base64 на 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// Пример использования
19let originalText = "Hello, World!"
20if let encoded = encodeToBase64(originalText) {
21 print("Закодировано: \(encoded)") // SGVsbG8sIFdvcmxkIQ==
22
23 if let decoded = decodeFromBase64(encoded) {
24 print("Декодировано: \(decoded)") // Hello, World!
25 } else {
26 print("Ошибка: Не удалось декодировать строку Base64")
27 }
28} else {
29 print("Ошибка: Не удалось закодировать текст")
30}
311' Кодирование/декодирование Base64 на VBA Excel
2' Примечание: Это требует ссылки на 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 = "Ошибка: Недопустимая строка Base64"
39End Function
40
41' Использование в рабочем листе:
42' =EncodeToBase64("Hello, World!")
43' =DecodeFromBase64("SGVsbG8sIFdvcmxkIQ==")
441# Кодирование/декодирование Base64 на R
2# Требуется пакет 'base64enc'
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7 # Преобразовать текст в необработанные байты, затем закодировать
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 # Преобразовать строку base64 в необработанные байты, затем декодировать
16 base64_raw <- charToRaw(base64_string)
17 decoded_raw <- base64decode(base64_raw)
18 return(rawToChar(decoded_raw))
19 }, error = function(e) {
20 stop(paste("Недопустимая строка Base64:", e$message))
21 })
22}
23
24# Пример использования
25original_text <- "Hello, World!"
26encoded <- encode_to_base64(original_text)
27cat("Закодировано:", encoded, "\n") # SGVsbG8sIFdvcmxkIQ==
28
29tryCatch({
30 decoded <- decode_from_base64(encoded)
31 cat("Декодировано:", decoded, "\n") # Hello, World!
32}, error = function(e) {
33 cat("Ошибка:", e$message, "\n")
34})
351% Кодирование/декодирование Base64 на MATLAB
2function demo_base64()
3 originalText = 'Hello, World!';
4
5 % Кодировать
6 encoded = encode_to_base64(originalText);
7 fprintf('Закодировано: %s\n', encoded); % SGVsbG8sIFdvcmxkIQ==
8
9 % Декодировать
10 try
11 decoded = decode_from_base64(encoded);
12 fprintf('Декодировано: %s\n', decoded); % Hello, World!
13 catch e
14 fprintf('Ошибка: %s\n', e.message);
15 end
16end
17
18function encoded = encode_to_base64(text)
19 % Преобразовать текст в массив uint8 и закодировать
20 bytes = uint8(text);
21 encoded = base64encode(bytes);
22end
23
24function decoded = decode_from_base64(base64String)
25 try
26 % Декодировать строку base64 в массив uint8
27 bytes = base64decode(base64String);
28 decoded = char(bytes);
29 catch
30 error('Недопустимая строка Base64');
31 end
32end
331// Кодирование/декодирование Base64 на C с использованием 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; // Недопустимый ввод Base64
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("Закодировано: %s\n", encoded); // SGVsbG8sIFdvcmxkIQ==
61
62 char* decoded = decode_from_base64(encoded);
63 if (decoded) {
64 printf("Декодировано: %s\n", decoded); // Hello, World!
65 free(decoded);
66 } else {
67 printf("Ошибка: Недопустимая строка Base64\n");
68 }
69
70 free(encoded);
71
72 return 0;
73}
741// Кодирование/декодирование Base64 на 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!("Недопустимая последовательность UTF-8: {}", e))
15 }
16 },
17 Err(e) => Err(format!("Недопустимая строка Base64: {}", e))
18 }
19}
20
21fn main() {
22 let original_text = "Hello, World!";
23 let encoded = encode_to_base64(original_text);
24 println!("Закодировано: {}", encoded); // SGVsbG8sIFdvcmxkIQ==
25
26 match decode_from_base64(&encoded) {
27 Ok(decoded) => println!("Декодировано: {}", decoded), // Hello, World!
28 Err(e) => println!("Ошибка: {}", e)
29 }
30}
31Пограничные случаи и соображения
При работе с кодированием и декодированием Base64 имейте в виду эти важные соображения:
-
Юникод и не-ASCII символы: При кодировании текста с не-ASCII символами убедитесь, что используется правильная кодировка символов (обычно UTF-8) перед кодированием Base64.
-
Дополнение: Стандартный Base64 использует дополнение с символами "=" для обеспечения того, чтобы длина выходных данных была кратна 4. Некоторые реализации позволяют опускать дополнение, что может вызвать проблемы совместимости.
-
Перенос строк: Традиционные реализации Base64 вставляют переносы строк (обычно каждые 76 символов) для читаемости, но современные приложения часто опускают их.
-
Безопасный для URL Base64: Стандартный Base64 использует "+" и "/" символы, которые имеют специальные значения в URL. Для контекстов URL используйте безопасный для URL Base64, который заменяет их на "-" и "_".
-
Пробелы: При декодировании некоторые реализации являются снисходительными и игнорируют пробелы, в то время как другие требуют точного ввода.
-
Увеличение размера: Кодирование Base64 увеличивает размер данных примерно на 33% (4 выходных байта на каждые 3 входных байта).
-
Производительность: Кодирование/декодирование Base64 может быть вычислительно затратным для очень больших данных. Рассмотрите возможность потоковых подходов для больших файлов.
Ссылки
Обратная связь
Нажмите на всплывающее окно обратной связи, чтобы начать давать обратную связь об этом инструменте
Связанные инструменты
Откройте больше инструментов, которые могут быть полезны для вашего рабочего процесса