¬ Home » Tutorials » Base64-Kodierung Feedback | Druckansicht

Tutorial: Base64-Kodierung

Autor: Alexander Kopatz Download: Beispielprojekt - Base64-Kodierung

Einführung

Dieses Beispiel veranschaulicht die Umwandlung einer Zeichenfolge in die Base64-Kodierung und zurück. Die Base64-Kodierung dient dabei der Umwandlung eines Datenstroms auf 8-Bit-Basis in eine solche auf 6-Bit-Basis. Für die Darstellung der Informationen je Zeichen werden somit lediglich 6 statt 8 Bits verwendet. Um Missverständnisse im Hinblick auf die Bezeichnung 'Kodierung' zu vermeiden sei angemerkt, dass es sich bei dieser Umwandlung jedoch nicht um eine Verschlüsselung handelt, sondern lediglich um eine Übertragung der Daten von einer Darstellungsform in ein anderes Darstellungsformat. Hinzu kommt, dass der Datenstrom im Ergebnis nicht etwa verkürzt wird, sondern tatsächlich um etwa 1/3 anschwillt.

Verwendung

Somit stellt sich die Frage, welchem Zweck eine solche Umwandlung dient. Die Daten werden weder verschlüsselt, noch wird das Datenvolumen reduziert. Die Erklärung findet sich in der Entwicklung der Computersystem. In früheren Tagen war Arbeits- und Festplattenspeicher rar und so galt das Einsparen von Speicherplatz als wichtige Tugend. Dies galt auch für die verwendeten Zeichensätze. Eine noch heute bedeutsamer Zeichensatz, welcher im Jahre 1963 entwickelt wurde, ist der sogenannte ASCII-Zeichensatz (American Standard Code for Information Interchange). Der ASCII-Code ist ein 7-Bit Code und umfasst damit insgesamt 128 kodierbare Zeichen. Von diesen 128 Zeichen sind jedoch nicht alle darstellbar, bei vielen der Zeichen handelt es sich um reine Steuerzeichen (33 Stück) die nur für die interne Verwendung im System und die Formatierung reserviert sind. Im Laufe der Zeit trug es sich zu, dass eine Vielzahl an Computersysteme unabhängig von Ihrem Betriebssystem zur Interpretierung des ASCII-Zeichensatzes in der Lage waren (und sind). Dies wiederum führte dazu, dass auch andere wichtige Standards, wenigstens in ihrer Urform die Verwendung eines 7-Bit Zeichensatzes voraussetzen oder doch immerhin unterstützten. So auch beispielsweise das SMTP-Protokoll aus dem Jahre 1982. Das SMTP-Protokoll (Simple Mail Transfer Protocol) dient auch heute, mit diversen Modifikationen, noch als Basis für den Versand von Emails. Daher kann es bei der Verwendung von 8-Bit (UTF-8) oder 16-Bit Zeichensätzen (bspw. UTF-16) zu Problemen mit der Übermittlung oder der Darstellung beim Empfänger kommen. Aus diesem Grund ist es erforderlich Zeichensätze mit 8 oder mehr Bit auf eine niedrigere Bit-Basis umzuwandeln, um so derartigen Problemen entgegen zu wirken. Dies kann durch eine Umwandlung in Base64 geschehen. Die in Base-64 enthaltenen Zeichen:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
a b c d e f g h i j k l m n o p q r s t u v w x y z
0 1 2 3 4 5 6 7 8 9
+ /

lassen sich problemlos auch mit ASCII- oder kompatiblen Zeichensätzen darstellen. So ist eine fehlerfreie Übertragung etwa per SMTP (Email) gewährleistet. Per Base64 lassen sich zudem nicht nur Zeichenfolgen übertragen sondern auch Binärdaten (etwa Bilder oder Musikstücke), welche ansonsten Probleme mit der Darstellung bereiten könnten.

Funktionsweise

Die Umwandlung eines gewöhnlichen Textes in Base64 gelingt in mehreren Schritten, die hier exemplarisch an Hand eines Beispieltextes demonstriert werden sollen. Als Beispieltext wählen wir:

Viel Spaß beim Programmieren! :)

Im ersten Schritt wird die Zeichenfolge von Anfang bis Ende durchlaufen und dabei jeder Buchstabe und jedes sonstige Zeichen in seinen entsprechenden Zeichencode umgewandelt. Unter Visual Basic geschieht dies am einfachsten mit Hilfe der Asc-Funktion. Der obige Beispieltext wird so zu:

86 105 101 108 32 83 112 97 223 32 98 101 105 109 32 80 114 111 103 114 97 109 109 105 101 114 101 110 33 32 58 41

Im zweiten Schritt wird jeder der so gewonnenen Zeichencodes sodann in seine binäre Schreibweise überführt. Wichtig ist hierbei auf jedes Zeichen auf eine Länge von 8 Bit zu normalisieren, da es sonst bei der Umwandlung zu Problemen kommen könnte. Für unseren Beispielsatz ergibt sich folgendes:

01010110 01101001 01100101 01101100 00100000 01010011 01110000 01100001 11011111 00100000 01100010 01100101 01101001 01101101 00100000 01010000 01110010 01101111 01100111 01110010 01100001 01101101 01101101 01101001 01100101 01110010 01100101 01101110 00100001 00100000 00111010 00101001

Die so gewonnene Bitfolge entspricht im Wesentlichen noch unserem Ausgangstext lediglich in binärer Schreibweise. Um nun eine Übertragung auf 6-Bit Zeichenlänge durchführen zu können müssen die einzelnen Bits im dritten Schritt neu angeordnet werden. Die Neuordnung erfolgt in Schritten von 3 Zeichen á 8 Bit (entsprechend 3 x 8 Bit = 24 Bit) und mündet in eine Umgruppierung zu 4 Einheiten á 6 Bit (entsprechend 4 x 6 = 24 Bit). Der Bitstrom an sich wird somit nicht verändert lediglich die Anordnung seiner Elemente. Hieraus ergibt sich folgende Anordnung:

010101 100110 100101 100101 011011 000010 000001 010011 011100 000110 000111 011111 001000 000110 001001 100101 011010 010110 110100 100000 010100 000111 001001 101111 011001 110111 001001 100001 011011 010110 110101 101001 011001 010111 001001 100101 011011 100010 000100 100000 001110 100010 100100

Sollte die Zeichenanzahl des Ausgangstextes nicht durch drei teilbar sein und daher das letzte Tripple nicht aufgehen werden die fehlenden Bits durch 0-Bits ergänzt. Der vierte Schritt ergibt daher folgende Ergänzung:

010101 100110 100101 100101 011011 000010 000001 010011 011100 000110 000111 011111 001000 000110 001001 100101 011010 010110 110100 100000 010100 000111 001001 101111 011001 110111 001001 100001 011011 010110 110101 101001 011001 010111 001001 100101 011011 100010 000100 100000 001110 100010 100100 000000

Im fünften Schritt werden aus diesen Binärwerte wieder die entsprechenden Dezimalwerte ermittelt:

21 38 37 37 27 2 1 19 28 6 7 31 8 6 9 37 26 22 52 32 20 7 9 47 25 55 9 33 27 22 53 41 25 23 9 37 27 34 4 32 14 34 36 0

Welche im Anschluss, im sechsten Schritt, anhand der Base64-Tabelle in die korrespondierenden Zeichen übertragen werden:

V m l l b C B T c G H f I G J l a W 0 g U H J v Z 3 J h b W 1 p Z X J l b i E g O i k A

Im abschließenden siebten und letzten Schritt werden die Zeichen zu einem Gesamtstring zusammengefügt und jene Werte am Ende des Strings, welche vollständig durch 0-Bit-Ergänzung enstanden sind durch "=" bzw. "==" ersetzt, falls Erforderlich. Dies verhindert fehlerhafte Dekodierungen, wenn die Base64-Zeichenfolge wieder in seine ursprüngliche Form übertragen werden soll:

VmllbCBTcGHfIGJlaW0gUHJvZ3JhbW1pZXJlbiEgOik=

Damit ist die Umwandlung abgeschlossen und es liegt eine in Base64 kodierte Zeichenfolge vor. Wie zu erkennen hat sich durch die Umwandlung im konkreten Fall die Textlänge von 32 auf 44 Zeichen verlängert und sämtliche nicht im Base64-Satz enthaltene Zeichen sind aus dem finalen String verschwunden.

Base64-Tabelle

Im Folgenden eine Übersicht über die Base64-Mapping-Tabelle:

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

Tipps

» Tipp 054: Umwandlung Binärsystem zu Dezimalsystem

Beispielprojekt

frmBase64

Form                     frmBase64
Label                    lblAscii
Label                    lblBinär
TextBox                  txtBase64

' VISUAL BASIC WORLD
' ===========================================
' Das große Portal zum Thema Visual Basic.
'
' Wenn Ihnen dieser Source Code gefallen hat,
' dann empfehlen Sie Visual Basic World bitte
' weiter und/oder setzen Sie einen Link auf:
'
' http://www.visualbasicworld.de/
'
' Vernetzen Sie sich mit uns:
'
' http://twitter.com/visualbasicwrld

Option Explicit
 

 
Private Sub txtBase64_Change()
 
   Me.Caption = "Base64-Kodierung | www.visualbasicworld.de" _
      & " | Zeichen-Base64: " & Len(txtBase64.Text)
 
   txtData.Text = Base64ToData(txtBase64.Text)
 
End Sub
 

 
Private Sub txtData_Change()
 
   Me.Caption = "Base64-Kodierung | www.visualbasicworld.de" & _
      " | Zeichen-ASCII: " & Len(txtData.Text)
 
   txtBase64.Text = DataToBase64(txtData.Text)
 
End Sub

modBase64

' VISUAL BASIC WORLD
' ===========================================
' Das große Portal zum Thema Visual Basic.
'
' Wenn Ihnen dieser Source Code gefallen hat,
' dann empfehlen Sie Visual Basic World bitte
' weiter und/oder setzen Sie einen Link auf:
'
' http://www.visualbasicworld.de/
'
' Vernetzen Sie sich mit uns:
'
' http://twitter.com/visualbasicwrld

Option Explicit
 
Global Const Base64CodeTafel = _
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
 

 
 
Public Function DataToBase64(strData As String) As String
 
'========================================================='
'= Funktion wandelt ASCII-Daten in Base64 kodierte Daten ='
'========================================================='
 
   Dim lngZähler As Long
   Dim lngCounter As Long
 
   Dim lngMax As Long
 
   Dim lngBuffer As Long
   Dim strBuffer As String
 
   lngMax = Len(strData)
 
   For lngZähler = 1 To lngMax
 
      strBuffer = strBuffer & _
         Format(DezToBin(Asc(Mid$(strData, lngZähler, 1))), "00000000")
 
      lngBuffer = Len(strBuffer)
         'Der Zwischenspeicher wird gefüllt und die Länge des gespeicherten String
         'vermerkt. Die Zwischenspeicherung der Textlänge erfolgt vor allem aus
         'Performance-Gründen, da dieser Wert mehrmals benötigt wird.
 
      If lngBuffer = 24 Or lngZähler = lngMax Then
         'Verarbeitung in Gruppen zu 24-Bit bzw. 8-Byte.
 
         If Not lngBuffer Mod 6 = 0 Then
            strBuffer = strBuffer & Mid$("000000", 1, 6 - lngBuffer Mod 6)
            lngBuffer = Len(strBuffer)
         End If
            'Die Binärbits die zuvor je Byte in 8er-Gruppen organisiert waren werden im
            'Nächsten Schritt in 6er-Gruppen neu sortiert. Damit diese Neuorganisation
            'auch stets aufgeht werden hier fehlende Bits (zum Sextett) durch angehängte
            '0-Bits geschlossen. Dies ist jedoch nicht immer erforderlich und auch stets
            'nur im letzten Durchgang der Codierung. Daher erfolgt zuvor eine Abfrage
            'mit Hilfe der Modulo-Funktion.
 
 
         For lngCounter = 1 To lngBuffer Step 6
            DataToBase64 = DataToBase64 & _
               Mid$(Base64CodeTafel, 1 + BinToDez(Mid$(strBuffer, lngCounter, 6)), 1)
               'Sind alle Bits bereit zur Verarbeitung und die Gruppen zu ganzen
               '6er-Verbänden geschlossen werden die Bits neu kodiert, indem die
               'Binärzahlenwerte wieder ins Dezimalsystem übertragen werden.
         Next
 
         strBuffer = ""
 
      End If
 
   Next
 
   If Not Len(strData) Mod 3 = 0 Then _
      DataToBase64 = DataToBase64 & Mid$("==", 1, 3 - Len(strData) Mod 3)
         'Wenn die Anzahl des Eingabebytes nicht durch drei teilbar ist werden die
         'fehlenden Bytes mit Füllbits ("0") geschlossen. Um bei der Dekodierung zu
         'erkennen welche Bytes vollständig nachträglich angefügt wurden werden diese
         'mit "=" kodiert. Da maximal zwei Bytes komplett mit Füllbits zu füllen sind
         'können nie mehr als zwei "==" kodiert werden.
 
