Base64-Kodierungsbibliothek mit Arduino
Base64 ist ein Codierungssystem, das 64 Symbole verwendet, die in Nachrichten gruppiert sind, deren Länge ein Vielfaches von vier ist. Diese Nachrichten (Datenpakete) werden ggf. mit einem Pluszeichen (also 65) vervollständigt, oft auch mit dem Gleichheitszeichen (=), wenn die verschlüsselte Nutzinformation eine kürzere Länge ergibt.
Mit 64 Zeichen können Sie mit den 10 Zahlen sowie Groß- und Kleinbuchstaben (26+26) des Codes arbeiten ASCIIDas Problem besteht darin, dass es beispielsweise 62 eindeutige Symbole plus zwei gibt, die in verschiedenen Implementierungen variieren. Obwohl manchmal mit dem Ausdruck „Zeichen“ bezeichnet ASCII druckbare", in Wirklichkeit sind es diejenigen, die von dem Code 32 (Leerzeichen) bis 126 (~) reichen, den 95 wirklich druckbaren.
Die Implementierung der Codierung Base64 am häufigsten verwendet, das von PEM, das auch von verwendet wird MIME, arbeiten Sie mit den zusätzlichen „+“- und „/“-Zeichen und dem „=“-Zeichen zum Auffüllen, sodass die Pakete ein Längenvielfaches von vier haben. Die Buchstaben A–Z belegen die Positionen 0–25, die Buchstaben a–z belegen die Positionen 26–51, die Zahlen 0–9 belegen die Positionen 52–61, das Pluszeichen (+) die Positionen 62 und Position 63 wird durch den Schrägstrich (/) belegt.
Die Art und Weise, Daten im Format darzustellen Base64 besteht darin, aus den Originaldaten Gruppen von zu entnehmen 6 Bit die mit dem entsprechenden Code dargestellt werden. Sollten noch Bits übrig sein, werden diese rechts mit Nullen aufgefüllt. Wenn die resultierende Anzahl an Codes kein Vielfaches von vier ist, wird sie rechts mit Gleichheitszeichen ausgefüllt.
Das folgende Bild zeigt die Codierung ASCII eines Textes ("Ohm") und die Art und Weise, wie er umgewandelt wird Base64. Da es 7 Symbole gibt, müsste die letzte Nachricht am Ende mit einem Gleichheitszeichen gefüllt werden. Man könnte sagen, dass der Text „Ohm“ in ist ASCII entspricht „b2htaW8=" in Base64.
Spezifische Verwendungszwecke der Codierung Base64 Sie schreiben in der Regel auch eine maximale Leitungslänge vor. Die Umsetzung MIME Beschränkt jede Zeile auf 76 Zeichen. Normalerweise werden die Zeilen durch einen Zeilenendecode (CR, dargestellt durch den Wert 0x0D in) getrennt ASCII) und eine weitere neue Zeile (NL, die dem Code entspricht ASCII 0x0A).
Die Unannehmlichkeiten, die bei der Implementierung der Codierung entstehen Base64 auf einem Gerät mit wenigen Ressourcen, wie es oft der Fall ist bei einem Mikrocontroller ist, dass Sie codieren müssen, sobald die Informationen eintreffen, oder mit einem puffern Mindestens, was auch die Bereitstellung eines Systems erfordert, das anzeigt, dass das Ende der ursprünglichen Nachricht erreicht wurde, beispielsweise durch Hinzufügen eines speziellen Codes oder durch die Verwendung eines Pins, dessen Pegel (synchronisiert mit dem Empfang) den Status der Nachricht anzeigt.
Der folgende Beispielcode ist a Bibliothek für Arduino zum Codieren in Base64 was mit beiden Kriterien umgesetzt wird: Kodierung der ankommenden Informationen (ohne a puffern) und warten Sie, bis ein Warnsignal erklingt.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
//base64.h
#include <string.h> // memcpy/strncpy
#define LONGITUD_LINEA 76
#define MASCARA_B64 0B00111111
#define ULTIMO_CODIGO_BASE64 64 // 64 caracteres más el signo igual (empezando a contar desde cero)
#define MAXIMA_LONGITUD_RESULTADO 6 // Máximo número de caracteres del resultado parcial de la codificación. Puede ser 1 si no se ha llegado al final de un bloque (2 bytes en el original, 4 en la conversión), 2 si se ha llegado al final de un bloque, 3 si no se ha llegado al final de un bloque pero se supera la longitud máxima de la línea, 4 si se llega al final de un bloque y se supera la longitud máxima de la línea, 5 si hay que rellenar con un signo igual o 6 si hay que rellenar con dos signos igual
class Base64
{
private:
unsigned char simbolo_base64[ULTIMO_CODIGO_BASE64+1]; // Espacio para la codificación Base64, el relleno (=) una terminación en \0
unsigned int numero_valor; // Posición (empezando en cero) que ocupa el valor que se desea convertir en el mensaje completo original
unsigned int numero_codigo; // Posición del último código calculado. Podría limitarse al ancho de la línea (LONGITUD_LINEA, 76 caracteres) pero usando un contenedor alto se podría implementar también una cuenta estadística
unsigned char resto_base64; // Último resto obtenido al calcular el último código
unsigned char resultado[MAXIMA_LONGITUD_RESULTADO+1]; // Resultado de la conversión actual. Si es terminal puede incluir el caracter 65 (=) una o dos veces
unsigned char contador_caracteres_resultado=0;
void acumular_resultado(unsigned char valor);
public:
Base64();
~Base64();
void iniciar_conversion();
unsigned char *convertir(unsigned char valor_original, bool terminar_conversion);
unsigned char *convertir(unsigned char valor_original);
unsigned char *terminar();
};
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
//base64.cpp
#include “base64.h”
Base64::Base64() // Constructor
{
memcpy(simbolo_base64,“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=”,ULTIMO_CODIGO_BASE64+1);
iniciar_conversion();
}
Base64::~Base64() // Destructor
{
}
void Base64::iniciar_conversion()
{
numero_valor=0;
numero_codigo=0;
resto_base64=0;
}
unsigned char *Base64::convertir(unsigned char valor_original, bool terminar_conversion) // Valor que se desea convertir a Base64
{
convertir(valor_original);
if(terminar_conversion)
{
terminar();
}
return resultado;
}
unsigned char *Base64::convertir(unsigned char valor_original) // Valor que se desea convertir a Base64
{
unsigned char desplazamiento;
contador_caracteres_resultado=0;
acumular_resultado((valor_original>>(2+(numero_valor%3)*2))|resto_base64);
desplazamiento=4–(numero_valor%3)*2;
resto_base64=(valor_original&(MASCARA_B64>>desplazamiento))<<desplazamiento;
if(((numero_codigo+1)%4==0))
{
acumular_resultado(resto_base64);
resto_base64=0;
}
numero_valor++;
resultado[contador_caracteres_resultado]=0;
return resultado;
}
unsigned char *Base64::terminar()
{
if(numero_codigo%4)
{
acumular_resultado(resto_base64);
while(numero_codigo%4)
{
acumular_resultado(ULTIMO_CODIGO_BASE64);
}
}
resultado[contador_caracteres_resultado]=0;
iniciar_conversion();
return resultado;
}
void Base64::acumular_resultado(unsigned char valor)
{
numero_codigo++;
resultado[contador_caracteres_resultado++]=simbolo_base64[valor];
if((numero_codigo%LONGITUD_LINEA)==0)
{
resultado[contador_caracteres_resultado++]=13; // CR “\r”
resultado[contador_caracteres_resultado++]=10; // LF “\n”
}
}
|
Der grundlegende Teil der Codeberechnung Base64 Dies geschieht mit dem Ausdruck:
(valor_original>>(2+(numero_valor%3)*2))|resto_base64
und die Berechnung des Restes mit dem Ausdruck:
(valor_original&(MASCARA_B64>>desplazamiento))<<desplazamiento,
siendo desplazamiento ein Wert, der mit dem Ausdruck berechnet wird:
4-(numero_valor%3)*2
Der Prozess zum Erhalten dieser Ausdrücke besteht darin, die Berechnung jedes der vier Codes zu verallgemeinern Base64 die sich aus der Darstellung von drei Bytes des Originalwerts ergeben.
Base64=((byte_1>>2)|resto)&0b00111111 |
resto=(byte_1&0b00000011)<<4 |
Base64=((byte_2>>4)|resto)&0b00111111 |
resto=(byte_2&0b00001111)<<2 |
Base64=((byte_3>>6)|resto)&0b00111111 |
resto=(byte_3&0b00111111)<<0 |
Base64=((byte_3>>0)|resto)&0b00111111 |
resto=(byte_3&0b00111111)<<0 |
Mit dem Text Base64 Der obige Pseudocode bezieht sich auf den Code in Base64 das wird berechnet. Der Ausdruck wurde verwendet byte_n bezieht sich auf das n-te Byte, das codiert wird. Der Text resto stellt die verbleibenden Bits des zu kodierenden Bytes dar. Zu Beginn der Berechnung wird davon ausgegangen, dass der Rest Null ist
Aus Gründen der Übersichtlichkeit wurde im vorherigen Pseudocode die 6-Bit-Maske in die Berechnung aller Codes einbezogen, obwohl nur der letzte von ihnen bestimmt werden muss, da die anderen rotiert werden, sodass immer die beiden meisten Bits verloren gehen. bedeutsam.
Wie man sehen kann, besteht der vierte Code ausschließlich aus Resten und es besteht keine Notwendigkeit, nachträglich einen Rest zu berechnen. Es müssen daher nur drei Schritte durchgeführt werden, einer pro codiertem Byte. Es ist wichtig zu bedenken, dass, wenn ein drittes Byte in einem Paket nicht codiert wäre, der letzte Code rechts mit Nullen aufgefüllt werden müsste. Base64 erhalten.
Um es zu verallgemeinern: Die Rechtsdrehung des Ausdrucks, der den Code berechnet Base64 kann dargestellt werden als 2+(numero_byte%3)*2 so dass sich der Teil in den Klammern von Null auf Zwei drehen würde, was bei jedem Schritt 2, 4 und 6 ergibt. Natürlich ist das nicht die einzige Möglichkeit, es zu verallgemeinern, aber ich habe mich wegen der Funktionalität und vor allem wegen der Klarheit für diese entschieden. Da die Maske (AND) nur im vierten Code notwendig war und bereits gesehen wurde, dass es nicht notwendig ist, sie zu berechnen (es ist alles Rest), ist sie zur Vereinfachung nicht im endgültigen Ausdruck enthalten, obwohl wir uns daran erinnern müssen dass vom Typ der verwendeten Daten (Byte) nur die 6 niedrigstwertigen Bits übernommen werden.
Die Linksdrehung des Restes kann analog zur vorherigen verallgemeinert werden. Es ist auch zu erkennen, dass die angewendete Maske (AND) die gleiche Bitrotation erfährt, jedoch in die entgegengesetzte Richtung. Aus diesem Grund wird die Verschiebung mit berechnet 4-(numero_valor%3)*2 bevor es in dem Sinne angewendet wird, der jedem Teil des Ausdrucks entspricht.
Das folgende Beispiel zeigt, wie die Bibliothek zum Codieren einer Textzeichenfolge verwendet wird (denken Sie daran Base64 kann für jeden Datensatz verwendet werden, z. B. für ein Bild). Im folgenden Code gibt es einige Details, die es zu klären gilt. Zunächst wurde ein spezielles Symbol (das ~-Symbol) verwendet, um das Ende des Textes anzuzeigen, anstelle eines Hardwaresignals oder der Angabe der Textlänge. Logischerweise kann dieses Symbol nicht Teil der codierten Daten sein.
Der zweite ebenso wichtige wie offensichtliche Punkt, der berücksichtigt werden muss, ist, dass der Decoder am Zielort wissen muss, wie die ihn erreichenden Informationen dargestellt werden. Der Text enthält Zeichen, die nicht zum Satz gehören ASCII ausdruckbar (von 32 bis 126), zum Beispiel Buchstaben mit Akzent. Arduino wird zwei Bytes verwenden (UTF-8), um diese Zeichen darzustellen. Das Übliche kann nicht einfach verwendet werden \0 als Textabschluss, da in vielen Fällen das erste Byte, mit dem ein Zeichen dargestellt wird, genau Null ist.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
#include “base64.h”
char texto_prueba[]=“La bella y graciosa moza marchose a lavar la ropa.\nLa mojó en el arroyuelo y cantando la lavó.\nLa frotó sobre una piedra, la colgó de un abedul.\nDespués de lavar la ropa, la niña se fue al mercado.\nUn pastor vendía ovejas pregonando a viva voz:\nved qué oveja, ved qué lana, ved qué bestia, qué animal.\nLa niña la vio muy flaca, sin embargo le gustó.\nYo te pago veinte escudos y no discutamos más.\nVuelve la niña cantando muy contenta con su oveja.\nCuando llegaron al bosque la ovejita se escapó.\nLa niña desesperada arrojose encima de ella.\nVelozmente y con destreza aferrola por detrás.\nLlegaba por el camino jinete de altivo porte.\nDescendió de su caballo y a la niña le cantó…~”;
char *resultado;
Base64 base64;
void setup()
{
Serial.begin(9600);
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega16U4__) // ¿Es un Arduino Leonardo (ATmega32U4)?
while(!Serial){}; // Esperar a Arduino Leonardo
#endif
// Mostrar el texto original
unsigned int contador=0;
while(texto_prueba[contador]!=‘~’)
{
//Serial.println(String(texto_prueba[contador])+”=”+String(texto_prueba[contador],DEC));
Serial.print(String(texto_prueba[contador]));
contador++;
}
Serial.println(“\n”);
// Mostrar el texto codificado en Base64
contador=0;
while(texto_prueba[contador]!=‘~’)
{
resultado=base64.convertir(texto_prueba[contador],texto_prueba[contador+1]==‘~’);
byte contador_resultado=0;
while(resultado[contador_resultado]>0)
{
Serial.print(String(resultado[contador_resultado]));
contador_resultado++;
}
contador++;
}
}
void loop()
{
}
|
Zeile 26 des vorherigen Beispiels zeigt die Verwendung von Bibliothek für Arduino zum Codieren in Base64. Es ist lediglich die Angabe der Methode erforderlich convertir jedes Byte, das Sie kodieren möchten und optional, ob es das letzte ist oder, falls nicht, stoppen Sie die Konvertierung mit der Methode terminar wenn du das Ende erreichst.
Wie im Screenshot unten zu sehen ist, ist das Beispielprogramm der Bibliothek für Arduino zum Codieren in Base64 Zeigt zunächst den zu kodierenden Text an Base64, in diesem Fall der Beginn des berühmten Liedes der Riesen Les Luthiersund anschließend das Ergebnis der Codierung in Base64 Verwenden der Formatzeilenlänge MIME.
Geben Sie Anmerkung