{"id":55001190,"date":"2019-06-01T00:00:00","date_gmt":"2024-06-07T21:47:27","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1190"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Benutzerverwaltung_mit_verschluesselten_Kennwoertern","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Benutzerverwaltung_mit_verschluesselten_Kennwoertern\/","title":{"rendered":"Benutzerverwaltung mit verschlüsselten Kennwörtern"},"content":{"rendered":"

\"\"Wenn Sie in einer Access-Anwendung Benutzer verwalten wollen, die sich per Benutzername und Kennwort an die Anwendung anmelden, sollten Sie sehr sensibel mit den in der Anwendung gespeicherten Kennwörtern umgehen. Das geht am einfachsten, wenn Sie die Kennwörter verschlüsselt speichern. Damit verringern Sie die Wahrscheinlichkeit, dass jemand die Kennwörter entschlüsselt und für seine Zwecke nutzen kann, erheblich. Dieser Artikel stellt eine kleine Benutzerverwaltung vor, mit der Sie Benutzer und Benutzergruppen verwalten und auch Berechtigungen für verschiedene Tabellen vergeben können.<\/b><\/p>\n

Die Benutzerverwaltung<\/h2>\n

Zur Benutzerverwaltung gehören einige Tabellen, mit denen wir die Benutzer, die Benutzergruppen, die Zuordnung der Benutzer zu den Benutzergruppen, die Tabellen, für die wir Berechtigungen vergeben wollen, sowie die Berechtigungen selbst verwalten wollen.<\/p>\n

Außerdem gehört dazu ein Formular für die Anmeldung des jeweiligen Benutzers. Dieses nimmt den Benutzernamen und das Kennwort entgegen und prüft, ob ein passendes Paar dieser beiden Daten in der Tabelle der Benutzer gefunden werden kann. In diesem Fall soll eine temporäre Variable mit dem Namen des Benutzers gefüllt werden.<\/p>\n

Weitere Mechanismen, welche die Prüfung der Berechtigungen dieses Benutzers beim Zugriff auf die Daten durchführen, nutzen den Inhalt dieser Variablen. Diese Mechanismen stellen wir beispielsweise im Beitrag Zugriffsrechte mit Datenmakros<\/b> (www.access-im-unternehmen.de\/1193<\/b>) vor.<\/p>\n

Tabellen der Benutzerverwaltung<\/h2>\n

Die erste Tabelle der Benutzerverwaltung heißt tblBenutzer <\/b>und dient zum Speichern der Benutzerdaten, in diesem Fall des Benutzernamens und des Kennworts. Der Entwurf dieser Tabelle sieht wie in Bild 1 aus. Für das Feld Benutzername <\/b>legen wir einen eindeutigen Index fest, damit kein Benutzername zwei Mal vergeben werden kann. Außerdem fügen wir noch ein Feld namens KennwortZuletztGeaendertAm <\/b>mit dem Datentyp Datum\/Uhrzeit <\/b>hinzu, das speichert, wann das Kennwort des Benutzers zuletzt geändert wurde.<\/p>\n

\"Tabelle<\/p>\n

Bild 1: Tabelle zur Verwaltung der Benutzer<\/span><\/b><\/p>\n

Die Tabelle tblBenutzergruppen<\/b> speichert die Namen der Benutzergruppen (siehe Bild 2). Das einzige Feld neben dem Primärschlüsselfeld heißt Benutzergruppe <\/b>und besitzt ebenfalls einen eindeutigen Index, damit jede Benutzergruppe nur einmal angegeben werden kann.<\/p>\n

\"Tabelle<\/p>\n

Bild 2: Tabelle zur Verwaltung der Benutzergruppen<\/span><\/b><\/p>\n

Um die Benutzer den Benutzergruppen zuzuordnen, erstellen wir eine weitere Tabelle namens tblGruppenzuordnungen<\/b>. Diese enthält neben dem Primärschlüsselfeld GruppenzuordnungID <\/b>noch zwei Fremdschlüsselfelder namens BenutzerID <\/b>und BenutzergruppeID<\/b>. Beide Beziehungen haben wir mit dem Nachschlageassistenten eingerichtet. Damit jeder Benutzer nur einmal zu jeder Benutzergruppe zugeordnet werden kann, fügen wir der Tabelle einen zusammengesetzten, eindeutigen Index über die beiden Felder BenutzerID<\/b> und BenutzergruppeID <\/b>hinzu (siehe Bild 3).<\/p>\n

\"Tabelle<\/p>\n

Bild 3: Tabelle zur Zuordnung von Benutzern zu Benutzergruppen<\/span><\/b><\/p>\n

Tabelle zum Speichern der Tabellen<\/h2>\n

Wir wollen für jede Benutzergruppe die Berechtigungen für den Zugriff auf die Tabellen der Datenbank festlegen. Dazu benötigen wir erst einmal eine Tabelle mit den Tabellen der Datenbank. Diese heißt tblTabellen <\/b>und sieht im Entwurf wie in Bild 4 aus.<\/p>\n

\"Tabelle<\/p>\n

Bild 4: Tabelle zum Speichern der Tabellennamen<\/span><\/b><\/p>\n

Füllen der Tabelle mit Tabellennamen<\/h2>\n

Damit das Eintragen der Tabellen nicht zu aufwendig wird, haben wir eine kleine Prozedur geschrieben, mit der Sie die Bezeichnungen der Tabellen schnell in die Tabelle tblTabellen <\/b>eintragen können. Diese finden Sie in Listing 1. Die Prozedur durchläuft alle Elemente der Auflistung TableDefs <\/b>des Database<\/b>-Objekts für die aktuelle Datenbank. Dabei legt es jeweils einen neuen Datensatz in der Tabelle tblTabellen <\/b>an und trägt die Bezeichnung der Tabelle ein. Dabei untersucht die Prozedur noch die Bezeichnung der Tabelle und trägt nur solche Tabellenbezeichnungen ein, die nicht mit MSys <\/b>(Systemtabellen) oder ~ <\/b>beginnen (temporäre Tabellen).<\/p>\n

Public Sub <\/span>TabellenEintragen()\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>tdf As <\/span>DAO.TableDef\r\n     Set<\/span> db = CurrentDb\r\n     For Each tdf In db.TableDefs\r\n         If <\/span>Not<\/span> tdf.Name Like \"MSys*\" And Not<\/span> tdf.Name Like \"~*\" Then<\/span>\r\n             On Error Resume Next<\/span>\r\n             db.Execute \"INSERT INTO tblTabellen(Tabelle) VALUES(''\" & tdf.Name & \"'')\", dbFailOnError\r\n             On Error GoTo<\/span> 0\r\n         End If<\/span>\r\n     Next<\/span> tdf\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Prozedur zum Eintragen der Tabellennamen<\/span><\/b><\/p>\n
Tabelle der Berechtigungen<\/h2>\n
Die Tabelle tblBerechtigungen <\/b>soll festlegen, welche Berechtigungen für die Kombinationen aus Benutzergruppen und Tabellen festgelegt werden können. Dabei haben wir für diese Tabelle ausnahmsweise einmal kein Primärschlüsselfeld mit dem Datentyp Autowert <\/b>definiert, sondern eines mit dem Datentyp Zahl<\/b>. Auf diese Weise können wir die Werte für das Primärschlüsselfeld selbst vergeben. Das zweite Feld heißt Berechtigung <\/b>und soll die Bezeichnung der Berechtigung enthalten (siehe Bild 5). Auch für dieses Feld haben wir wieder einen eindeutigen Index festgelegt.<\/p>\n
\"Tabelle<\/p>\n
Bild 5: Tabelle zum Speichern der Berechtigungen<\/span><\/b><\/p>\n
Werte der Tabelle tblBerechtigungen<\/h2>\n
Warum aber wollen wir für das Primärschlüsselfeld dieser Tabelle nicht die Autowert-Funktion verwenden? Weil wir die Werte für das Primärschlüsselfeld selbst vergeben wollen. Diese sollen nämlich wie in Bild 6 aussehen. Die Berechtigung Keine <\/b>erhält beispielsweise den Wert 0<\/b>. Lesen <\/b>erhält den Wert 1<\/b>, Anlegen <\/b>den Wert 2<\/b>, Ändern <\/b>den Wert 4 <\/b>und Löschen <\/b>den Wert 8<\/b>.<\/p>\n
\"Werte<\/p>\n
Bild 6: Werte der Berechtigungen<\/span><\/b><\/p>\n
Das Muster ist leicht zu erkennen: Die Werte entsprechen allesamt Zweierpotenzen. Warum das? Weil die Berechtigungen kombinierbar sein sollen und wir die Kombinationen in einem einzigen Wert erfassen wollen. Wenn wir nur Zweierpotenzen für diese Werte verwenden, können wir durch Summieren der Werte einzelne Berechtigungen zusammenfassen.<\/p>\n
Der Wert 1 <\/b>würde bedeuten, dass der Benutzer nur lesende Rechte an der Tabelle hat. Der Wert 5 <\/b>(aus 1 + 4<\/b>) heißt, der Benutzer hat Leserechte und darf die Datensätze ändern. Der Wert 15 <\/b>(aus 1 + 2 + 4 + 8<\/b>) bedeutet, dass der Benutzer alle Rechte an den Datensätzen der Tabelle hat. Wir schauen uns später im Detail an, wie wir diese Werte nutzen können.<\/p>\n
Alternative: Alle Kombinationen?<\/h2>\n
Die Alternative hierzu wäre, gleich alle Kombinationen in der Tabelle zu speichern, also etwa noch Einträge hinzuzufügen wie Lesen und Anlegen<\/b>, Lesen und Ändern<\/b>, Lesen und Löschen <\/b>bis hinzu zu Lesen, Anlegen, Bearbeiten und Löschen<\/b>. Dann wäre nur die Auswahl eines Eintrags für die Ermittlung aller Berechtigungen nötig. Allerdings müsste man dann auch immer, wenn man nur wissen will, ob der Benutzer einer Benutzergruppe etwa Löschrechte besitzt, den Zahlenwert interpretieren. Also fahren wir mit der Variante, bei der wir die einzelnen Rechte explizit und einzeln setzen müssen.<\/p>\n
Tabellen zum Zuordnen der Berechtigungen<\/h2>\n
Fehlt noch eine Tabelle, mit der wir die verschiedenen Berechtigungen für die Kombination aus Benutzergruppe und Tabelle festlegen.<\/p>\n
Die Tabelle heißt tblBerechtigungszuordnungen<\/b> und sieht in der Entwurfsansicht wie in Bild 7 aus. Diese Tabelle hat gleich drei Fremdschlüsselfelder, mit denen die Datensätze der Tabellen tblBenutzergruppen<\/b>, tblTabellen <\/b>und tblBerechtigungen <\/b>kombiniert werden. Damit auch hier jede Kombination nur einmal vorkommt, haben wir einen zusammengesetzten, eindeutigen Index für die drei Felder BenutzergruppeID<\/b>, TabelleID <\/b>und BerechtigungID <\/b>angelegt.<\/p>\n
\"Tabelle<\/p>\n
Bild 7: Tabelle zur Zuordnung der Berechtigungen<\/span><\/b><\/p>\n
Benutzer verwalten<\/h2>\n
Für die Verwaltung der Benutzer und die Zuordnung zu den Benutzergruppen legen wir ein Formular an, dass an die Tabelle tblBenutzer <\/b>gebunden ist. Zwei Listenfelder namens lstZugewiesen<\/b> und lstNichtZugewiesen <\/b>dienen der Zuweisung der Benutzergruppen zu den Benutzern (siehe Bild 8).<\/p>\n
\"Formular<\/p>\n
Bild 8: Formular zum Verwalten der Benutzer<\/span><\/b><\/p>\n
Das erste Listenfeld zeigt alle Einträge der Tabelle tblBenutzergruppen <\/b>an, die mit dem aktuell im Formular angezeigten Benutzer verknüpft sind. Dazu legen wir für das Listenfeld die Abfrage mit dem Entwurf aus Bild 9 als Datensatzherkunft fest. Diese liefert alle Einträge der Tabelle tblBenutzergruppen<\/b>, die über die Tabelle tblGruppenzuordnungen <\/b>dem aktuellen Benutzer aus dem Formular zugeordnet sind.<\/p>\n
\"Datensatzherkunft<\/p>\n
Bild 9: Datensatzherkunft des Listenfeldes lstZugewiesen<\/span><\/b><\/p>\n
Als Datensatzherkunft für das zweite Listenfeld verwenden wir die Abfrage aus Bild 10. Als Kriterium verwenden wir eine abgespeckte Variante der Datensatzherkunft für das Listenfeld lstZugewiesen<\/b>. Abgespeckt deshalb, weil eine Abfrage, die wir als Parameter der NOT IN<\/b>– beziehungsweise Nicht In<\/b>-Klausel verwenden, nur ein Feld zurückliefern darf – und in diesem Fall interessiert uns nur, welche Benutzergruppen bereits für den aktuellen Benutzer ausgewählt sind.<\/p>\n
\"Abfrage<\/p>\n
Bild 10: Abfrage zur Ermittlung aller nicht ausgewählten Benutzergruppen<\/span><\/b><\/p>\n
Über die Nicht In<\/b>-Klausel ermitteln wir dann alle Datensätze der Tabelle tblBenutzergruppen<\/b>, die nicht in der als Parameter in Klammern angegebenen Abfrage enthalten sind. Die als Kriterium verwendete Abfrage sieht dann so aus:<\/p>\n
Nicht In (SELECT tblBenutzergruppen.BenutzergruppeID \r\nFROM tblBenutzergruppen \r\nINNER JOIN tblGruppenzuordnungen \r\nON tblBenutzergruppen.BenutzergruppeID = \r\ntblGruppenzuordnungen.BenutzergruppeID \r\nWHERE tblGruppenzuordnungen.BenutzerID)=\r\n[Forms]![frmBenutzerVerwalten]![BenutzerID]<\/pre>\n
Damit die beiden Listenfelder nicht den Wert des Primärschlüsselfeldes BenutzergruppeID<\/b> anzeigen, sondern die Bezeichnung der Benutzergruppe, stellen wir die Eigenschaft Spaltenanzahl <\/b>auf 2 <\/b>und die Eigenschaft Spaltenbreiten <\/b>auf den Wert 0cm <\/b>ein.<\/p>\n
Datensatzherkünfte der Listenfelder beim Anzeigen eines Datensatzes aktualisieren<\/h2>\n
Wenn wir den im Formular angezeigten Benutzer aktualisieren, sollen auch die Daten der beiden Listenfelder aktualisiert werden. Dazu hinterlegen wir für die Ereignis-eigenschaft Beim Anzeigen <\/b>die folgende Ereignisprozedur. Diese ruft für die beiden Listenfelder die Requery<\/b>-Methode auf:<\/p>\n
Private Sub <\/span>Form_Current()\r\n     Me!lstNichtZugewiesen.Requery\r\n     Me!lstZugewiesen.Requery\r\nEnd Sub<\/span><\/pre>\n
Gruppen zuordnen und entfernen per Doppelklick<\/h2>\n
Um eine Benutzergruppe zu einem Benutzer hinzuzufügen, muss der Benutzer den entsprechenden Eintrag des rechten Listenfeldes anklicken. Um eine Benutzergruppe zu entfernen, ist ein Doppelklick auf den Eintrag im linken Listenfeld nötig.<\/p>\n
Der Doppelklick zum Entfernen eines Eintrags löst die Ereignisprozedur aus Listing 2 aus. Die Prozedur prüft, ob sowohl das Feld BenutzerID <\/b>im Formular als auch der angeklickte Eintrag im Listenfeld lstZugeordnet <\/b>nicht den Wert Null <\/b>enthält. Nur dann kann der aktuell angeklickte Eintrag vom aktuellen Benutzer entfernt werden.<\/p>\n
Private Sub <\/span>lstZugewiesen_DblClick(Cancel As Integer<\/span>)\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Set<\/span> db = CurrentDb\r\n     If <\/span>Not<\/span> IsNull(Me!BenutzerID) And Not<\/span> IsNull(Me!lstZugewiesen) Then<\/span>\r\n         db.Execute \"DELETE FROM tblGruppenzuordnungen WHERE BenutzerID = \" & Me!BenutzerID _\r\n             & \" AND BenutzergruppeID = \" & Me!lstZugewiesen, dbFailOnError\r\n         Me!lstZugewiesen.Requery\r\n         Me!lstNichtZugewiesen.Requery\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 2: Prozedur zum Entfernen einer Benutzergruppe eines Benutzers<\/span><\/b><\/p>\n
Das geschieht über den Aufruf einer DELETE<\/b>-Abfrage, die genau den Eintrag mit der aktuellen BenutzerID <\/b>und dem Wert des Listenfeldes lstZugeordnet <\/b>aus der Tabelle tblGruppenzuordnungen <\/b>entfernt. Damit diese Änderungen sich auch in den beiden Listenfeldern lstZugeordnet <\/b>und lstNichtZugeordnet <\/b>niederschlagen, aktualisieren wir beide mit der Requery<\/b>-Methode.<\/p>\n
Klickt der Benutzer auf einen der Einträge des rechten Listenfeldes lstNichtZugeordnet<\/b>, soll dieser Eintrag in das linke Listenfeld verschoben werden. Dazu prüft die Prozedur aus Listing 3, ob sowohl ein Benutzer im Formular angezeigt wird als auch ein Eintrag im Listenfeld angeklickt wurde. Ist das der Fall, fügt sie in einer INSERT INTO<\/b>-Abfrage einen neuen Datensatz mit den entsprechenden Werten zur Tabelle tblGruppenzuordnungen <\/b>hinzu.<\/p>\n
Private Sub <\/span>lstNichtZugewiesen_DblClick(Cancel As Integer<\/span>)\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Set<\/span> db = CurrentDb\r\n     If <\/span>Not<\/span> IsNull(Me!BenutzerID) And Not<\/span> IsNull(Me!lstNichtZugewiesen) Then<\/span>\r\n         db.Execute \"INSERT INTO tblGruppenzuordnungen(BenutzerID, BenutzergruppeID) VALUES(\" & Me!BenutzerID & \", \" _\r\n             & Me!lstNichtZugewiesen & \")\", dbFailOnError\r\n         Me!lstZugewiesen.Requery\r\n         Me!lstNichtZugewiesen.Requery\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 3: Prozedur zum Hinzufügen einer Benutzergruppe zu einem Benutzer<\/span><\/b><\/p>\n
Das sieht dann etwa wie in Bild 11 aus.<\/p>\n
\"Das<\/p>\n
Bild 11: Das Formular frmBenutzerVerwalten in der Formularansicht<\/span><\/b><\/p>\n
Neuen Benutzer anlegen<\/h2>\n
Neue Benutzer fügt man einfach über das soeben vorgestellte Formular hinzu. Neue Benutzer gehören zunächst keiner Benutzergruppe an, was sich aber durch einen Doppelklick auf den gewünschten Eintrag ändern lässt.<\/p>\n
Kennwort eintragen<\/h2>\n
Im Formular sehen Sie noch kein Kennwort im entsprechenden Textfeld. Dieses soll mit einem vom System vergebenen Kennwort gefüllt werden, dass der Benutzer dann vor der ersten Anmeldung ändern muss. Wie gehen wir das an? Wir machen das so, dass wir beim Anlegen eines Benutzers auf eine Schaltfläche klicken, welche das Kennwort generiert und damit zwei Dinge erledigt:<\/p>\n