{"id":55000346,"date":"2017-02-01T00:00:00","date_gmt":"2020-01-24T15:59:45","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=346"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Tabelleninhalte_verschluesseln","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/Tabelleninhalte_verschluesseln.html","title":{"rendered":"Tabelleninhalte verschlüsseln"},"content":{"rendered":"

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.<\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispiele dieses Artikels finden Sie in der Datenbank 1701_Cryto.accdb<\/b>.<\/p>\n

Strings verschlüsseln per VBA<\/h2>\n

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.<\/p>\n

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<\/b> die üblichen Adressfelder. Wir machen uns zur Aufgabe, die folgenden Felder zu verschlüsseln: Nachname<\/b>, Vorname<\/b>, Strasse<\/b>, Telefon<\/b> und Email<\/b>. 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.<\/p>\n

\"Das<\/a><\/p>\n

Bild 1: Das Datenmodell der Beispieldatenbank zu Kundenadressen<\/p>\n

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<\/b>-Installation, denn die Datenzugriffsbibliotheken DAO<\/b> und ADO<\/b> bringt Windows<\/b> bereits von Haus aus mit. Selbst unter Linux\/Android<\/b> und etwa das Zugriffssystem JDBC<\/b> 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<\/b>-Verschlüsselung unterzogen worden, auf die wir noch zu sprechen kommen.<\/p>\n

\"Dieselben<\/a><\/p>\n

Bild 2: Dieselben Datensätze der verschlüsselten Kundentabelle in der Datenblattansicht<\/p>\n

\"Einige<\/a><\/p>\n

Bild 3: Einige Datensätze der normalen Kundentabelle in der Datenblattansicht<\/p>\n

Verschlüsselungsalgorithmen<\/h2>\n

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

Listing 1 zeigt eine extrem einfache Methode, die sich die VBA-Funktion StrReverse<\/b> zunutze macht. Sie kehrt einen übergebenen String schlicht um:<\/p>\n

Sub <\/span>CryptReverse(S As String<\/span>)\r\n     Dim <\/span>sCrypt As String<\/span>\r\n     \r\n     sCrypt = StrReverse(S)\r\n     S = StrReverse(sCrypt)\r\n     Debug.Print<\/span> sCrypt, \"\/\", S\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Textverschlüsselung über eine String-Umkehr<\/p>\n
CryptReverse \"Access Basics\"\r\n->  scisaB sseccA \/  Access Basics<\/pre>\n
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<\/b>-Operation unterzieht:<\/p>\n
Sub <\/span>CryptXOR(S As String<\/span>)\r\n     Dim <\/span>sCrypt As String<\/span>\r\n     Dim <\/span>i As Long<\/span>, n As Long<\/span>\r\n     Dim <\/span>nOrd As Long<\/span>\r\n     n = Len<\/span>(S)\r\n     sCrypt = String(n, 0)\r\n     For i = 1 To n\r\n         nOrd = Asc(Mid<\/span>(S, i, 1))\r\n         Mid<\/span>(sCrypt, i) = Chr((nOrd Xor 255))\r\n     Next<\/span> i\r\n     S = String(n, 0)\r\n     For i = 1 To n\r\n         nOrd = Asc(Mid<\/span>(sCrypt, i, 1))\r\n         Mid<\/span>(S, i) = Chr((nOrd Xor 255))\r\n     Next<\/span> i\r\n     Debug.Print<\/span> sCrypt, \"\/\", S\r\nEnd Sub<\/span><\/pre>\n
Listing 2: Textverschlüsselung über ein Byte-weises XOR<\/p>\n
CryptXOR \"Access Basics\"\r\n->  \u00beœœšœœß\u00bdžœ-œœ  \/ Access Basics<\/pre>\n
In der ersten For-Next<\/b>-Schleife werden die einzelnen Zeichen des Strings zunächst über die Mid<\/b>-Funktion ermittelt und deren ASCII<\/b>-Ordinalzahl in der Variablen nOrd<\/b> (Long<\/b>) gespeichert. Diese wird binär mit Xor 255<\/b> behandelt und anschließend per Chr<\/b>-Funktion wieder in ein Zeichen verwandelt. Die Stringvariable sCrypt<\/b> 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<\/b> der Fall ist. Tatsächlich handelt es sich bei Anwendung von Xor 255<\/b> um eine ähnliche Angelegenheit, da hier die Bits eines Bytes schlicht umgekehrt werden:<\/p>\n
00110101 -> 11001010<\/pre>\n
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.<\/p>\n
Die Routine CryptXORReverse<\/b> (Listing 3) kombiniert die beiden beschriebenen Prozeduren. Erst greift wieder der XOR<\/b>-Algorithmus, doch anschließend kommt noch StrReverse<\/b> zum Einsatz. Ergebnis:<\/p>\n
Sub <\/span>CryptXORReverse(S As String<\/span>)\r\n     Dim <\/span>sCrypt As String<\/span>\r\n     Dim <\/span>i As Long<\/span>, n As Long<\/span>\r\n     Dim <\/span>nOrd As Long<\/span>\r\n     n = Len<\/span>(S)\r\n     sCrypt = String(n, 0)\r\n     For i = 1 To n\r\n         nOrd = Asc(Mid<\/span>(S, i, 1))\r\n         Mid<\/span>(sCrypt, i) = Chr((nOrd Xor 255))\r\n     Next<\/span> i\r\n     sCrypt = StrReverse(sCrypt)\r\n     S = String(n, 0)\r\n     For i = 1 To n\r\n         nOrd = Asc(Mid<\/span>(sCrypt, i, 1))\r\n         Mid<\/span>(S, i) = Chr((nOrd Xor 255))\r\n     Next<\/span> i\r\n     S = StrReverse(S)\r\n     Debug.Print<\/span> sCrypt, \"\/\", S\r\nEnd Sub<\/span><\/pre>\n
Listing 3: Textverschlüsselung über  Byte-weises XOR plus String-Umkehr<\/p>\n
CryptXORReverse \"Access Basics\"\r\n->  œœ-œž\u00bdßœœšœœ\u00be  \/  Access Basics<\/pre>\n
Deutlich schwerer nachvollziehbar sind Algorithmen, die sich etwa die Mod<\/b>-Funktion von VBA zunutze machen, welche die Ordinalzahl eines Zeichens quasi rotieren lässt. Listing 4 demonstriert so eine Lösung.<\/p>\n
Sub <\/span>CryptAddMod(S As String<\/span>)\r\n     Dim <\/span>sCrypt As String<\/span>\r\n     Dim <\/span>i As Long<\/span>, n As Long<\/span>\r\n     Dim <\/span>nOrd As Long<\/span>\r\n     n = Len<\/span>(S)\r\n     sCrypt = String(n, 0)\r\n     For i = 1 To n\r\n         nOrd = Asc(Mid<\/span>(S, i, 1))\r\n         Mid<\/span>(sCrypt, i) = Chr(((nOrd + 144) Mod<\/span> 256))\r\n     Next<\/span> i\r\n     S = String(n, 0)\r\n     For i = 1 To n\r\n         nOrd = Asc(Mid<\/span>(sCrypt, i, 1)) - 144\r\n         Mid<\/span>(S, i) = Chr((nOrd + 256) Mod<\/span> 256)\r\n     Next<\/span> i\r\n     Debug.Print<\/span> sCrypt, \"\/\", S\r\nEnd Sub<\/span><\/pre>\n
Listing 4: Textverschlüsselung über die Ordinalzahl der Zeichen und Mod<\/p>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Access [basics]<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 400 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t