Кодирование и декодирование java base64

What tools does Smush.it use to smush images?

We have found many good tools for reducing image size. Often times these tools are specific to particular image formats and work much better in certain circumstances than others. To «smush» really means to try many different image reduction algorithms and figure out which one gives the best result.

These are the algorithms currently in use:

1. ImageMagick: to identify the image type and to convert GIF files to PNG files.
2. pngcrush: to strip unneeded chunks from PNGs. We are also experimenting with other PNG reduction tools such as pngout, optipng, pngrewrite. Hopefully these tools will provide improved optimization of PNG files.
3. jpegtran: to strip all metadata from JPEGs (currently disabled) and try progressive JPEGs.
4. gifsicle: to optimize GIF animations by stripping repeating pixels in different frames.

расшифровка base64_decode описание

1. Скачать

1. Как обновить java на windows 10 бесплатно

   base64_decode — это функция, которая противоположна base64_encode . Те данные, зашифрованные base64_encode можно декодировать с помощью base64_decode

   base64_decode ( string $var ) : string|false
   Что означает выше приведенная информация спецификации base64_decode!?

   base64_decode — написание функции base64_decode

   «string» — передаваемое значение в функцию должно иметь тип данных string

   bool — тип данных bool

   $var — переменная с данными

   $strict — Если параметр strict задан как TRUE, функция base64_decode() вернет FALSE в случае, если входные данные содержат символы, не входящие в алфавит base64. В противном случае такие символы будут отброшены.

   «: string|false» — возвращает тип данных строку, либо false.

   Для того, что продемонстрировать, как работает данное декодирование base64_decode

   Мы должны какие-то данные зашифровать например «Hello world!»

   Hello world! = SGVsbG8gd29ybGQh

   Полученные данные помещаем в переменную: :

   $example = ‘SGVsbG8gd29ybGQh ‘;

   Применяем к данной строке расшифровка base64_decode :

   base64_decode ($example);

   Выводим с помощью echo

   echo base64_decode ($example);

   Hello world!

   Как вы наверное знаете, что некоторые функции категорически не работают с кириллицей в utf-8 по причине, которую мы вот тут разбирали.

   Для того, чтобы проверить работу функции base64_decode с кириллицей utf-8, нам опять понадобится сперва зашифровать «Привет мир!» :

   Привет мир! = 0J/RgNC40LLQtdGCINC80LjRgCE=

   Полученные данные помещаем в переменную:

   $example = ‘0J/RgNC40LLQtdGCINC80LjRgCE=’;

   Выводим :

   echo base64_decode ($example);

   Привет мир!

2. Как расшифровать данные с помощью base64_decode?

   Чтобы получить строку, которая закодирована ранее, для вашего удобства сделаю два поля —

   декодировать.

   На данной в поле введите данные и нажмите отправить.

   Скопируйте результат.

   Вставьте скопированную строку в поле ниже и нажмите Декодировать base64_decode.

Php код для шифрования текста с помощью функции base64_decode

Style:

.kod {

display: block;

background: #fbfbfb;

margin: 10px 0 10px 0;

padding: 20px;

border: 1px solid #a7a7a7;

font-size: 14px;

word-break: break-word;

}

Php:

<?

