Tabelleninhalte verschlüsseln

Der Schutz sensibler Daten in Access-Datenbanken ist keine triviale Angelegenheit. Die Tabellen liegen offen in nur einer Datei, die problemlos auf einen USB-Stick kopiert werden kann, um deren Inhalte anderenorts in aller Ruhe zu inspizieren. Frühere Access-Versionen bis Office 2003 erlaubten die Absicherung über ein Berechtigungsmodell, das später leider ersatzlos gestrichen wurde. Wer auf Nummer Sicher gehen will, der sollte sich Gedanken über eine Datenverschlüsselung machen.

Beispieldatenbank

Die Beispiele dieses Artikels finden Sie in der Datenbank 1701_Cryto.accdb.

Strings verschlüsseln per VBA

Zu den Daten, die in einer Tabelle nicht unbedingt auf den ersten Blick einsehbar sein müssen, gehören vor allem Texte. In einer Adressenliste etwa beträfe dies die Namensfelder, die Telefon- und E-Mail-Daten, sowie andere Adressfelder. Verschlüsselt man diese, so kann ein Unbefugter mit ihnen nicht allzu viel anfangen.

In der Beispieldatenbank bekommen wir es wieder einmal mit der bekannten Kundentabelle zu tun, deren Datenmodell Bild 1 wiedergibt. Neben den Nachschlagetabellen zu Anreden, Orten und Ländern enthält die Haupttabelle tblKunden die üblichen Adressfelder. Wir machen uns zur Aufgabe, die folgenden Felder zu verschlüsseln: Nachname, Vorname, Strasse, Telefon und Email. Das sollte ausreichen, um die Datensätze so zu verunstalten, dass aus ihnen keine Rückschlüsse auf den ursprünglichen Inhalt mehr möglich sind.

Bild 1: Das Datenmodell der Beispieldatenbank zu Kundenadressen

Der Ausgangszustand zeigt sich in Bild 2. Hier sind alle Adressdaten in konventioneller Weise abgespeichert. Jeder kann sie einsehen und gegebenenfalls stehlen. Dazu benötigt man noch nicht einmal eine Office-Installation, denn die Datenzugriffsbibliotheken DAO und ADO bringt Windows bereits von Haus aus mit. Selbst unter Linux/Android und etwa das Zugriffssystem JDBC käme man an die Tabelle heran. Das wäre zwar auch nach Verschlüsselung noch der Fall, doch dann nützt der Einblick wenig, wie Bild 3 beweist. Hier sind die erwähnten Textfelder über eine Aktualisierungsabfrage einer RC4-Verschlüsselung unterzogen worden, auf die wir noch zu sprechen kommen.

Bild 2: Dieselben Datensätze der verschlüsselten Kundentabelle in der Datenblattansicht

Bild 3: Einige Datensätze der normalen Kundentabelle in der Datenblattansicht

Verschlüsselungsalgorithmen

Access und VBA selbst bringen direkt keine Verschlüsselungsmethoden mit. Sie sind deshalb auf eigene VBA-Implementierungen in Form von Funktionen angewiesen.

Listing 1 zeigt eine extrem einfache Methode, die sich die VBA-Funktion StrReverse zunutze macht. Sie kehrt einen übergebenen String schlicht um:

Sub CryptReverse(S As String)
     Dim sCrypt As String
     
     sCrypt = StrReverse(S)
     S = StrReverse(sCrypt)
     Debug.Print sCrypt, "/", S
End Sub

Listing 1: Textverschlüsselung über eine String-Umkehr

CryptReverse "Access Basics"
->  scisaB sseccA /  Access Basics

Das Ergebnis stellt einen Hacker vor keinerlei Herausforderungen. Der Algorithmus ist ganz offensichtlich – von Verschlüsselung kann man hier wohl kaum sprechen. Anders sieht es bei der Routine zum zweiten Beispiel aus (siehe Listing 2), das alle Zeichen des übergebenen Strings einer binären XOR-Operation unterzieht:

Sub CryptXOR(S As String)
     Dim sCrypt As String
     Dim i As Long, n As Long
     Dim nOrd As Long
     n = Len(S)
     sCrypt = String(n, 0)
     For i = 1 To n
         nOrd = Asc(Mid(S, i, 1))
         Mid(sCrypt, i) = Chr((nOrd Xor 255))
     Next i
     S = String(n, 0)
     For i = 1 To n
         nOrd = Asc(Mid(sCrypt, i, 1))
         Mid(S, i) = Chr((nOrd Xor 255))
     Next i
     Debug.Print sCrypt, "/", S
End Sub

Listing 2: Textverschlüsselung über ein Byte-weises XOR

CryptXOR "Access Basics"
->  ¾œœšœœß½žœ-œœ  / Access Basics

In der ersten For-Next-Schleife werden die einzelnen Zeichen des Strings zunächst über die Mid-Funktion ermittelt und deren ASCII-Ordinalzahl in der Variablen nOrd (Long) gespeichert. Diese wird binär mit Xor 255 behandelt und anschließend per Chr-Funktion wieder in ein Zeichen verwandelt. Die Stringvariable sCrypt nimmt diese Zeichen nacheinander auf. Die zweite Schleife macht die Probe und wiederholt den Vorgang auf genau die gleiche Weise. Verschlüsseln und Entschlüsseln geschehen also über den identischen Algorithmus, so, wie dies auch bei StrReverse der Fall ist. Tatsächlich handelt es sich bei Anwendung von Xor 255 um eine ähnliche Angelegenheit, da hier die Bits eines Bytes schlicht umgekehrt werden:

00110101 -> 11001010

Der Ergebnis-String ist nun ziemlich kryptisch, doch auch hier hat ein Hacker sicher schnell die Lösung gefunden. Also versuchen wir es ihm noch schwerer zu machen.

Die Routine CryptXORReverse (Listing 3) kombiniert die beiden beschriebenen Prozeduren. Erst greift wieder der XOR-Algorithmus, doch anschließend kommt noch StrReverse zum Einsatz. Ergebnis:

Sub CryptXORReverse(S As String)
     Dim sCrypt As String
     Dim i As Long, n As Long
     Dim nOrd As Long
     n = Len(S)
     sCrypt = String(n, 0)
     For i = 1 To n
         nOrd = Asc(Mid(S, i, 1))
         Mid(sCrypt, i) = Chr((nOrd Xor 255))
     Next i
     sCrypt = StrReverse(sCrypt)
     S = String(n, 0)
     For i = 1 To n
         nOrd = Asc(Mid(sCrypt, i, 1))
         Mid(S, i) = Chr((nOrd Xor 255))
     Next i
     S = StrReverse(S)
     Debug.Print sCrypt, "/", S
End Sub

Listing 3: Textverschlüsselung über Byte-weises XOR plus String-Umkehr

CryptXORReverse "Access Basics"
->  œœ-œž½ßœœšœœ¾  /  Access Basics

Deutlich schwerer nachvollziehbar sind Algorithmen, die sich etwa die Mod-Funktion von VBA zunutze machen, welche die Ordinalzahl eines Zeichens quasi rotieren lässt. Listing 4 demonstriert so eine Lösung.

Sub CryptAddMod(S As String)
     Dim sCrypt As String
     Dim i As Long, n As Long
     Dim nOrd As Long
     n = Len(S)
     sCrypt = String(n, 0)
     For i = 1 To n
         nOrd = Asc(Mid(S, i, 1))
         Mid(sCrypt, i) = Chr(((nOrd + 144) Mod 256))
     Next i
     S = String(n, 0)
     For i = 1 To n
         nOrd = Asc(Mid(sCrypt, i, 1)) - 144
         Mid(S, i) = Chr((nOrd + 256) Mod 256)
     Next i
     Debug.Print sCrypt, "/", S
End Sub

Listing 4: Textverschlüsselung über die Ordinalzahl der Zeichen und Mod

Benutzername oder E-Mail-Adresse: