Base 64 es un esquema de codificación que convierte datos binarios en formato de texto para que los datos textuales codificados puedan transportarse fácilmente a través de la red sin corrupción y sin pérdida de datos. Base64 se usa comúnmente en varias aplicaciones, incluido el correo electrónico a través de MIME y el almacenamiento de datos complejos en XML.
El problema con el envío de datos binarios normales a una red es que los protocolos subyacentes pueden malinterpretar los bits, producir datos incorrectos en el Node receptor y es por eso que usamos este código.
¿Por qué base 64?
El texto resultante después de codificar nuestros datos tiene esos caracteres que están ampliamente presentes en muchos conjuntos de caracteres, por lo que hay menos posibilidades de que los datos se dañen o modifiquen.
¿Cómo convertir al formato base 64?
El conjunto de caracteres en base64 es
char_set = "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz0123456789+/" // 64 characters
Idea básica
Tomemos un ejemplo. Tenemos que codificar la string «MENON» en formato base64. Llamemos a «MENON» como input_str , sobre el conjunto de caracteres base64 («ABC..+/») como char_set y la string codificada resultante como res_str .
- Tome 3 caracteres de input_str, es decir, «MEN», ya que cada tamaño de carácter es de 8 bits, tendremos (8 * 3) 24 bits con nosotros.
- Agruparlos en un bloque de 6 bits cada uno (24/6 = 4 bloques). (¿por qué 6?) porque 2^6 = 64 caracteres, con 6 bits podemos representar cada carácter en char_set .
- Convierta cada bloque de 6 bits a su valor decimal correspondiente. El valor decimal obtenido es el índice del carácter codificado resultante en char_set .
- Entonces, por cada 3 caracteres de input_str , recibiremos 4 caracteres en res_str .
- ¿Qué sucede si nos quedan menos de 3 caracteres en input_str , es decir, «ON»? Tenemos 16 bits y los bloques serán 16/6 = 2 bloques. Los 4 bits más a la derecha no harán un bloque adecuado (1 bloque = 6 bits), por lo que agregaremos ceros al lado derecho del bloque para que sea un bloque adecuado, es decir, se agregarán 2 ceros a la derecha. Ahora tenemos 3 bloques adecuados, encuentre el valor decimal correspondiente de cada bloque para obtener el índice.
- Dado que había menos de 3 caracteres («ON») en input_str , agregaremos «=» en res_str. por ejemplo, «ON» aquí 3 – 2 = 1 relleno de «=» en res_str .
Ejemplo
1. Convierta “MENON” a su formato de estado binario (8 bits). Tome cada carácter de la string y escriba su representación binaria de 8 bits.
Valores ASCII de caracteres en string a codificar
M : 77 (01001101), E : 69 (01000101), N : 78 (01001110), O : 79 (01001111), N : 78 (01001110)
Los datos binarios resultantes de la string anterior son:
01001101 01000101 01001110 01001111 01001110
2. Comenzando desde la izquierda, haga bloques de 6 bits hasta cubrir todos los bits
BIT-STREAM:
(010011) (010100) (010101) (001110) (010011) (110100) (1110)
3. Si el bloque más a la derecha tiene menos de 6 bits, simplemente agregue ceros a la derecha de ese bloque para que sea de 6 bits. Aquí, en el ejemplo anterior, tenemos que agregar 2 ceros para que sea 6.
BIT-STREAM:
(010011) (010100) (010101) (001110) (010011) (110100) (111000)
Observe los ceros en negrita.
4. Tome 3 caracteres de input_str («MEN»), es decir, 24 bits y encuentre el valor decimal correspondiente (índice para char_set).
BLOQUES :
INDEX --> (010011) : 19, (010100) : 20, (010101) : 21, (001110) : 14 char_set[19] = T, char_set[20] = U, char_set[21] = V, char_set[14] = O
Por lo tanto, nuestro input_str = «MEN» se convertirá en una string codificada «TUVO».
5. Tome los caracteres restantes («ON»). Tenemos que rellenar la string codificada resultante con 1 “=” ya que el número de caracteres es inferior a 3 en input_str. (3 – 2 = 1 relleno)
BLOQUES:
INDEX --> (010011) : 19 (110100) : 52 (111000) : 56 char_set[19] = T char_set[52] = 0 char_set[56] = 4 So our input_str = "ON" will be converted to encoded string "T04=".
Ejemplos:
Input : MENON // string in ASCII Output :TUVOT04= // encoded string in Base 64. Input : geeksforgeeks Output : Z2Vla3Nmb3JnZWVrcw==
Podemos usar operadores bit a bit para codificar nuestra string. Podemos tomar un valor entero «val» (generalmente 4 bytes en la mayoría de los compiladores) y almacenar todos los caracteres de input_str (3 a la vez) en val. Los caracteres de input_str se almacenarán en val
en forma de bits. Usaremos (operador O) para almacenar los caracteres y (IZQUIERDA – MAYÚS) por 8 para
dejar espacio para otros 8 bits. De manera similar, usaremos (DERECHA – MAYÚS) para recuperar bits del valor 6 a la vez
y encontrar el valor de los bits haciendo & con 63 (111111), lo que nos dará el índice. Entonces podemos obtener nuestro carácter resultante simplemente yendo a ese índice de char_set.
C++
// C++ program to encode an ASCII
// string in Base64 format
#include <iostream>
using namespace std;
#define SIZE 1000
// Takes string to be encoded as input
// and its length and returns encoded string
char* base64Encoder(char input_str[], int len_str)
{
// Character set of base64 encoding scheme
char char_set[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
// Resultant string
char *res_str = (char *) malloc(SIZE * sizeof(char));
int index, no_of_bits = 0, padding = 0, val = 0, count = 0, temp;
int i, j, k = 0;
// Loop takes 3 characters at a time from
// input_str and stores it in val
for (i = 0; i < len_str; i += 3)
{
val = 0, count = 0, no_of_bits = 0;
for (j = i; j < len_str && j <= i + 2; j++)
{
// binary data of input_str is stored in val
val = val << 8;
// (A + 0 = A) stores character in val
val = val | input_str[j];
// calculates how many time loop
// ran if "MEN" -> 3 otherwise "ON" -> 2
count++;
}
no_of_bits = count * 8;
// calculates how many "=" to append after res_str.
padding = no_of_bits % 3;
// extracts all bits from val (6 at a time)
// and find the value of each block
while (no_of_bits != 0)
{
// retrieve the value of each block
if (no_of_bits >= 6)
{
temp = no_of_bits - 6;
// binary of 63 is (111111) f
index = (val >> temp) & 63;
no_of_bits -= 6;
}
else
{
temp = 6 - no_of_bits;
// append zeros to right if bits are less than 6
index = (val << temp) & 63;
no_of_bits = 0;
}
res_str[k++] = char_set[index];
}
}
// padding is done here
for (i = 1; i <= padding; i++)
{
res_str[k++] = '=';
}
res_str[k] = '\0';
return res_str;
}
// Driver code
int main()
{
char input_str[] = "MENON";
int len_str;
// calculates length of string
len_str = sizeof(input_str) / sizeof(input_str[0]);
// to exclude '\0' character
len_str -= 1;
cout <<"Input string is : "<< input_str << endl;
cout <<"Encoded string is : "<< base64Encoder(input_str, len_str)<< endl;
return 0;
}
// This code is contributed by shivanisinghss2110
C
// C program to encode an ASCII
// string in Base64 format
#include <stdio.h>
#include <stdlib.h>
#define SIZE 1000
// Takes string to be encoded as input
// and its length and returns encoded string
char* base64Encoder(char input_str[], int len_str)
{
// Character set of base64 encoding scheme
char char_set[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
// Resultant string
char *res_str = (char *) malloc(SIZE * sizeof(char));
int index, no_of_bits = 0, padding = 0, val = 0, count = 0, temp;
int i, j, k = 0;
// Loop takes 3 characters at a time from
// input_str and stores it in val
for (i = 0; i < len_str; i += 3)
{
val = 0, count = 0, no_of_bits = 0;
for (j = i; j < len_str && j <= i + 2; j++)
{
// binary data of input_str is stored in val
val = val << 8;
// (A + 0 = A) stores character in val
val = val | input_str[j];
// calculates how many time loop
// ran if "MEN" -> 3 otherwise "ON" -> 2
count++;
}
no_of_bits = count * 8;
// calculates how many "=" to append after res_str.
padding = no_of_bits % 3;
// extracts all bits from val (6 at a time)
// and find the value of each block
while (no_of_bits != 0)
{
// retrieve the value of each block
if (no_of_bits >= 6)
{
temp = no_of_bits - 6;
// binary of 63 is (111111) f
index = (val >> temp) & 63;
no_of_bits -= 6;
}
else
{
temp = 6 - no_of_bits;
// append zeros to right if bits are less than 6
index = (val << temp) & 63;
no_of_bits = 0;
}
res_str[k++] = char_set[index];
}
}
// padding is done here
for (i = 1; i <= padding; i++)
{
res_str[k++] = '=';
}
res_str[k] = '\0;';
return res_str;
}
// Driver code
int main()
{
char input_str[] = "MENON";
int len_str;
// calculates length of string
len_str = sizeof(input_str) / sizeof(input_str[0]);
// to exclude '\0' character
len_str -= 1;
printf("Input string is : %s\n", input_str);
printf("Encoded string is : %s\n", base64Encoder(input_str, len_str));
return 0;
}
Input string is : MENON Encoded string is : TUVOT04=
Complejidad de tiempo: O(2 * N) insertando bits en val + recuperando bits de val
Complejidad espacial : O(N) donde N es el tamaño de la string de entrada
Ejercicio: Implementar un decodificador base 64
Este artículo es una contribución de Arshpreet Soodan . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA