<\/p>\n
Für den einen oder anderen Zweck möchten Sie vielleicht Kennwörter generieren oder in einer Benutzeroberfläche die Möglichkeit zum Generieren von Kennwörtern anbieten. Wenn Sie etwa Benutzer zu einer Benutzerverwaltung hinzufügen, sollten Sie ein initiales Kennwort definieren, das der Benutzer dann bei der ersten Anmeldung ändert. Das Generieren von Kennwörtern wird allerdings umso komplizierter, je mehr Anforderungen es gibt. Einfach nur ein paar Zeichen zufällig auszuwählen, ist noch einfach, aber wenn es Bedingungen gibt, wie sie in sensiblen Umgebungen vorherrschen, soll ein Kennwort beispielsweise mindestens einen Kleinbuchstaben, einen Großbuchstaben, eine Zahl und ein Sonderzeichen enthalten. Diese Anforderungen wollen wir in der hier vorgestellten Funktion natürlich auch unterstützen.<\/b><\/p>\nKennwort mit bestimmter Zeichenanzahl<\/h2>\n
Die einfachste Variante ermittelt einfach ein Kennwort mit beliebigen Zeichen aus einem bestimmten Zeichenpool, wobei wir mit dem einzigen Parameter der Funktion namens KennwortGenerierenEinfach <\/b>die Anzahl der Zeichen angeben (siehe Listing 1).<\/p>\n Listing 1: Generieren eines einfachen Kennworts<\/span><\/b><\/p>\n Die Funktion definiert eine Konstante, die alle vorgesehenen Zeichen enthält – in diesem Fall alle Großbuchstaben, alle Kleinbuchstaben, alle Zahlen und einige Sonderzeichen:<\/p>\n Nach der Definition der beiden übrigen Variablen strKennwort <\/b>zum Speichern des zusammengesetzten Kennworts und i <\/b>als Laufvariable der For Next<\/b>-Schleife initialisiert die Funktion mit der Randomize<\/b>-Funktion den Zufallszahlengenerator.<\/p>\n Die Rnd<\/b>-Funktion, die eine Zufallszahl ermittelt, liefert nämlich sonst nach jedem neuen Start der Access-Anwendung die gleichen Ergebnisse. Sie können das ausprobieren, indem Sie im Direktbereich die Rnd<\/b>-Funktion wie folgt aufrufen:<\/p>\n Nach dem Schließen und erneutem Öffnen der Anwendung erhalten Sie mit dem Aufruf der Rnd()-<\/b>Funktion auch das gleiche Ergebnis. Wenn Sie jedoch zuvor einmal die Randomize<\/b>-Anweisung aufrufen, wird die Rnd()<\/b>-Funktion auf Basis der Timer()<\/b>-Funktion initialisiert und liefert somit immer andere Werte.<\/p>\n In der For…Next<\/b>-Schleife durchlaufen wir die Zahlen von 1 <\/b>bis zu der mit dem Parameter intLaenge <\/b>angegebenen Zeichenzahl. In der einzigen Anweisung innerhalb der Schleife fügen wir der Variablen strKennwort <\/b>jeweils ein zufällig aus der Konstanten strZeichen <\/b>ausgewähltes Zeichen aus. Damit die Funktion Rnd() <\/b>auch genau einen der Werte von 1 <\/b>bis 87 <\/b>liefert, was dem ersten und dem letzten Zeichen der Konstanten strZeichen <\/b>entspricht, multiplizieren wir das Ergebnis der Rnd()<\/b>-Funktion, das immer einen Wert zwischen 0 <\/b>und 1 <\/b>liefert, mit der Anzahl der Zeichen, runden das Ergebnis und addieren dann den Wert 1 <\/b>hinzu. Die Mid<\/b>-Funktion ermittelt dann genau den Wert mit der angegebenen Position aus der Zeichenkette strZeichen<\/b>.<\/p>\n Nun bauen wir eine weitere, etwas leistungsfähigere Variante der Funktion. Diese erhält vier weitere Parameter mit dem Datentyp Boolean<\/b>, die wie folgt heißen:<\/p>\n Die vier Parameter legen also fest, aus welchen Zeichen das Kennwort bestehen soll.<\/p>\n Abhängig von den Angaben beim Aufruf wird die Ermittlung des Kennwort etwas aufwendiger, denn: Wir wollen nicht etwa die verschiedenen angeforderten Zeichen an einer bestimmten Stelle zurückgeben.<\/p>\n Das wäre einfach: Dann könnten wir zu Beginn einen Großbuchstaben wählen, dann einen Kleinbuchstaben, eine Zahl und schließlich ein Sonderzeichen und den Rest der angeforderten Zeichen für das Kennwort mit beliebigen Zeichen.<\/p>\n Die angeforderten Elemente, also Groß- und Kleinbuchstaben, Zahlen und Sonderzeichen, sollen in beliebiger Reihenfolge im Kennwort auftauchen. Das in einen Algorithmus zu fassen, ist mit etwas Denkarbeit verbunden.<\/p>\n Wir haben uns für den folgenden Ansatz entschieden: Wir starten mit einer Zeichenfolge als Kennwort, die ausschließlich Leerzeichen enthält. Dann prüfen wir die vier Boolean<\/b>-Parameter und fügen an zufällig ausgewählte Stellen die geforderten Zeichen hinzu. Schließlich füllen wir die noch leeren Stellen mit Zeichen aus dem kompletten Pool auf.<\/p>\n Den Ansatz finden Sie in der Funktion KennwortGenerieren<\/b>, deren ersten Teil wir in Listing 2 abgebildet haben. Hier finden Sie zunächst die Parameterliste, die aus der Anzahl der gewünschten Zeichen und den vier bereits beschriebenen Parametern besteht. Alle Parameter sind optional und erhalten den Wert True<\/b>, wenn sie beim Aufruf nicht angegeben werden.<\/p>\n <\/p>\n Listing 2: Funktion KennwortGenerieren, Teil 1<\/span><\/b><\/p>\n Die Liste der möglichen Zeichen geben wir hier nicht als einzelne Konstante an, sondern wir deklarieren vier verschiedene Konstanten, von denen jede die Zeichen eines bestimmten Typs aufnimmt – also Großbuchstaben, Kleinbuchstaben, Zahlen und Sonderzeichen.<\/p>\n Bevor die Funktion die eigentliche Aufgabe erledigt, prüft sie, ob die Anzahl der Zeichen für das Kennwort mindestens so groß ist wie die Anzahl der gewählten Optionen für die Pflichtzeichen wie Großbuchstaben et cetera. Anderenfalls bricht die Funktion mit einer Meldung ab.<\/p>\n Dann füllt die Funktion das Kennwort in der Variablen strKennwort <\/b>über die Space<\/b>-Funktion mit Leerzeichen, und zwar entsprechend der im Parameter intLaenge <\/b>angegebenen Anzahl. Die Randomize<\/b>-Anweisung initialisiert wieder die Rnd()<\/b>-Funktion. Danach prüft die Funktion, ob dem Kennwort Großbuchstaben hinzugefügt werden sollen. Das ist der Fall, wenn der Parameter bolGrossbuchstaben <\/b>den Wert True <\/b>hat. In diesem Fall ermittelt die Funktion per Rnd<\/b>-Funktion eine Position im Kennwort (in intPositionZufall<\/b>) sowie ebenfalls mit der Rnd<\/b>-Funktion eines der Element der Konstanten strGrossbuchstaben <\/b>und somit den einzufügenden Großbuchstaben (landet in strZeichenZufall<\/b>). Das Kennwort wird nun neu zusammengesetzt aus drei Zeichenketten: <\/p>\n Wenn wir also für intLaenge <\/b>den Wert 10 <\/b>übergeben haben und bolGrossbuchstaben <\/b>den Wert True <\/b>hat, erhalten wir etwa für intPositionZufall <\/b>den Wert 5 <\/b>und für strZeichenZufall <\/b>den Wert B<\/b>.<\/p>\n Unser Kennwort besteht danach also aus vier Leerzeichen, dem Buchstaben B <\/b>und weiteren fünf Leerzeichen.<\/p>\n Der letzte Schritt in dieser If…Then<\/b>-Bedingung überträgt den Inhalt der Konstanten strGrossbuchstaben <\/b>in die Variable strZeichen<\/b>. Diese verwenden wir später, wenn wir die noch leeren Stellen des Kennworts mit den zulässigen Zeichen auffüllen wollen. In diesem Fall hatte bolGrossbuchstaben <\/b>den Wert True<\/b>, also darf auch mehr als ein Großbuchstabe im Kennwort vorkommen.<\/p>\n Danach kümmern wir uns um den Parameter bolKleinbuchstaben<\/b>. Hat dieser den Wert True<\/b>, soll das Kennwort mindestens einen Kleinbuchstaben enthalten.<\/p>\n Die Aufgabe, eine geeignete Position zum Einfügen des Kleinbuchstabens zu finden, ist etwas schwieriger als beim Finden der Position für den Großbuchstaben: Während uns bei diesem Schritt noch ein komplett leeres, lediglich aus Leerzeichen bestehendes Kennwort vorlag, in das wir an einer beliebigen Stelle den ersten Großbuchstaben einsetzen konnten, ist nun schon eine Stelle mit dem Großbuchstaben besetzt.<\/p>\n Das müssen wir bei der Ermittlung der Position für den Kleinbuchstaben berücksichtigen. Dabei verwenden wir eine Do While<\/b>-Schleife, die wir solange durchlaufen, bis wir eine Position im Kennwort gefunden haben, die ein Leerzeichen enthält. Als Bedingung für das Fortführen der Do While<\/b>-Schleife verwenden wir den Wert von bolGrossbuchstaben<\/b>. Das ist deshalb praktisch, weil dieser Parameter direkt angibt, ob wir überhaupt einen Kleinbuchstaben im Kennwort benötigen.<\/p>\n Falls der Aufruf den Wert False <\/b>enthielt, wird diese Schleife gar nicht erst durchlaufen. Anderenfalls jedoch starten wir in die Schleife, indem wir eine neue Zufallsposition ermitteln und diese in der Variablen intPositionZufall <\/b>speichern.<\/p>\n Danach prüfen wir in einer If…Then<\/b>-Bedingung, ob die Position des Kennworts, die der Position aus intPositionZufall <\/b>entspricht, noch ein Leerzeichen enthält. Falls nicht, endet der erste Durchlauf der Do While<\/b>-Schleife und diese wird erneut durchlaufen. Das geschieht solange, bis wir zufällig eine Position mit einem Leerzeichen im Kennwort aus strKennwort <\/b>entdecken.<\/p>\n Ist das schließlich der Fall, ermitteln wir einen der Kleinbuchstaben aus der Konstanten strKleinbuchstaben <\/b>und speichern diesen in der Variablen strZeichenZufall<\/b>. Dann fügen wir dieses Zeichen an der gewünschten Stelle im Kennwort ein, indem wir wieder den Teil des Kennworts bis zur ermittelten Position, den zufällig ermittelten Kleinbuchstaben und den Teil des Kennworts hinter der ermittelten Position zusammensetzen.<\/p>\n Angenommen, wir hätten als Position den Wert 7 <\/b>und als Kleinbuchstaben das Zeichen c<\/b> ermittelt, würde unser Kennwort also nun etwa so aussehen (die Unterstriche dienen als Platzhalter für das Leerzeichen):<\/p>\n Auch hier fügen wir, wenn bolKleinbuchstaben <\/b>den Wert True <\/b>hat und wir einen Kleinbuchstaben in das Kennwort eingefügt haben, noch den Inhalt der Konstanten strKleinbuchstaben <\/b>zur Variablen strZeichen <\/b>hinzu, die später die restlichen Zeichen beisteuert.<\/p>\n Danach geht es auf ähnliche Weise für die Zahlen weiter. Wir durchlaufen wieder eine Do While<\/b>-Schleife, bis wir eine Position gefunden haben, die noch ein Leerzeichen enthält und fügen dann eine zufällige Zahl an der passenden Stelle ein. Die Zeichenkette strZeichen <\/b>wird dann um den Inhalt der Variablen strZahlen <\/b>erweitert.<\/p>\n Unser Kennwort könnte nun etwa so aussehen:<\/p>\n Und auf die gleiche Art fügen wir dem Kennwort noch ein Sonderzeichen hinzu, falls bolSonderzeichen <\/b>den Wert True <\/b>hat. (siehe Listing 3) Die Sonderzeichen aus strSonderzeichen <\/b>landen in diesem Fall in der Variablen strZeichen<\/b>. Danach lautet unser Kennwort etwa so:<\/p>\nPublic Function <\/span>KennwortGenerierenEinfach(intLaenge As Integer<\/span>)\r\n Const strZeichen As String<\/span> = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"\"§$%&()[]{}**#:;,.-+<>\"\r\n Dim <\/span>strKennwort As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Randomize\r\n For i = 1 To intLaenge\r\n strKennwort = strKennwort & Mid<\/span>(strZeichen, Fix(Len<\/span>(strZeichen) * Rnd) + 1, 1)\r\n Next<\/span>\r\n KennwortGenerierenEinfach = strKennwort\r\nEnd Function<\/span><\/pre>\nABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"\"§$%&()[]{}**#:;,.-+<><\/pre>\nDebug.Print<\/span> Rnd()\r\n 0,7055475 <\/pre>\nKennwort mit bestimmten Anforderungen<\/h2>\n
\n
Public Function <\/span>KennwortGenerieren(intLaenge As Integer<\/span>, Optional<\/span> bolGrossbuchstaben As Boolean<\/span> = True, _\r\n Optional<\/span> bolKleinbuchstaben As Boolean<\/span> = True, Optional<\/span> bolZahlen As Boolean<\/span> = True, _\r\n Optional<\/span> bolSonderzeichen As Boolean<\/span> = True<\/span>)\r\n Const strGrossbuchstaben As String<\/span> = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\r\n Const strKleinbuchstaben As String<\/span> = \"abcdefghijklmnopqrstuvwxyz\"\r\n Const strZahlen As String<\/span> = \"0123456789\"\r\n Const strSonderzeichen As String<\/span> = \"!\"\"§$%&()[]{}**#:;,.-+<>\"\r\n Dim <\/span>strZeichen As String<\/span>\r\n Dim <\/span>strKennwort As String<\/span>\r\n Dim <\/span>intPositionZufall As Integer<\/span>\r\n Dim <\/span>strZeichenZufall As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>intZeichen As Integer<\/span>\r\n intZeichen = Abs(bolGrossbuchstaben) + Abs(bolKleinbuchstaben) + Abs(bolZahlen) + Abs(bolSonderzeichen)\r\n If <\/span>intLaenge < intZeichen Then<\/span>\r\n MsgBox<\/span> \"Die Länge muss mindestens \" & intZeichen & \" Zeichen betragen.\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n strKennwort = Space(intLaenge)\r\n Randomize\r\n If <\/span>bolGrossbuchstaben = True<\/span> Then<\/span>\r\n intPositionZufall = Fix(intLaenge * Rnd) + 1\r\n strZeichenZufall = Mid<\/span>(strGrossbuchstaben, Fix(Len<\/span>(strGrossbuchstaben) * Rnd) + 1, 1)\r\n strKennwort = Left<\/span>(strKennwort, intPositionZufall - 1) & strZeichenZufall & Mid<\/span>(strKennwort, intPositionZufall + 1)\r\n strZeichen = strZeichen & strGrossbuchstaben\r\n End If<\/span>\r\n Do While<\/span> bolKleinbuchstaben = True<\/span>\r\n intPositionZufall = Fix(intLaenge * Rnd) + 1\r\n If <\/span>Mid<\/span>(strKennwort, intPositionZufall, 1) = \" \" Then<\/span>\r\n strZeichenZufall = Mid<\/span>(strKleinbuchstaben, Fix(Len<\/span>(strKleinbuchstaben) * Rnd) + 1, 1)\r\n strKennwort = Left<\/span>(strKennwort, intPositionZufall - 1) & strZeichenZufall & Mid<\/span>(strKennwort, _\r\n intPositionZufall + 1)\r\n bolKleinbuchstaben = False<\/span>\r\n strZeichen = strZeichen & strKleinbuchstaben\r\n End If<\/span>\r\n Loop<\/span>\r\n Do While<\/span> bolZahlen = True<\/span>\r\n intPositionZufall = Fix(intLaenge * Rnd) + 1\r\n If <\/span>Mid<\/span>(strKennwort, intPositionZufall, 1) = \" \" Then<\/span>\r\n strZeichenZufall = Mid<\/span>(strZahlen, Fix(Len<\/span>(strZahlen) * Rnd) + 1, 1)\r\n strKennwort = Left<\/span>(strKennwort, intPositionZufall - 1) & strZeichenZufall & Mid<\/span>(strKennwort, _\r\n intPositionZufall + 1)\r\n bolZahlen = False<\/span>\r\n strZeichen = strZeichen & strZahlen\r\n End If<\/span>\r\n Loop<\/span><\/pre>\n\n
____B_c___<\/pre>\n
9___B_c___<\/pre>\n
...Fortsetzung\r\n Do While<\/span> bolSonderzeichen = True<\/span>\r\n intPositionZufall = Fix(intLaenge * Rnd) + 1\r\n strZeichenZufall = Mid<\/span>(strSonderzeichen, Fix(Len<\/span>(strSonderzeichen) * Rnd) + 1, 1)\r\n If <\/span>Mid<\/span>(strKennwort, intPositionZufall, 1) = \" \" Then<\/span>\r\n strKennwort = Left<\/span>(strKennwort, intPositionZufall - 1) & strZeichenZufall & Mid<\/span>(strKennwort, _\r\n intPositionZufall + 1)\r\n bolSonderzeichen = False<\/span>\r\n strZeichen = strZeichen & strSonderzeichen\r\n End If<\/span>\r\n Loop<\/span>\r\n For i = 1 To intLaenge\r\n If <\/span>Mid<\/span>(strKennwort, i, 1) = \" \" Then<\/span>\r\n strZeichenZufall = Mid<\/span>(strZeichen, Fix(Len<\/span>(strZeichen) * Rnd) + 1, 1)\r\n strKennwort = Left<\/span>(strKennwort, i - 1) & strZeichenZufall & Mid<\/span>(strKennwort, i + 1)\r\n End If<\/span>\r\n Next<\/span>\r\n KennwortGenerieren = strKennwort\r\nEnd Function<\/span><\/pre>\n