End Function
 

 
Public Function Base64ToData(strBase64 As String) As String
 
'==========================================================='
'= Funktion wandelt Base64-Daten in gewöhnlichen Daten um. ='
'==========================================================='
 
   Dim lngZähler As Long
   Dim lngCounter As Long
   Dim lngMax As Long
 
   Dim strBuffer As String
   
'== Unzulässige Zeichen ausfiltern ==='
 
   'Der Base64 Algorithmus gestattet lediglich die Verwendung der festgelegten
   '64 Zeichen zur Kodierung. Alle übrigen Zeichen im Zeichen-Stream sind damit
   'nicht Bestandteil des Base64-Datenstreams und werden entfernt. Dies ermöglicht
   'eine Formatierung der Daten per Leerzeichen oder ähnliches, da diese bei der
   'Dekodierung ohnehin entfernt werden.
 
   lngMax = Len(strBase64)
 
   For lngZähler = 1 To lngMax
 
      strBuffer = Mid$(strBase64, lngZähler, 1)
      If InStr(Base64CodeTafel, strBuffer) = 0 Then
         strBase64 = Replace(strBase64, strBuffer, "")
         lngMax = Len(strBase64)
      End If
 
   Next
 
   strBuffer = ""
   
'== Base64 codierten Datenstream umwandeln ==='
 
   'Die "Entschlüsselung" des Base64-Streams geschieht umgekehrt zur Kodierung.
   'Zunächst werden die einzelnen Buchstaben in Binärform überführt. Sodann
   'werden Gruppen zu 24 Bits in drei Zeichen á 8 Bit übertragen. Diese werden
   'aus den sich hieraus ergebenden ASCII-Codes werden mit der Chr-Funktion
   'Buchstaben und Zeichen gebildet. Diese werden dem Ergebnisstring angehängt
   'und so fort bis der gesamte Datenstrom übertragen wurde.
 
   For lngZähler = 1 To lngMax
 
       strBuffer = strBuffer & _
         Format(DezToBin(InStr(Base64CodeTafel, _
            Mid$(strBase64, lngZähler, 1)) - 1), "000000")
 
       If (Len(strBuffer) = 24) Or (lngZähler = lngMax) Then
 
            For lngCounter = 1 To Len(strBuffer) Step 8
 
               Base64ToData = Base64ToData & _
                  Chr(BinToDez(Mid$(strBuffer, lngCounter, 8)))
 
            Next
 
            strBuffer = ""
 
 
       End If
 
   Next
 
End Function
 

 
Private Function DezToBin(ByVal dblDezimal As Double) As String
 
   '======================================================================'
   '= Funktion wandelt eine Zahl aus dem Dezimal- in das Binärsystem um. ='
   '======================================================================'
 
   DezToBin = ""
 
   Do
 
      DezToBin = dblDezimal Mod 2 & DezToBin
 
      dblDezimal = dblDezimal \ 2
 
   Loop Until dblDezimal < 1
 
End Function
 

 
 
Private Function BinToDez(ByVal strBinär As String) As Double
 
   '======================================================================'
   '= Funktion wandelt eine Zahl aus dem Binär- in das Dezimalsystem um. ='
   '======================================================================'
 
   Dim lngZähler As Long
   Dim lngMax As Long
 
   lngMax = Len(strBinär)
 
   For lngZähler = 0 To (lngMax - 1)
 
      BinToDez = BinToDez + CDbl(Mid$(strBinär, lngMax - (lngZähler), 1)) * (2 ^ lngZähler)
 
   Next
 
End Function