if($_POST) { $result = ‘<a name=»result»></a><red> Ваш зашифрованный текст</red> : <div class=»kod»>’ . base64_decode (strip_tags($_POST)).'</div>’ ;}

?>

Html:

<? echo $result; ?>

<form method=»post» action=»#result»>

<textarea name=»example»></textarea>

<input name=»example1″ type=»submit» class=»width_100pro padding_10_0″>

</form>

Пользуйтесь на здоровье! Не забудьте сказать

Название скрипта :Расшифровка base64_decode
Ссылка на скачивание : Все скрипты на

Теги :

Реализация декодирования

Декодирование реализуется гораздо проще. При использовании LINQ без необходимости оптимизаций скорости алгоритм на C# может представлять из себя следующее:

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

public byte[] FromBase64Custom(string str)
{
	var allBytes = string.Join("", str.Where(x => x != '=').Select(x => Convert.ToString(base64DIctionary, 2).PadLeft(6, '0')));

	var countOfBytes = allBytes.Count();

	return Enumerable.Range(0, countOfBytes / 8).Select(x => allBytes.Substring(x * 8, 8)).Select(x => Convert.ToByte(x, 2)).ToArray();
}

Здесь всё то же самое что и с кодированием – подобная реализация проста для понимания, но ни в коем случае нельзя её использовать для реальных проектов, так как скорость работы данного алгоритма недопустимо медленна.

Вот что показало тестирование скорости работы в BenchmarkDotNet при сравнении с реализацией в :

Разница в скорости работы примерно в 60 раз.

Если же опять отказаться от LINQ, добавить работу с битами и убрать лишние вызовы, получится что-то похожее:

public unsafe byte[] FromBase64Custom(string str)
{
    var length = str.Length;
    var countOfEquals = str.EndsWith("==") ? 2 : str.EndsWith("=") ? 1 : 0;
    var arraySize = (length - countOfEquals) * 6 / 8;

    var result = new byte;
    var loopLength = (length / 4) * 4;

    var arrayPosition = 0;
    var stringPosition = 0;
    fixed (char* c = str)
    {
        fixed (byte* element = result)
        {
            for (int i = 0; i < loopLength; i += 4)
            {

                var next = base64DIctionary;
                var buf = base64DIctionary;
                next = next << 2;
                next |= (buf >> 4);
                *(element + arrayPosition++) = (byte)next;

                next = (buf & 0b001111) << 4;
                buf = base64DIctionary;
                next |= (buf >> 2);
                *(element + arrayPosition++) = (byte)next;


                next = (buf & 0b000011) << 6;
                buf = base64DIctionary;
                next |= buf;
                *(element + arrayPosition++) = (byte)next;
            }
            if (countOfEquals != 0)
            {
                var cur = loopLength;

                if (stringPosition < str.Length)
                {
                    var next = base64DIctionary << 2;

                    var buf = base64DIctionary;
                    next |= buf >> 4;
                    *(element + arrayPosition++) = (byte)next;
                    if (countOfEquals == 1)
                    {
                        next = (buf & 0b001111) << 4;
                        buf = base64DIctionary;
                        next |= (buf >> 2);
                        *(element + arrayPosition) = (byte)next;
                    }
                    if (countOfEquals == 2)
                    {
                        next = (buf & 0b001111) << 4;
                        buf = base64DIctionary;
                        next |= (buf >> 2);
                        *(element + arrayPosition) = (byte)next;
                    }
                }
            }
        }
    }
    return result;
}

Данная реализация так же не является оптимальной, но уже гораздо ближе к ней. Ниже приведены результаты работы бенчмарка:

На реальных проектах, используя .NET технологии для разработки, маловероятно, что вам необходимо будет собственная реализация алгоритма Base64. Но понимание того, как он работает, несомненно является большим плюсом, так как идеи, которые используются для реализации могут быть применены в схожих задачах. Например, именно для ваших целей, может быть эффективен некий аналог с названием Base512 (использующий таблицу доступных символов гораздо большего размера, либо меньшего), либо вам нужно будет использовать другую таблицу символов. Со знанием того, как устроен Base64 реализовать подобное не составит труда. Также стоит иметь ввиду, что многие вещи можно реализовать в C# очень быстро, но всегда нужно думать о производительности ваших алгоритмов, чтобы они не стали «бутылочным горлышком» для ваших приложений. LINQ очень приятно использовать, но за использование данной технологии приходится платить скоростью исполнения самих приложений, и в местах, где критична производительности, следует отказаться от их использования, заменив чем-то более эффективным.

А на этом всё.

Приятного программирования.

Кодирование/декодирование двоичных данных.

Модуль предоставляет функции для кодирования двоичных данных в печатаемые символы ASCII и декодирования таких кодировок обратно в двоичные данные. Он обеспечивает функции кодирования и декодирования для кодировок, указанных в RFC 3548, который определяет алгоритмы , и , а также для де-факто стандартных кодировок и .

Кодировки RFC 3548 подходят для кодирования двоичных данных, чтобы их можно было безопасно отправлять по электронной почте, использовать как части URL-адресов или включать как часть HTTP POST запроса. Алгоритм кодирования не совпадает с алгоритмом программы .

Этот модуль предоставляет два интерфейса. Современный интерфейс поддерживает кодирование байтовоподобных объектов в байты ASCII и декодирование байтообразных объектов или строк, содержащих ASCII в байты. Поддерживаются оба алфавита base-64, определенные в RFC 3548 — это обычный и безопасный для URL и файловой системы.

Устаревший интерфейс (рассматриваться не будет) не поддерживает декодирование из строк, но он предоставляет функции для кодирования и декодирования в и из файловых объектов. Он поддерживает только стандартный алфавит и добавляет новые строки каждые 76 символов в соответствии с RFC 2045.

Примеры использования:

>>> import base64
>>> encoded = base64.b64encode(b'data to be encoded')
>>> encoded
# b'ZGF0YSB0byBiZSBlbmNvZGVk'
>>> data = base64.b64decode(encoded)
>>> data
# b'data to be encoded'

Кодирование файла в base64

# file-to-base64.py
import base64, pprint

with open(__file__, 'r', encoding='utf-8') as fp
    raw = fp.read()

byte_string = raw.encode('utf-8')
encoded_data = base64.b64encode(byte_string)

num_initial = len(byte_string)
num_encoded = len(encoded_data)

padding = 3 - (num_initial % 3)

print(f'{num_initial} байт до кодирования')
print(f'{padding} байта заполнения')
print(f'{num_encoded} bytes после encoding\n')
# Так как строка длинная печатаем ее при помощи pprint
pprint.pprint(encoded_data, width=60)

Результат:

$ python3 file-to-base64.py
586 байт до кодирования
2 байта заполнения
784 bytes после encoding

(b'IyBmaWxlLXRvLWJhc2U2NC5weQppbXBvcnQgYmFzZTY0LCBwcHJpbnQK'
 b'CndpdGggb3BlbihfX2ZpbGVfXywgJ3InLCBlbmNvZGluZz0ndXRmLTgn'
 b'KSBhcyBmcDoKICAgIHJhdyA9IGZwLnJlYWQoKQoKYnl0ZV9zdHJpbmcg'
 b'PSByYXcuZW5jb2RlKCd1dGYtOCcpCmVuY29kZWRfZGF0YSA9IGJhc2U2'
 b'NC5iNjRlbmNvZGUoYnl0ZV9zdHJpbmcpCgpudW1faW5pdGlhbCA9IGxl'
 b'bihieXRlX3N0cmluZykKbnVtX2VuY29kZWQgPSBsZW4oZW5jb2RlZF9k'
 b'YXRhKQoKcGFkZGluZyA9IDMgLSAobnVtX2luaXRpYWwgJSAzKQoKcHJp'
 b'bnQoZid7bnVtX2luaXRpYWx9INCx0LDQudGCINC00L4g0LrQvtC00LjR'
 b'gNC+0LLQsNC90LjRjycpCnByaW50KGYne3BhZGRpbmd9INCx0LDQudGC'
 b'0LAg0LfQsNC/0L7Qu9C90LXQvdC40Y8nKQpwcmludChmJ3tudW1fZW5j'
 b'b2RlZH0gYnl0ZXMg0L/QvtGB0LvQtSBlbmNvZGluZ1xuJykKIyDQotCw'
 b'0Log0LrQsNC6INGB0YLRgNC+0LrQsCDQtNC70LjQvdC90LDRjyDQv9C1'
 b'0YfQsNGC0LDQtdC8INC10LUg0L/RgNC4INC/0L7QvNC+0YnQuCBwcHJp'
 b'bnQKcHByaW50LnBwcmludChlbmNvZGVkX2RhdGEsIHdpZHRoPTYwKQ==')

The «Unicode Problem»

Since s are 16-bit-encoded strings, in most browsers calling on a Unicode string will cause a exception if a character exceeds the range of a 8-bit byte (0x00~0xFF). There are two possible methods to solve this problem:

• the first one is to escape the whole string (with UTF-8, see ) and then encode it;
• the second one is to convert the UTF-16 to an UTF-8 array of characters and then encode it.

Here are the two possible methods.

To decode the Base64-encoded value back into a String:

Unibabel implements common conversions using this strategy.

Use a TextEncoder polyfill such as TextEncoding (also includes legacy windows, mac, and ISO encodings), TextEncoderLite, combined with a Buffer and a Base64 implementation such as base64-js.

When a native implementation is not available, the most light-weight solution would be to use TextEncoderLite with base64-js. Use the browser implementation when you can.

The following function implements such a strategy. It assumes base64-js imported as . Note that TextEncoderLite only works with UTF-8.

Навигатор по конфигурации базы 1С 8.3

Универсальная внешняя обработка для просмотра метаданных конфигураций баз 1С 8.3.
Отображает свойства и реквизиты объектов конфигурации, их количество, основные права доступа и т.д.
Отображаемые характеристики объектов: свойства, реквизиты, стандартные рекизиты, реквизиты табличных частей, предопределенные данные, регистраторы для регистров, движения для документов, команды, чужие команды, подписки на события, подсистемы.
Отображает структуру хранения объектов базы данных, для регистров доступен сервис «Управление итогами».
Платформа 8.3, управляемые формы. Версия 1.1.0.83 от 24.06.2021

3 стартмани

Building

The directory contains the code for the actual library.
Typing in the toplevel directory will build and .
The first is a single, self-contained object file that you can link into your own project.
The second is a standalone test binary that works similarly to the system utility.

The matching header file needed to use this library is in .

To compile just the «plain» library without SIMD codecs, type:

make lib/libbase64.o

Optional SIMD codecs can be included by specifying the , , ,
, , and/or environment variables.
A typical build invocation on x86 looks like this:

AVX2_CFLAGS=-mavx2 SSSE3_CFLAGS=-mssse3 SSE41_CFLAGS=-msse4.1 SSE42_CFLAGS=-msse4.2 AVX_CFLAGS=-mavx make lib/libbase64.o

AVX2

To build and include the AVX2 codec, set the environment variable to a value that will turn on AVX2 support in your compiler, typically .
Example:

AVX2_CFLAGS=-mavx2 make

The codec will only be used if runtime feature detection shows that the target machine supports AVX2.

SSSE3

To build and include the SSSE3 codec, set the environment variable to a value that will turn on SSSE3 support in your compiler, typically .
Example:

SSSE3_CFLAGS=-mssse3 make

The codec will only be used if runtime feature detection shows that the target machine supports SSSE3.

NEON

This library includes two NEON codecs: one for regular 32-bit ARM and one for the 64-bit AArch64 with NEON, which has double the amount of SIMD registers and can do full 64-byte table lookups.
These codecs encode in 48-byte chunks and decode in massive 64-byte chunks, so they had to be augmented with an uint32/64 codec to stay fast on smaller inputs!

Use LLVM/Clang for compiling the NEON codecs.
The code generation of at least GCC 4.6 (the version shipped with Raspbian and used for testing) contains a bug when compiling , and the generated assembly code is of low quality.
NEON intrinsics are a known weak area of GCC.
Clang does a better job.

NEON support can unfortunately not be portably detected at runtime from userland (the instruction is privileged), so the default value for using the NEON codec is determined at compile-time.
But you can do your own runtime detection.
You can include the NEON codec and make it the default, then do a runtime check if the CPU has NEON support, and if not, force a downgrade to non-NEON with .

These are your options:

1. Don’t include NEON support;
2. build NEON support and make it the default, but build all other code without NEON flags so that you can override the default at runtime with ;
3. build everything with NEON support and make it the default;
4. build everything with NEON support, but don’t make it the default (which makes no sense).

For option 1, simply don’t specify any NEON-specific compiler flags at all, like so:

CC=clang CFLAGS="-march=armv6" make

For option 2, keep your plain, but set the environment variable to a value that will build NEON support.
The line below, for instance, will build all the code at ARMv6 level, except for the NEON codec, which is built at ARMv7.
It will also make the NEON codec the default.
For ARMv6 platforms, override that default at runtime with the flag.
No ARMv7/NEON code will then be touched.

CC=clang CFLAGS="-march=armv6" NEON32_CFLAGS="-march=armv7 -mfpu=neon" make

For option 3, put everything in your and use a stub, but non-empty, .
This example works for the Raspberry Pi 2B V1.1, which has NEON support:

CC=clang CFLAGS="-march=armv7 -mtune=cortex-a7" NEON32_CFLAGS="-mfpu=neon" make

To build and include the NEON64 codec, use as usual to define the platform and set to a nonempty stub.
(The AArch64 target has mandatory NEON64 support.)
Example:

CC=clang CFLAGS="--target=aarch64-linux-gnu -march=armv8-a" NEON64_CFLAGS=" " make

OpenMP

To enable OpenMP on GCC you need to build with . This can be by setting the the environment variable to .

Example:

OPENMP=1 make

This will let the compiler define , which in turn will include the OpenMP optimized into .

By default the number of parallel threads will be equal to the number of cores of the processor.
On a quad core with hyperthreading eight cores will be detected, but hyperthreading will not increase the performance.

To get verbose information about OpenMP start the program with , for instance

OMP_DISPLAY_ENV=VERBOSE test/benchmark

To put a limit on the number of threads, start the program with , for instance

OMP_THREAD_LIMIT=2 test/benchmark

An example of running a benchmark with OpenMP, SSSE3 and AVX2 enabled:

make clean && OPENMP=1 SSSE3_CFLAGS=-mssse3 AVX2_CFLAGS=-mavx2 make && OPENMP=1 make -C test

About

• Character set: Our website uses the UTF-8 character set, so your input data is transmitted in that format. Change this option if you want to convert the data to another character set before encoding. Note that in case of text data, the encoding scheme does not contain the character set, so you may have to specify the appropriate set during the decoding process. As for files, the binary option is the default, which will omit any conversion; this option is required for everything except plain text documents.
• Newline separator: Unix and Windows systems use different line break characters, so prior to encoding either variant will be replaced within your data by the selected option. For the files section, this is partially irrelevant since files already contain the corresponding separators, but you can define which one to use for the «encode each line separately» and «split lines into chunks» functions.
• Encode each line separately: Even newline characters are converted to their Base64 encoded forms. Use this option if you want to encode multiple independent data entries separated with line breaks. (*)
• Split lines into chunks: The encoded data will become a continuous text without any whitespaces, so check this option if you want to break it up into multiple lines. The applied character limit is defined in the MIME (RFC 2045) specification, which states that the encoded lines must be no more than 76 characters long. (*)
• Perform URL-safe encoding: Using standard Base64 in URLs requires encoding of «+», «/» and «=» characters into their percent-encoded form, which makes the string unnecessarily longer. Enable this option to encode into an URL- and filename- friendly Base64 variant (RFC 4648 / Base64URL) where the «+» and «/» characters are respectively replaced by «-» and «_», as well as the padding «=» signs are omitted.
• Live mode: When you turn on this option the entered data is encoded immediately with your browser’s built-in JavaScript functions, without sending any information to our servers. Currently this mode supports only the UTF-8 character set.

(*) These options cannot be enabled simultaneously since the resulting output would not be valid for the majority of applications.Safe and secureCompletely freeDetails of the Base64 encodingDesignExampleMan is distinguished, not only by his reason, but …ManTWFu

Text content	M	a	n
ASCII	77	97	110
Bit pattern	1	1	1	1	1	1	1	1	1	1	1	1
Index	19	22	5	46
Base64-encoded	T	W	F	u

Кодирование/Декодирование С Использованием Кодека Apache Commons

Во-первых, нам нужно определить зависимость commons-codec в pom.xml :

commons-codeccommons-codec1.10

Обратите внимание, что мы можем проверить, были ли выпущены более новые версии библиотеки на. Основным API является класс org.apache.commons.codec.binary.Base64 , который может быть параметризован с помощью различных конструкторов:

Основным API является класс org.apache.commons.codec.binary.Base64 , который может быть параметризован с помощью различных конструкторов:

• Base64(boolean urlSafe) создает API Base64, управляя включенным или выключенным режимом URL-safe.
• Base64 (int lineLength) создает API Base64 в небезопасном для URL режиме и управляет длиной строки (по умолчанию 76).
• Base64(int lineLength, byte[] LineSeparator) создает API Base64, принимая дополнительный разделитель строк, который по умолчанию является CRLF (“\r\n”).

После создания API Base64 и кодирование, и декодирование довольно просты:

String originalInput = "test input";
Base64 base64 = new Base64();
String encodedString = new String(base64.encode(originalInput.getBytes()));

Метод decode() класса Base64 возвращает декодированную строку:

String decodedString = new String(base64.decode(encodedString.getBytes()));

Другим простым вариантом является использование статического API Base64 |/вместо создания экземпляра:

String originalInput = "test input";
String encodedString = new String(Base64.encodeBase64(originalInput.getBytes()));
String decodedString = new String(Base64.decodeBase64(encodedString.getBytes()));

More Info and Resources

The Base 64 Alphabet

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

RFC’s

• RFC 1866 — Hypertext Markup Language — 2.0
• RFC 2045 — Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies
• RFC 2046 — Definition of media types
• RFC 2077 — Model top-level media type
• RFC 2396 — Uniform Resource Identifiers (URI): Generic Syntax
• RFC 2397 — The «data» URL scheme
• RFC 3023 — Media types based on XML
• RFC 4648 — The Base16, Base32, and Base64 Data Encodings
• RFC 6657 — Update to MIME regarding «charset» Parameter Handling in Textual Media Types
• RFC 5988 — Web Linking

Type image

GIF image; Defined in RFC 2045 and RFC 2046

JPEG JFIF image; Defined in RFC 2045 and RFC 2046

JPEG JFIF image; Associated with Internet Explorer; Listed in ms775147(v=vs.85) — Progressive JPEG, initiated before global browser support for progressive JPEGs (Microsoft and Firefox).

Portable Network Graphics; Registered, Defined in RFC 2083

SVG vector image; Defined in SVG Tiny 1.2 Specification Appendix M

Tag Image File Format (only for Baseline TIFF); Defined in RFC 3302

ICO image; Registered

Misc

• Image to data URI convertor
• : Your one-stop HTML5 spot for all things Data URL
• The data: URI kitchen
• php: data://
• Using Data URLs Effectively with Cascading Style Sheets
• getID3: PHP script that extracts useful information from MP3s & other multimedia file formats:

Introduction

A very popular way to encode binary data is Base64. The basis of this is an
encoding table. As you might expect, there are 64 total characters that go into
the tale. There are multiple implementations of base64 with slight differences.
They are all the same except for the last two characters and line ending
requirements. The first 62 characters are always
“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789”. PEM and MIME
encoding are the most common and use “+/” as the last two characters. PEM and
MIME may use the same characters but they have different maximum line lengths.
I’m going to implement PEM/MINE but I’m not going to implement new line
support.

Answers to Questions (FAQ)

How to encrypt using Base64 coding

Base 64 encoding requires a binary input. For a text, the values depend on its coding (often ASCII or Unicode).

Example: To code DCODE that is written 01100100 01000011 01101111 01100100 01100101 in binary (ASCII code)

Base 64 Coding starts by splitting the binary code in groups of 6 bits, filling it with if needed.

Example: Split as 011001 000100 001101 101111 011001 000110 0101 (+00)

Each group of 6 bits has a base 10 value, it corresponds to a character in the Base 64 alphabet (start at 0): ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

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

Example: The conversion from 011001 to base 10 is 25 and in the alphabet 25 is Z, 000100 is 4, etc. to obtain the characters numbered 25 4 13 47 25 6 20 or the coded message: ZENvZGU

Base 64 only works with groups of 4 characters, if needed, fill with =.

Example: Finally ZENvZGU (that had 7 chars) becomes ZENvZGU= (8 chars, a multiple of 4) which is the final base64 encoded message.

How to decrypt Base64 coding

Decryption consists in finding back values of the letters in the Base64 alphabet: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ (equal sign = is ignored)

Example: A coded message is YjY0, corresponding values of Y,j,Y,0 in the alphabet are: 24,35,24,52

Values are converted to 6-bit binary.

Example: 24 is converted 011000, 35 = 100011, etc. the decoded binary message is 011000100011011000110100

Base64 decoding is then complete. Binary message is then read using the desired coding system (ASCII, Unicode, etc.)

Example: In ASCII, 01100010,00110110,00110100 corresponds to the plain text b,6,4

How to recognize a Base64 ciphertext?

The message is theoretically composed of a number of characters multiple of 4. To this end, the presence of characters = (equal) at the end of the message is a big clue.

The message has a maximum of 65 distinct characters (and possibly space or line break). By default it is: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=

The Usenet network used Base64 to transfer files, any indication referring to it is a clue.

Several signatures of users or sites are associated with Base64 as code 6.0 (94/25) or the .b64 extensions

Base64 is sometimes used to store passwords that cannot be encrypted, in order to prevent them from being displayed in plain text, as in the XML configuration files of certain software (Databases, FTP, Filezilla, etc.)

Why using Base64?

A Base64 encoded message will only contain printable ASCII characters ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=

This property allows transmitting any data on systems originally designed to transmit only text (without having to worry about the initial encoding or how the characters will appear on the screen of the recipient of the message)

Does Base64 always ends with ==?

No, as indicated in the encoding principle, the presence of characters = (equal) is not mandatory, it occurs approximately 3 times out of 4.

Why is data size increasing?

In Base64, 4 ASCII characters are used to code 3 bytes. Volume is increased by 33%.

Example: Base64 (6 characters) is coded QmFzZTY0 (8 characters or +33%)

base64 (no uppercase) is coded YmFzZTY0

Why is Base64 named like this?

The base64 uses a sixty-four character alphabet to code any binary string (in base 2), so it is a mathematical conversion to base 64.

What is Base64URL?

Base64URL is a variant of Base64 suitable for URLs (http). Characters 62 + and 63 can cause problems with URL, they can be replaced by respectively — and _. Furthermore, the equal = sign is deleted.

Benchmarks

For all benchmarks see results.

Performance gain depends, among a lot of other things, on the workload size, so here no table will with superior results will be shown.

Direct encoding to a string is for small inputs slower than (has less overhead, and can write to string-buffer in a direct way).
But the larger the workload, the better this library works. For data-length of 1000 speedup can be ~5x with AVX2 encoding.

Direct decoding from a string is generally (a lot) faster than , also depending on workload size, but in the benchmark the speedup is from 1.5 to 12x.

For UTF-8 encoding and decoding
speedups for input-length 1000 can be in the height of 5 to 12x.

Note: please measure / profile in your real usecase, as this are just micro-benchmarks.

Usage

Basically the entry to encoder / decoder is for base64, and for base64Url.

See demo for further examples.

Encoding

byte[] guid = Guid.NewGuid().ToByteArray();

string guidBase64     = Base64.Default.Encode(guid);
string guidBases64Url = Base64.Url.Encode(guid);

or based (for UTF-8 encoded output):

int guidBase64EncodedLength = Base64.Default.GetEncodedLength(guid.Length);
Span<byte> guidBase64UTF8   = stackalloc byte;
OperationStatus status      = Base64.Default.Encode(guid, guidBase64UTF8, out int consumed, out int written);

int guidBase64UrlEncodedLength = Base64.Url.GetEncodedLength(guid.Length);
Span<byte> guidBase64UrlUTF8   = stackalloc byte;
status                         = Base64.Url.Encode(guid, guidBase64UrlUTF8, out consumed, out written);

Decoding

Guid guid = Guid.NewGuid();

string guidBase64    = Convert.ToBase64String(guid.ToByteArray());
string guidBase64Url = guidBase64.Replace('+', '-').Replace('/', '_').TrimEnd('=');

byte[] guidBase64Decoded    = Base64.Default.Decode(guidBase64);
byte[] guidBase64UrlDecoded = Base64.Url.Decode(guidBase64Url);

or based:

int guidBase64DecodedLen    = Base64.Default.GetDecodedLength(guidBase64);
int guidBase64UrlDecodedLen = Base64.Url.GetDecodedLength(guidBase64Url);

Span<byte> guidBase64DecodedBuffer    = stackalloc byte;
Span<byte> guidBase64UrlDecodedBuffer = stackalloc byte;

OperationStatus status = Base64.Default.Decode(guidBase64, guidBase64DecodedBuffer, out int consumed, out int written);
status                 = Base64.Url.Decode(guidBase64Url, guidBase64UrlDecodedBuffer, out consumed, out written);

Buffer chains

Buffer chains are handy when for encoding / decoding

• very large data
• data arrives is chunks, e.g. by reading from a (buffered) stream / pipeline
• the size of data is initially unknown
• …

var rnd         = new Random();
Span<byte> data = new byte;
rnd.NextBytes(data);

// exact length could be computed by Base64.Default.GetEncodedLength, here for demo exzessive size
Span<char> base64 = new char;

OperationStatus status = Base64.Default.Encode(data.Slice(, 400), base64, out int consumed, out int written, isFinalBlock: false);
status                 = Base64.Default.Encode(data.Slice(consumed), base64.Slice(written), out consumed, out int written1, isFinalBlock: true);

base64 = base64.Slice(, written + written1);

Span<byte> decoded = new byte;
status             = Base64.Default.Decode(base64.Slice(, 100), decoded, out consumed, out written, isFinalBlock: false);
status             = Base64.Default.Decode(base64.Slice(consumed), decoded.Slice(written), out consumed, out written1, isFinalBlock: true);

decoded = decoded.Slice(, written + written1);

ReadOnlySequence / IBufferWriter

Encoding / decoding with and can be used together with .

var pipeOptions = PipeOptions.Default;
var pipe        = new Pipe(pipeOptions);

var rnd  = new Random(42);
var data = new byte;
rnd.NextBytes(data);

pipe.Writer.Write(data);
await pipe.Writer.CompleteAsync();

ReadResult readResult = await pipe.Reader.ReadAsync();

var resultPipe = new Pipe();
Base64.Default.Encode(readResult.Buffer, resultPipe.Writer, out long consumed, out long written);
await resultPipe.Writer.CompleteAsync();

About

• Character set: Our website uses the UTF-8 character set, so your input data is transmitted in that format. Change this option if you want to convert the data to another character set before encoding. Note that in case of text data, the encoding scheme does not contain the character set, so you may have to specify the appropriate set during the decoding process. As for files, the binary option is the default, which will omit any conversion; this option is required for everything except plain text documents.
• Newline separator: Unix and Windows systems use different line break characters, so prior to encoding either variant will be replaced within your data by the selected option. For the files section, this is partially irrelevant since files already contain the corresponding separators, but you can define which one to use for the «encode each line separately» and «split lines into chunks» functions.
• Encode each line separately: Even newline characters are converted to their Base64 encoded forms. Use this option if you want to encode multiple independent data entries separated with line breaks. (*)
• Split lines into chunks: The encoded data will become a continuous text without any whitespaces, so check this option if you want to break it up into multiple lines. The applied character limit is defined in the MIME (RFC 2045) specification, which states that the encoded lines must be no more than 76 characters long. (*)
• Perform URL-safe encoding: Using standard Base64 in URLs requires encoding of «+», «/» and «=» characters into their percent-encoded form, which makes the string unnecessarily longer. Enable this option to encode into an URL- and filename- friendly Base64 variant (RFC 4648 / Base64URL) where the «+» and «/» characters are respectively replaced by «-» and «_», as well as the padding «=» signs are omitted.
• Live mode: When you turn on this option the entered data is encoded immediately with your browser’s built-in JavaScript functions, without sending any information to our servers. Currently this mode supports only the UTF-8 character set.

(*) These options cannot be enabled simultaneously since the resulting output would not be valid for the majority of applications.Safe and secureCompletely freeDetails of the Base64 encodingDesignExampleMan is distinguished, not only by his reason, but …ManTWFu

Text content	M	a	n
ASCII	77	97	110
Bit pattern	1	1	1	1	1	1	1	1	1	1	1	1
Index	19	22	5	46
Base64-encoded	T	W	F	u